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 54ab75253Smrj * Common Development and Distribution License (the "License"). 64ab75253Smrj * 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 */ 214ab75253Smrj 227c478bd9Sstevel@tonic-gate /* 235febcb4aSScott Carter, SD IOSW * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #include <sys/note.h> 287c478bd9Sstevel@tonic-gate #include <sys/types.h> 297c478bd9Sstevel@tonic-gate #include <sys/param.h> 307c478bd9Sstevel@tonic-gate #include <sys/systm.h> 317c478bd9Sstevel@tonic-gate #include <sys/buf.h> 327c478bd9Sstevel@tonic-gate #include <sys/uio.h> 337c478bd9Sstevel@tonic-gate #include <sys/cred.h> 347c478bd9Sstevel@tonic-gate #include <sys/poll.h> 357c478bd9Sstevel@tonic-gate #include <sys/mman.h> 367c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 377c478bd9Sstevel@tonic-gate #include <sys/model.h> 387c478bd9Sstevel@tonic-gate #include <sys/file.h> 397c478bd9Sstevel@tonic-gate #include <sys/proc.h> 407c478bd9Sstevel@tonic-gate #include <sys/open.h> 417c478bd9Sstevel@tonic-gate #include <sys/user.h> 427c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 437c478bd9Sstevel@tonic-gate #include <sys/vm.h> 447c478bd9Sstevel@tonic-gate #include <sys/stat.h> 457c478bd9Sstevel@tonic-gate #include <vm/hat.h> 467c478bd9Sstevel@tonic-gate #include <vm/seg.h> 477c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h> 487c478bd9Sstevel@tonic-gate #include <vm/seg_dev.h> 497c478bd9Sstevel@tonic-gate #include <vm/as.h> 507c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 517c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 527c478bd9Sstevel@tonic-gate #include <sys/debug.h> 537c478bd9Sstevel@tonic-gate #include <sys/autoconf.h> 547c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 557c478bd9Sstevel@tonic-gate #include <sys/esunddi.h> 567c478bd9Sstevel@tonic-gate #include <sys/sunndi.h> 577c478bd9Sstevel@tonic-gate #include <sys/kstat.h> 587c478bd9Sstevel@tonic-gate #include <sys/conf.h> 597c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> /* include implementation structure defs */ 607c478bd9Sstevel@tonic-gate #include <sys/ndi_impldefs.h> /* include prototypes */ 61dd4eeefdSeota #include <sys/ddi_timer.h> 627c478bd9Sstevel@tonic-gate #include <sys/hwconf.h> 637c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 647c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 657c478bd9Sstevel@tonic-gate #include <sys/epm.h> 667c478bd9Sstevel@tonic-gate #include <sys/devctl.h> 677c478bd9Sstevel@tonic-gate #include <sys/callb.h> 687c478bd9Sstevel@tonic-gate #include <sys/cladm.h> 697c478bd9Sstevel@tonic-gate #include <sys/sysevent.h> 707c478bd9Sstevel@tonic-gate #include <sys/dacf_impl.h> 717c478bd9Sstevel@tonic-gate #include <sys/ddidevmap.h> 727c478bd9Sstevel@tonic-gate #include <sys/bootconf.h> 737c478bd9Sstevel@tonic-gate #include <sys/disp.h> 747c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 757c478bd9Sstevel@tonic-gate #include <sys/promif.h> 767c478bd9Sstevel@tonic-gate #include <sys/instance.h> 777c478bd9Sstevel@tonic-gate #include <sys/sysevent/eventdefs.h> 787c478bd9Sstevel@tonic-gate #include <sys/task.h> 797c478bd9Sstevel@tonic-gate #include <sys/project.h> 807c478bd9Sstevel@tonic-gate #include <sys/taskq.h> 817c478bd9Sstevel@tonic-gate #include <sys/devpolicy.h> 827c478bd9Sstevel@tonic-gate #include <sys/ctype.h> 837c478bd9Sstevel@tonic-gate #include <net/if.h> 84c6939658Ssl #include <sys/rctl.h> 855679c89fSjv #include <sys/zone.h> 86d3d50737SRafael Vanoni #include <sys/clock_impl.h> 874c06356bSdh #include <sys/ddi.h> 88*a3114836SGerry Liu #include <sys/modhash.h> 89*a3114836SGerry Liu #include <sys/sunldi_impl.h> 90*a3114836SGerry Liu #include <sys/fs/dv_node.h> 91*a3114836SGerry Liu #include <sys/fs/snode.h> 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate extern pri_t minclsyspri; 947c478bd9Sstevel@tonic-gate 95c6939658Ssl extern rctl_hndl_t rc_project_locked_mem; 96c6939658Ssl extern rctl_hndl_t rc_zone_locked_mem; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate #ifdef DEBUG 997c478bd9Sstevel@tonic-gate static int sunddi_debug = 0; 1007c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate /* ddi_umem_unlock miscellaneous */ 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate static void i_ddi_umem_unlock_thread_start(void); 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate static kmutex_t ddi_umem_unlock_mutex; /* unlock list mutex */ 1077c478bd9Sstevel@tonic-gate static kcondvar_t ddi_umem_unlock_cv; /* unlock list block/unblock */ 1087c478bd9Sstevel@tonic-gate static kthread_t *ddi_umem_unlock_thread; 1097c478bd9Sstevel@tonic-gate /* 1107c478bd9Sstevel@tonic-gate * The ddi_umem_unlock FIFO list. NULL head pointer indicates empty list. 1117c478bd9Sstevel@tonic-gate */ 1127c478bd9Sstevel@tonic-gate static struct ddi_umem_cookie *ddi_umem_unlock_head = NULL; 1137c478bd9Sstevel@tonic-gate static struct ddi_umem_cookie *ddi_umem_unlock_tail = NULL; 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate /* 1167c478bd9Sstevel@tonic-gate * DDI(Sun) Function and flag definitions: 1177c478bd9Sstevel@tonic-gate */ 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate #if defined(__x86) 1207c478bd9Sstevel@tonic-gate /* 1217c478bd9Sstevel@tonic-gate * Used to indicate which entries were chosen from a range. 1227c478bd9Sstevel@tonic-gate */ 1237c478bd9Sstevel@tonic-gate char *chosen_reg = "chosen-reg"; 1247c478bd9Sstevel@tonic-gate #endif 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate /* 1277c478bd9Sstevel@tonic-gate * Function used to ring system console bell 1287c478bd9Sstevel@tonic-gate */ 1297c478bd9Sstevel@tonic-gate void (*ddi_console_bell_func)(clock_t duration); 1307c478bd9Sstevel@tonic-gate 1317c478bd9Sstevel@tonic-gate /* 1327c478bd9Sstevel@tonic-gate * Creating register mappings and handling interrupts: 1337c478bd9Sstevel@tonic-gate */ 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate /* 1367c478bd9Sstevel@tonic-gate * Generic ddi_map: Call parent to fulfill request... 1377c478bd9Sstevel@tonic-gate */ 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate int 1407c478bd9Sstevel@tonic-gate ddi_map(dev_info_t *dp, ddi_map_req_t *mp, off_t offset, 1417c478bd9Sstevel@tonic-gate off_t len, caddr_t *addrp) 1427c478bd9Sstevel@tonic-gate { 1437c478bd9Sstevel@tonic-gate dev_info_t *pdip; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate ASSERT(dp); 1467c478bd9Sstevel@tonic-gate pdip = (dev_info_t *)DEVI(dp)->devi_parent; 1477c478bd9Sstevel@tonic-gate return ((DEVI(pdip)->devi_ops->devo_bus_ops->bus_map)(pdip, 1487c478bd9Sstevel@tonic-gate dp, mp, offset, len, addrp)); 1497c478bd9Sstevel@tonic-gate } 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate /* 1527c478bd9Sstevel@tonic-gate * ddi_apply_range: (Called by nexi only.) 1537c478bd9Sstevel@tonic-gate * Apply ranges in parent node dp, to child regspec rp... 1547c478bd9Sstevel@tonic-gate */ 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate int 1577c478bd9Sstevel@tonic-gate ddi_apply_range(dev_info_t *dp, dev_info_t *rdip, struct regspec *rp) 1587c478bd9Sstevel@tonic-gate { 1597c478bd9Sstevel@tonic-gate return (i_ddi_apply_range(dp, rdip, rp)); 1607c478bd9Sstevel@tonic-gate } 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate int 1637c478bd9Sstevel@tonic-gate ddi_map_regs(dev_info_t *dip, uint_t rnumber, caddr_t *kaddrp, off_t offset, 1647c478bd9Sstevel@tonic-gate off_t len) 1657c478bd9Sstevel@tonic-gate { 1667c478bd9Sstevel@tonic-gate ddi_map_req_t mr; 1677c478bd9Sstevel@tonic-gate #if defined(__x86) 1687c478bd9Sstevel@tonic-gate struct { 1697c478bd9Sstevel@tonic-gate int bus; 1707c478bd9Sstevel@tonic-gate int addr; 1717c478bd9Sstevel@tonic-gate int size; 1727c478bd9Sstevel@tonic-gate } reg, *reglist; 1737c478bd9Sstevel@tonic-gate uint_t length; 1747c478bd9Sstevel@tonic-gate int rc; 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate /* 1777c478bd9Sstevel@tonic-gate * get the 'registers' or the 'reg' property. 1787c478bd9Sstevel@tonic-gate * We look up the reg property as an array of 1797c478bd9Sstevel@tonic-gate * int's. 1807c478bd9Sstevel@tonic-gate */ 1817c478bd9Sstevel@tonic-gate rc = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, 1827c478bd9Sstevel@tonic-gate DDI_PROP_DONTPASS, "registers", (int **)®list, &length); 1837c478bd9Sstevel@tonic-gate if (rc != DDI_PROP_SUCCESS) 1847c478bd9Sstevel@tonic-gate rc = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, 1857c478bd9Sstevel@tonic-gate DDI_PROP_DONTPASS, "reg", (int **)®list, &length); 1867c478bd9Sstevel@tonic-gate if (rc == DDI_PROP_SUCCESS) { 1877c478bd9Sstevel@tonic-gate /* 1887c478bd9Sstevel@tonic-gate * point to the required entry. 1897c478bd9Sstevel@tonic-gate */ 1907c478bd9Sstevel@tonic-gate reg = reglist[rnumber]; 1917c478bd9Sstevel@tonic-gate reg.addr += offset; 1927c478bd9Sstevel@tonic-gate if (len != 0) 1937c478bd9Sstevel@tonic-gate reg.size = len; 1947c478bd9Sstevel@tonic-gate /* 1957c478bd9Sstevel@tonic-gate * make a new property containing ONLY the required tuple. 1967c478bd9Sstevel@tonic-gate */ 1977c478bd9Sstevel@tonic-gate if (ddi_prop_update_int_array(DDI_DEV_T_NONE, dip, 1987c478bd9Sstevel@tonic-gate chosen_reg, (int *)®, (sizeof (reg)/sizeof (int))) 1997c478bd9Sstevel@tonic-gate != DDI_PROP_SUCCESS) { 2007c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s%d: cannot create '%s' " 2017c478bd9Sstevel@tonic-gate "property", DEVI(dip)->devi_name, 2027c478bd9Sstevel@tonic-gate DEVI(dip)->devi_instance, chosen_reg); 2037c478bd9Sstevel@tonic-gate } 2047c478bd9Sstevel@tonic-gate /* 2057c478bd9Sstevel@tonic-gate * free the memory allocated by 2067c478bd9Sstevel@tonic-gate * ddi_prop_lookup_int_array (). 2077c478bd9Sstevel@tonic-gate */ 2087c478bd9Sstevel@tonic-gate ddi_prop_free((void *)reglist); 2097c478bd9Sstevel@tonic-gate } 2107c478bd9Sstevel@tonic-gate #endif 2117c478bd9Sstevel@tonic-gate mr.map_op = DDI_MO_MAP_LOCKED; 2127c478bd9Sstevel@tonic-gate mr.map_type = DDI_MT_RNUMBER; 2137c478bd9Sstevel@tonic-gate mr.map_obj.rnumber = rnumber; 2147c478bd9Sstevel@tonic-gate mr.map_prot = PROT_READ | PROT_WRITE; 2157c478bd9Sstevel@tonic-gate mr.map_flags = DDI_MF_KERNEL_MAPPING; 2167c478bd9Sstevel@tonic-gate mr.map_handlep = NULL; 2177c478bd9Sstevel@tonic-gate mr.map_vers = DDI_MAP_VERSION; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* 2207c478bd9Sstevel@tonic-gate * Call my parent to map in my regs. 2217c478bd9Sstevel@tonic-gate */ 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate return (ddi_map(dip, &mr, offset, len, kaddrp)); 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate void 2277c478bd9Sstevel@tonic-gate ddi_unmap_regs(dev_info_t *dip, uint_t rnumber, caddr_t *kaddrp, off_t offset, 2287c478bd9Sstevel@tonic-gate off_t len) 2297c478bd9Sstevel@tonic-gate { 2307c478bd9Sstevel@tonic-gate ddi_map_req_t mr; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate mr.map_op = DDI_MO_UNMAP; 2337c478bd9Sstevel@tonic-gate mr.map_type = DDI_MT_RNUMBER; 2347c478bd9Sstevel@tonic-gate mr.map_flags = DDI_MF_KERNEL_MAPPING; 2357c478bd9Sstevel@tonic-gate mr.map_prot = PROT_READ | PROT_WRITE; /* who cares? */ 2367c478bd9Sstevel@tonic-gate mr.map_obj.rnumber = rnumber; 2377c478bd9Sstevel@tonic-gate mr.map_handlep = NULL; 2387c478bd9Sstevel@tonic-gate mr.map_vers = DDI_MAP_VERSION; 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate /* 2417c478bd9Sstevel@tonic-gate * Call my parent to unmap my regs. 2427c478bd9Sstevel@tonic-gate */ 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate (void) ddi_map(dip, &mr, offset, len, kaddrp); 2457c478bd9Sstevel@tonic-gate *kaddrp = (caddr_t)0; 2467c478bd9Sstevel@tonic-gate #if defined(__x86) 2477c478bd9Sstevel@tonic-gate (void) ddi_prop_remove(DDI_DEV_T_NONE, dip, chosen_reg); 2487c478bd9Sstevel@tonic-gate #endif 2497c478bd9Sstevel@tonic-gate } 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate int 2527c478bd9Sstevel@tonic-gate ddi_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp, 2537c478bd9Sstevel@tonic-gate off_t offset, off_t len, caddr_t *vaddrp) 2547c478bd9Sstevel@tonic-gate { 2557c478bd9Sstevel@tonic-gate return (i_ddi_bus_map(dip, rdip, mp, offset, len, vaddrp)); 2567c478bd9Sstevel@tonic-gate } 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate /* 2597c478bd9Sstevel@tonic-gate * nullbusmap: The/DDI default bus_map entry point for nexi 2607c478bd9Sstevel@tonic-gate * not conforming to the reg/range paradigm (i.e. scsi, etc.) 2617c478bd9Sstevel@tonic-gate * with no HAT/MMU layer to be programmed at this level. 2627c478bd9Sstevel@tonic-gate * 2637c478bd9Sstevel@tonic-gate * If the call is to map by rnumber, return an error, 2647c478bd9Sstevel@tonic-gate * otherwise pass anything else up the tree to my parent. 2657c478bd9Sstevel@tonic-gate */ 2667c478bd9Sstevel@tonic-gate int 2677c478bd9Sstevel@tonic-gate nullbusmap(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp, 2687c478bd9Sstevel@tonic-gate off_t offset, off_t len, caddr_t *vaddrp) 2697c478bd9Sstevel@tonic-gate { 2707c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(rdip)) 2717c478bd9Sstevel@tonic-gate if (mp->map_type == DDI_MT_RNUMBER) 2727c478bd9Sstevel@tonic-gate return (DDI_ME_UNSUPPORTED); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate return (ddi_map(dip, mp, offset, len, vaddrp)); 2757c478bd9Sstevel@tonic-gate } 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate /* 2787c478bd9Sstevel@tonic-gate * ddi_rnumber_to_regspec: Not for use by leaf drivers. 2797c478bd9Sstevel@tonic-gate * Only for use by nexi using the reg/range paradigm. 2807c478bd9Sstevel@tonic-gate */ 2817c478bd9Sstevel@tonic-gate struct regspec * 2827c478bd9Sstevel@tonic-gate ddi_rnumber_to_regspec(dev_info_t *dip, int rnumber) 2837c478bd9Sstevel@tonic-gate { 2847c478bd9Sstevel@tonic-gate return (i_ddi_rnumber_to_regspec(dip, rnumber)); 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate /* 2897c478bd9Sstevel@tonic-gate * Note that we allow the dip to be nil because we may be called 2907c478bd9Sstevel@tonic-gate * prior even to the instantiation of the devinfo tree itself - all 2917c478bd9Sstevel@tonic-gate * regular leaf and nexus drivers should always use a non-nil dip! 2927c478bd9Sstevel@tonic-gate * 2937c478bd9Sstevel@tonic-gate * We treat peek in a somewhat cavalier fashion .. assuming that we'll 2947c478bd9Sstevel@tonic-gate * simply get a synchronous fault as soon as we touch a missing address. 2957c478bd9Sstevel@tonic-gate * 2967c478bd9Sstevel@tonic-gate * Poke is rather more carefully handled because we might poke to a write 2977c478bd9Sstevel@tonic-gate * buffer, "succeed", then only find some time later that we got an 2987c478bd9Sstevel@tonic-gate * asynchronous fault that indicated that the address we were writing to 2997c478bd9Sstevel@tonic-gate * was not really backed by hardware. 3007c478bd9Sstevel@tonic-gate */ 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate static int 3037c478bd9Sstevel@tonic-gate i_ddi_peekpoke(dev_info_t *devi, ddi_ctl_enum_t cmd, size_t size, 3047c478bd9Sstevel@tonic-gate void *addr, void *value_p) 3057c478bd9Sstevel@tonic-gate { 3067c478bd9Sstevel@tonic-gate union { 3077c478bd9Sstevel@tonic-gate uint64_t u64; 3087c478bd9Sstevel@tonic-gate uint32_t u32; 3097c478bd9Sstevel@tonic-gate uint16_t u16; 3107c478bd9Sstevel@tonic-gate uint8_t u8; 3117c478bd9Sstevel@tonic-gate } peekpoke_value; 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate peekpoke_ctlops_t peekpoke_args; 3147c478bd9Sstevel@tonic-gate uint64_t dummy_result; 3157c478bd9Sstevel@tonic-gate int rval; 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate /* Note: size is assumed to be correct; it is not checked. */ 3187c478bd9Sstevel@tonic-gate peekpoke_args.size = size; 319abdbd06dSagiri peekpoke_args.dev_addr = (uintptr_t)addr; 3207c478bd9Sstevel@tonic-gate peekpoke_args.handle = NULL; 3217c478bd9Sstevel@tonic-gate peekpoke_args.repcount = 1; 3227c478bd9Sstevel@tonic-gate peekpoke_args.flags = 0; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate if (cmd == DDI_CTLOPS_POKE) { 3257c478bd9Sstevel@tonic-gate switch (size) { 3267c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 3277c478bd9Sstevel@tonic-gate peekpoke_value.u8 = *(uint8_t *)value_p; 3287c478bd9Sstevel@tonic-gate break; 3297c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 3307c478bd9Sstevel@tonic-gate peekpoke_value.u16 = *(uint16_t *)value_p; 3317c478bd9Sstevel@tonic-gate break; 3327c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 3337c478bd9Sstevel@tonic-gate peekpoke_value.u32 = *(uint32_t *)value_p; 3347c478bd9Sstevel@tonic-gate break; 3357c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 3367c478bd9Sstevel@tonic-gate peekpoke_value.u64 = *(uint64_t *)value_p; 3377c478bd9Sstevel@tonic-gate break; 3387c478bd9Sstevel@tonic-gate } 3397c478bd9Sstevel@tonic-gate } 3407c478bd9Sstevel@tonic-gate 341abdbd06dSagiri peekpoke_args.host_addr = (uintptr_t)&peekpoke_value.u64; 3427c478bd9Sstevel@tonic-gate 3437c478bd9Sstevel@tonic-gate if (devi != NULL) 3447c478bd9Sstevel@tonic-gate rval = ddi_ctlops(devi, devi, cmd, &peekpoke_args, 3457c478bd9Sstevel@tonic-gate &dummy_result); 3467c478bd9Sstevel@tonic-gate else 3477c478bd9Sstevel@tonic-gate rval = peekpoke_mem(cmd, &peekpoke_args); 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * A NULL value_p is permitted by ddi_peek(9F); discard the result. 3517c478bd9Sstevel@tonic-gate */ 3527c478bd9Sstevel@tonic-gate if ((cmd == DDI_CTLOPS_PEEK) & (value_p != NULL)) { 3537c478bd9Sstevel@tonic-gate switch (size) { 3547c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 3557c478bd9Sstevel@tonic-gate *(uint8_t *)value_p = peekpoke_value.u8; 3567c478bd9Sstevel@tonic-gate break; 3577c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 3587c478bd9Sstevel@tonic-gate *(uint16_t *)value_p = peekpoke_value.u16; 3597c478bd9Sstevel@tonic-gate break; 3607c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 3617c478bd9Sstevel@tonic-gate *(uint32_t *)value_p = peekpoke_value.u32; 3627c478bd9Sstevel@tonic-gate break; 3637c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 3647c478bd9Sstevel@tonic-gate *(uint64_t *)value_p = peekpoke_value.u64; 3657c478bd9Sstevel@tonic-gate break; 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate return (rval); 3707c478bd9Sstevel@tonic-gate } 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate /* 3737c478bd9Sstevel@tonic-gate * Keep ddi_peek() and ddi_poke() in case 3rd parties are calling this. 3747c478bd9Sstevel@tonic-gate * they shouldn't be, but the 9f manpage kind of pseudo exposes it. 3757c478bd9Sstevel@tonic-gate */ 3767c478bd9Sstevel@tonic-gate int 3777c478bd9Sstevel@tonic-gate ddi_peek(dev_info_t *devi, size_t size, void *addr, void *value_p) 3787c478bd9Sstevel@tonic-gate { 3797c478bd9Sstevel@tonic-gate switch (size) { 3807c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 3817c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 3827c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 3837c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 3847c478bd9Sstevel@tonic-gate break; 3857c478bd9Sstevel@tonic-gate default: 3867c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(devi, DDI_CTLOPS_PEEK, size, addr, value_p)); 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate int 3937c478bd9Sstevel@tonic-gate ddi_poke(dev_info_t *devi, size_t size, void *addr, void *value_p) 3947c478bd9Sstevel@tonic-gate { 3957c478bd9Sstevel@tonic-gate switch (size) { 3967c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 3977c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 3987c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 3997c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 4007c478bd9Sstevel@tonic-gate break; 4017c478bd9Sstevel@tonic-gate default: 4027c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(devi, DDI_CTLOPS_POKE, size, addr, value_p)); 4067c478bd9Sstevel@tonic-gate } 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate int 4097c478bd9Sstevel@tonic-gate ddi_peek8(dev_info_t *dip, int8_t *addr, int8_t *val_p) 4107c478bd9Sstevel@tonic-gate { 4117c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4127c478bd9Sstevel@tonic-gate val_p)); 4137c478bd9Sstevel@tonic-gate } 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate int 4167c478bd9Sstevel@tonic-gate ddi_peek16(dev_info_t *dip, int16_t *addr, int16_t *val_p) 4177c478bd9Sstevel@tonic-gate { 4187c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4197c478bd9Sstevel@tonic-gate val_p)); 4207c478bd9Sstevel@tonic-gate } 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate int 4237c478bd9Sstevel@tonic-gate ddi_peek32(dev_info_t *dip, int32_t *addr, int32_t *val_p) 4247c478bd9Sstevel@tonic-gate { 4257c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4267c478bd9Sstevel@tonic-gate val_p)); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate int 4307c478bd9Sstevel@tonic-gate ddi_peek64(dev_info_t *dip, int64_t *addr, int64_t *val_p) 4314ab75253Smrj { 4324ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4334ab75253Smrj val_p)); 4344ab75253Smrj } 4354ab75253Smrj 4364ab75253Smrj 4374ab75253Smrj /* 4384ab75253Smrj * We need to separate the old interfaces from the new ones and leave them 4394ab75253Smrj * in here for a while. Previous versions of the OS defined the new interfaces 4404ab75253Smrj * to the old interfaces. This way we can fix things up so that we can 4414ab75253Smrj * eventually remove these interfaces. 4424ab75253Smrj * e.g. A 3rd party module/driver using ddi_peek8 and built against S10 4434ab75253Smrj * or earlier will actually have a reference to ddi_peekc in the binary. 4444ab75253Smrj */ 4454ab75253Smrj #ifdef _ILP32 4464ab75253Smrj int 4474ab75253Smrj ddi_peekc(dev_info_t *dip, int8_t *addr, int8_t *val_p) 4484ab75253Smrj { 4494ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4504ab75253Smrj val_p)); 4514ab75253Smrj } 4524ab75253Smrj 4534ab75253Smrj int 4544ab75253Smrj ddi_peeks(dev_info_t *dip, int16_t *addr, int16_t *val_p) 4554ab75253Smrj { 4564ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4574ab75253Smrj val_p)); 4584ab75253Smrj } 4594ab75253Smrj 4604ab75253Smrj int 4614ab75253Smrj ddi_peekl(dev_info_t *dip, int32_t *addr, int32_t *val_p) 4624ab75253Smrj { 4634ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4644ab75253Smrj val_p)); 4654ab75253Smrj } 4664ab75253Smrj 4677c478bd9Sstevel@tonic-gate int 4687c478bd9Sstevel@tonic-gate ddi_peekd(dev_info_t *dip, int64_t *addr, int64_t *val_p) 4697c478bd9Sstevel@tonic-gate { 4707c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr, 4717c478bd9Sstevel@tonic-gate val_p)); 4727c478bd9Sstevel@tonic-gate } 4734ab75253Smrj #endif /* _ILP32 */ 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate int 4767c478bd9Sstevel@tonic-gate ddi_poke8(dev_info_t *dip, int8_t *addr, int8_t val) 4777c478bd9Sstevel@tonic-gate { 4787c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate int 4827c478bd9Sstevel@tonic-gate ddi_poke16(dev_info_t *dip, int16_t *addr, int16_t val) 4837c478bd9Sstevel@tonic-gate { 4847c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 4857c478bd9Sstevel@tonic-gate } 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate int 4887c478bd9Sstevel@tonic-gate ddi_poke32(dev_info_t *dip, int32_t *addr, int32_t val) 4897c478bd9Sstevel@tonic-gate { 4907c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 4917c478bd9Sstevel@tonic-gate } 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate int 4947c478bd9Sstevel@tonic-gate ddi_poke64(dev_info_t *dip, int64_t *addr, int64_t val) 4954ab75253Smrj { 4964ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 4974ab75253Smrj } 4984ab75253Smrj 4994ab75253Smrj /* 5004ab75253Smrj * We need to separate the old interfaces from the new ones and leave them 5014ab75253Smrj * in here for a while. Previous versions of the OS defined the new interfaces 5024ab75253Smrj * to the old interfaces. This way we can fix things up so that we can 5034ab75253Smrj * eventually remove these interfaces. 5044ab75253Smrj * e.g. A 3rd party module/driver using ddi_poke8 and built against S10 5054ab75253Smrj * or earlier will actually have a reference to ddi_pokec in the binary. 5064ab75253Smrj */ 5074ab75253Smrj #ifdef _ILP32 5084ab75253Smrj int 5094ab75253Smrj ddi_pokec(dev_info_t *dip, int8_t *addr, int8_t val) 5104ab75253Smrj { 5114ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 5124ab75253Smrj } 5134ab75253Smrj 5144ab75253Smrj int 5154ab75253Smrj ddi_pokes(dev_info_t *dip, int16_t *addr, int16_t val) 5164ab75253Smrj { 5174ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 5184ab75253Smrj } 5194ab75253Smrj 5204ab75253Smrj int 5214ab75253Smrj ddi_pokel(dev_info_t *dip, int32_t *addr, int32_t val) 5224ab75253Smrj { 5234ab75253Smrj return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 5244ab75253Smrj } 5254ab75253Smrj 5267c478bd9Sstevel@tonic-gate int 5277c478bd9Sstevel@tonic-gate ddi_poked(dev_info_t *dip, int64_t *addr, int64_t val) 5287c478bd9Sstevel@tonic-gate { 5297c478bd9Sstevel@tonic-gate return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val)); 5307c478bd9Sstevel@tonic-gate } 5314ab75253Smrj #endif /* _ILP32 */ 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate /* 5347c478bd9Sstevel@tonic-gate * ddi_peekpokeio() is used primarily by the mem drivers for moving 5357c478bd9Sstevel@tonic-gate * data to and from uio structures via peek and poke. Note that we 5367c478bd9Sstevel@tonic-gate * use "internal" routines ddi_peek and ddi_poke to make this go 5377c478bd9Sstevel@tonic-gate * slightly faster, avoiding the call overhead .. 5387c478bd9Sstevel@tonic-gate */ 5397c478bd9Sstevel@tonic-gate int 5407c478bd9Sstevel@tonic-gate ddi_peekpokeio(dev_info_t *devi, struct uio *uio, enum uio_rw rw, 5417c478bd9Sstevel@tonic-gate caddr_t addr, size_t len, uint_t xfersize) 5427c478bd9Sstevel@tonic-gate { 5437c478bd9Sstevel@tonic-gate int64_t ibuffer; 5447c478bd9Sstevel@tonic-gate int8_t w8; 5457c478bd9Sstevel@tonic-gate size_t sz; 5467c478bd9Sstevel@tonic-gate int o; 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate if (xfersize > sizeof (long)) 5497c478bd9Sstevel@tonic-gate xfersize = sizeof (long); 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate while (len != 0) { 5527c478bd9Sstevel@tonic-gate if ((len | (uintptr_t)addr) & 1) { 5537c478bd9Sstevel@tonic-gate sz = sizeof (int8_t); 5547c478bd9Sstevel@tonic-gate if (rw == UIO_WRITE) { 5557c478bd9Sstevel@tonic-gate if ((o = uwritec(uio)) == -1) 5567c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 5577c478bd9Sstevel@tonic-gate if (ddi_poke8(devi, (int8_t *)addr, 5587c478bd9Sstevel@tonic-gate (int8_t)o) != DDI_SUCCESS) 5597c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 5607c478bd9Sstevel@tonic-gate } else { 5617c478bd9Sstevel@tonic-gate if (i_ddi_peekpoke(devi, DDI_CTLOPS_PEEK, sz, 5627c478bd9Sstevel@tonic-gate (int8_t *)addr, &w8) != DDI_SUCCESS) 5637c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 5647c478bd9Sstevel@tonic-gate if (ureadc(w8, uio)) 5657c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 5667c478bd9Sstevel@tonic-gate } 5677c478bd9Sstevel@tonic-gate } else { 5687c478bd9Sstevel@tonic-gate switch (xfersize) { 5697c478bd9Sstevel@tonic-gate case sizeof (int64_t): 5707c478bd9Sstevel@tonic-gate if (((len | (uintptr_t)addr) & 5717c478bd9Sstevel@tonic-gate (sizeof (int64_t) - 1)) == 0) { 5727c478bd9Sstevel@tonic-gate sz = xfersize; 5737c478bd9Sstevel@tonic-gate break; 5747c478bd9Sstevel@tonic-gate } 5757c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 5767c478bd9Sstevel@tonic-gate case sizeof (int32_t): 5777c478bd9Sstevel@tonic-gate if (((len | (uintptr_t)addr) & 5787c478bd9Sstevel@tonic-gate (sizeof (int32_t) - 1)) == 0) { 5797c478bd9Sstevel@tonic-gate sz = xfersize; 5807c478bd9Sstevel@tonic-gate break; 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 5837c478bd9Sstevel@tonic-gate default: 5847c478bd9Sstevel@tonic-gate /* 5857c478bd9Sstevel@tonic-gate * This still assumes that we might have an 5867c478bd9Sstevel@tonic-gate * I/O bus out there that permits 16-bit 5877c478bd9Sstevel@tonic-gate * transfers (and that it would be upset by 5887c478bd9Sstevel@tonic-gate * 32-bit transfers from such locations). 5897c478bd9Sstevel@tonic-gate */ 5907c478bd9Sstevel@tonic-gate sz = sizeof (int16_t); 5917c478bd9Sstevel@tonic-gate break; 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate if (rw == UIO_READ) { 5957c478bd9Sstevel@tonic-gate if (i_ddi_peekpoke(devi, DDI_CTLOPS_PEEK, sz, 5967c478bd9Sstevel@tonic-gate addr, &ibuffer) != DDI_SUCCESS) 5977c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 5987c478bd9Sstevel@tonic-gate } 5997c478bd9Sstevel@tonic-gate 6007c478bd9Sstevel@tonic-gate if (uiomove(&ibuffer, sz, rw, uio)) 6017c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate if (rw == UIO_WRITE) { 6047c478bd9Sstevel@tonic-gate if (i_ddi_peekpoke(devi, DDI_CTLOPS_POKE, sz, 6057c478bd9Sstevel@tonic-gate addr, &ibuffer) != DDI_SUCCESS) 6067c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate } 6097c478bd9Sstevel@tonic-gate addr += sz; 6107c478bd9Sstevel@tonic-gate len -= sz; 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate /* 6167c478bd9Sstevel@tonic-gate * These routines are used by drivers that do layered ioctls 6177c478bd9Sstevel@tonic-gate * On sparc, they're implemented in assembler to avoid spilling 6187c478bd9Sstevel@tonic-gate * register windows in the common (copyin) case .. 6197c478bd9Sstevel@tonic-gate */ 6207c478bd9Sstevel@tonic-gate #if !defined(__sparc) 6217c478bd9Sstevel@tonic-gate int 6227c478bd9Sstevel@tonic-gate ddi_copyin(const void *buf, void *kernbuf, size_t size, int flags) 6237c478bd9Sstevel@tonic-gate { 6247c478bd9Sstevel@tonic-gate if (flags & FKIOCTL) 6257c478bd9Sstevel@tonic-gate return (kcopy(buf, kernbuf, size) ? -1 : 0); 6267c478bd9Sstevel@tonic-gate return (copyin(buf, kernbuf, size)); 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate int 6307c478bd9Sstevel@tonic-gate ddi_copyout(const void *buf, void *kernbuf, size_t size, int flags) 6317c478bd9Sstevel@tonic-gate { 6327c478bd9Sstevel@tonic-gate if (flags & FKIOCTL) 6337c478bd9Sstevel@tonic-gate return (kcopy(buf, kernbuf, size) ? -1 : 0); 6347c478bd9Sstevel@tonic-gate return (copyout(buf, kernbuf, size)); 6357c478bd9Sstevel@tonic-gate } 6367c478bd9Sstevel@tonic-gate #endif /* !__sparc */ 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate /* 6397c478bd9Sstevel@tonic-gate * Conversions in nexus pagesize units. We don't duplicate the 6407c478bd9Sstevel@tonic-gate * 'nil dip' semantics of peek/poke because btopr/btop/ptob are DDI/DKI 6417c478bd9Sstevel@tonic-gate * routines anyway. 6427c478bd9Sstevel@tonic-gate */ 6437c478bd9Sstevel@tonic-gate unsigned long 6447c478bd9Sstevel@tonic-gate ddi_btop(dev_info_t *dip, unsigned long bytes) 6457c478bd9Sstevel@tonic-gate { 6467c478bd9Sstevel@tonic-gate unsigned long pages; 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate (void) ddi_ctlops(dip, dip, DDI_CTLOPS_BTOP, &bytes, &pages); 6497c478bd9Sstevel@tonic-gate return (pages); 6507c478bd9Sstevel@tonic-gate } 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate unsigned long 6537c478bd9Sstevel@tonic-gate ddi_btopr(dev_info_t *dip, unsigned long bytes) 6547c478bd9Sstevel@tonic-gate { 6557c478bd9Sstevel@tonic-gate unsigned long pages; 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate (void) ddi_ctlops(dip, dip, DDI_CTLOPS_BTOPR, &bytes, &pages); 6587c478bd9Sstevel@tonic-gate return (pages); 6597c478bd9Sstevel@tonic-gate } 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate unsigned long 6627c478bd9Sstevel@tonic-gate ddi_ptob(dev_info_t *dip, unsigned long pages) 6637c478bd9Sstevel@tonic-gate { 6647c478bd9Sstevel@tonic-gate unsigned long bytes; 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate (void) ddi_ctlops(dip, dip, DDI_CTLOPS_PTOB, &pages, &bytes); 6677c478bd9Sstevel@tonic-gate return (bytes); 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate unsigned int 6717c478bd9Sstevel@tonic-gate ddi_enter_critical(void) 6727c478bd9Sstevel@tonic-gate { 6737c478bd9Sstevel@tonic-gate return ((uint_t)spl7()); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate void 6777c478bd9Sstevel@tonic-gate ddi_exit_critical(unsigned int spl) 6787c478bd9Sstevel@tonic-gate { 6797c478bd9Sstevel@tonic-gate splx((int)spl); 6807c478bd9Sstevel@tonic-gate } 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate /* 6837c478bd9Sstevel@tonic-gate * Nexus ctlops punter 6847c478bd9Sstevel@tonic-gate */ 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate #if !defined(__sparc) 6877c478bd9Sstevel@tonic-gate /* 6887c478bd9Sstevel@tonic-gate * Request bus_ctl parent to handle a bus_ctl request 6897c478bd9Sstevel@tonic-gate * 6907c478bd9Sstevel@tonic-gate * (The sparc version is in sparc_ddi.s) 6917c478bd9Sstevel@tonic-gate */ 6927c478bd9Sstevel@tonic-gate int 6937c478bd9Sstevel@tonic-gate ddi_ctlops(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t op, void *a, void *v) 6947c478bd9Sstevel@tonic-gate { 6957c478bd9Sstevel@tonic-gate int (*fp)(); 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate if (!d || !r) 6987c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate if ((d = (dev_info_t *)DEVI(d)->devi_bus_ctl) == NULL) 7017c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate fp = DEVI(d)->devi_ops->devo_bus_ops->bus_ctl; 7047c478bd9Sstevel@tonic-gate return ((*fp)(d, r, op, a, v)); 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate #endif 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate /* 7107c478bd9Sstevel@tonic-gate * DMA/DVMA setup 7117c478bd9Sstevel@tonic-gate */ 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate #if defined(__sparc) 7147c478bd9Sstevel@tonic-gate static ddi_dma_lim_t standard_limits = { 7157c478bd9Sstevel@tonic-gate (uint_t)0, /* addr_t dlim_addr_lo */ 7167c478bd9Sstevel@tonic-gate (uint_t)-1, /* addr_t dlim_addr_hi */ 7177c478bd9Sstevel@tonic-gate (uint_t)-1, /* uint_t dlim_cntr_max */ 7187c478bd9Sstevel@tonic-gate (uint_t)1, /* uint_t dlim_burstsizes */ 7197c478bd9Sstevel@tonic-gate (uint_t)1, /* uint_t dlim_minxfer */ 7207c478bd9Sstevel@tonic-gate 0 /* uint_t dlim_dmaspeed */ 7217c478bd9Sstevel@tonic-gate }; 7227c478bd9Sstevel@tonic-gate #elif defined(__x86) 7237c478bd9Sstevel@tonic-gate static ddi_dma_lim_t standard_limits = { 7247c478bd9Sstevel@tonic-gate (uint_t)0, /* addr_t dlim_addr_lo */ 7257c478bd9Sstevel@tonic-gate (uint_t)0xffffff, /* addr_t dlim_addr_hi */ 7267c478bd9Sstevel@tonic-gate (uint_t)0, /* uint_t dlim_cntr_max */ 7277c478bd9Sstevel@tonic-gate (uint_t)0x00000001, /* uint_t dlim_burstsizes */ 7287c478bd9Sstevel@tonic-gate (uint_t)DMA_UNIT_8, /* uint_t dlim_minxfer */ 7297c478bd9Sstevel@tonic-gate (uint_t)0, /* uint_t dlim_dmaspeed */ 7307c478bd9Sstevel@tonic-gate (uint_t)0x86<<24+0, /* uint_t dlim_version */ 7317c478bd9Sstevel@tonic-gate (uint_t)0xffff, /* uint_t dlim_adreg_max */ 7327c478bd9Sstevel@tonic-gate (uint_t)0xffff, /* uint_t dlim_ctreg_max */ 7337c478bd9Sstevel@tonic-gate (uint_t)512, /* uint_t dlim_granular */ 7347c478bd9Sstevel@tonic-gate (int)1, /* int dlim_sgllen */ 7357c478bd9Sstevel@tonic-gate (uint_t)0xffffffff /* uint_t dlim_reqsizes */ 7367c478bd9Sstevel@tonic-gate }; 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate #endif 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate int 7417c478bd9Sstevel@tonic-gate ddi_dma_setup(dev_info_t *dip, struct ddi_dma_req *dmareqp, 7427c478bd9Sstevel@tonic-gate ddi_dma_handle_t *handlep) 7437c478bd9Sstevel@tonic-gate { 7447c478bd9Sstevel@tonic-gate int (*funcp)() = ddi_dma_map; 7457c478bd9Sstevel@tonic-gate struct bus_ops *bop; 7467c478bd9Sstevel@tonic-gate #if defined(__sparc) 7477c478bd9Sstevel@tonic-gate auto ddi_dma_lim_t dma_lim; 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate if (dmareqp->dmar_limits == (ddi_dma_lim_t *)0) { 7507c478bd9Sstevel@tonic-gate dma_lim = standard_limits; 7517c478bd9Sstevel@tonic-gate } else { 7527c478bd9Sstevel@tonic-gate dma_lim = *dmareqp->dmar_limits; 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate dmareqp->dmar_limits = &dma_lim; 7557c478bd9Sstevel@tonic-gate #endif 7567c478bd9Sstevel@tonic-gate #if defined(__x86) 7577c478bd9Sstevel@tonic-gate if (dmareqp->dmar_limits == (ddi_dma_lim_t *)0) 7587c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 7597c478bd9Sstevel@tonic-gate #endif 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate /* 7627c478bd9Sstevel@tonic-gate * Handle the case that the requester is both a leaf 7637c478bd9Sstevel@tonic-gate * and a nexus driver simultaneously by calling the 7647c478bd9Sstevel@tonic-gate * requester's bus_dma_map function directly instead 7657c478bd9Sstevel@tonic-gate * of ddi_dma_map. 7667c478bd9Sstevel@tonic-gate */ 7677c478bd9Sstevel@tonic-gate bop = DEVI(dip)->devi_ops->devo_bus_ops; 7687c478bd9Sstevel@tonic-gate if (bop && bop->bus_dma_map) 7697c478bd9Sstevel@tonic-gate funcp = bop->bus_dma_map; 7707c478bd9Sstevel@tonic-gate return ((*funcp)(dip, dip, dmareqp, handlep)); 7717c478bd9Sstevel@tonic-gate } 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate int 7747c478bd9Sstevel@tonic-gate ddi_dma_addr_setup(dev_info_t *dip, struct as *as, caddr_t addr, size_t len, 7757c478bd9Sstevel@tonic-gate uint_t flags, int (*waitfp)(), caddr_t arg, 7767c478bd9Sstevel@tonic-gate ddi_dma_lim_t *limits, ddi_dma_handle_t *handlep) 7777c478bd9Sstevel@tonic-gate { 7787c478bd9Sstevel@tonic-gate int (*funcp)() = ddi_dma_map; 7797c478bd9Sstevel@tonic-gate ddi_dma_lim_t dma_lim; 7807c478bd9Sstevel@tonic-gate struct ddi_dma_req dmareq; 7817c478bd9Sstevel@tonic-gate struct bus_ops *bop; 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate if (len == 0) { 7847c478bd9Sstevel@tonic-gate return (DDI_DMA_NOMAPPING); 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate if (limits == (ddi_dma_lim_t *)0) { 7877c478bd9Sstevel@tonic-gate dma_lim = standard_limits; 7887c478bd9Sstevel@tonic-gate } else { 7897c478bd9Sstevel@tonic-gate dma_lim = *limits; 7907c478bd9Sstevel@tonic-gate } 7917c478bd9Sstevel@tonic-gate dmareq.dmar_limits = &dma_lim; 7927c478bd9Sstevel@tonic-gate dmareq.dmar_flags = flags; 7937c478bd9Sstevel@tonic-gate dmareq.dmar_fp = waitfp; 7947c478bd9Sstevel@tonic-gate dmareq.dmar_arg = arg; 7957c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_size = len; 7967c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = DMA_OTYP_VADDR; 7977c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_as = as; 7987c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_addr = addr; 7997c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_priv = NULL; 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate /* 8027c478bd9Sstevel@tonic-gate * Handle the case that the requester is both a leaf 8037c478bd9Sstevel@tonic-gate * and a nexus driver simultaneously by calling the 8047c478bd9Sstevel@tonic-gate * requester's bus_dma_map function directly instead 8057c478bd9Sstevel@tonic-gate * of ddi_dma_map. 8067c478bd9Sstevel@tonic-gate */ 8077c478bd9Sstevel@tonic-gate bop = DEVI(dip)->devi_ops->devo_bus_ops; 8087c478bd9Sstevel@tonic-gate if (bop && bop->bus_dma_map) 8097c478bd9Sstevel@tonic-gate funcp = bop->bus_dma_map; 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate return ((*funcp)(dip, dip, &dmareq, handlep)); 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate int 8157c478bd9Sstevel@tonic-gate ddi_dma_buf_setup(dev_info_t *dip, struct buf *bp, uint_t flags, 8167c478bd9Sstevel@tonic-gate int (*waitfp)(), caddr_t arg, ddi_dma_lim_t *limits, 8177c478bd9Sstevel@tonic-gate ddi_dma_handle_t *handlep) 8187c478bd9Sstevel@tonic-gate { 8197c478bd9Sstevel@tonic-gate int (*funcp)() = ddi_dma_map; 8207c478bd9Sstevel@tonic-gate ddi_dma_lim_t dma_lim; 8217c478bd9Sstevel@tonic-gate struct ddi_dma_req dmareq; 8227c478bd9Sstevel@tonic-gate struct bus_ops *bop; 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate if (limits == (ddi_dma_lim_t *)0) { 8257c478bd9Sstevel@tonic-gate dma_lim = standard_limits; 8267c478bd9Sstevel@tonic-gate } else { 8277c478bd9Sstevel@tonic-gate dma_lim = *limits; 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate dmareq.dmar_limits = &dma_lim; 8307c478bd9Sstevel@tonic-gate dmareq.dmar_flags = flags; 8317c478bd9Sstevel@tonic-gate dmareq.dmar_fp = waitfp; 8327c478bd9Sstevel@tonic-gate dmareq.dmar_arg = arg; 8337c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_size = (uint_t)bp->b_bcount; 8347c478bd9Sstevel@tonic-gate 8352d3bf78eScth if (bp->b_flags & B_PAGEIO) { 8367c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = DMA_OTYP_PAGES; 8377c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.pp_obj.pp_pp = bp->b_pages; 8387c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.pp_obj.pp_offset = 8397c478bd9Sstevel@tonic-gate (uint_t)(((uintptr_t)bp->b_un.b_addr) & MMU_PAGEOFFSET); 8407c478bd9Sstevel@tonic-gate } else { 8417c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = DMA_OTYP_BUFVADDR; 8427c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_addr = bp->b_un.b_addr; 8432d3bf78eScth if (bp->b_flags & B_SHADOW) { 8447c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_priv = 845184cd04cScth bp->b_shadow; 8467c478bd9Sstevel@tonic-gate } else { 8477c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_priv = NULL; 8487c478bd9Sstevel@tonic-gate } 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate /* 8517c478bd9Sstevel@tonic-gate * If the buffer has no proc pointer, or the proc 8527c478bd9Sstevel@tonic-gate * struct has the kernel address space, or the buffer has 8537c478bd9Sstevel@tonic-gate * been marked B_REMAPPED (meaning that it is now 8547c478bd9Sstevel@tonic-gate * mapped into the kernel's address space), then 8557c478bd9Sstevel@tonic-gate * the address space is kas (kernel address space). 8567c478bd9Sstevel@tonic-gate */ 8572d3bf78eScth if ((bp->b_proc == NULL) || (bp->b_proc->p_as == &kas) || 8582d3bf78eScth (bp->b_flags & B_REMAPPED)) { 8597c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_as = 0; 8607c478bd9Sstevel@tonic-gate } else { 8617c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_as = 8627c478bd9Sstevel@tonic-gate bp->b_proc->p_as; 8637c478bd9Sstevel@tonic-gate } 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate /* 8677c478bd9Sstevel@tonic-gate * Handle the case that the requester is both a leaf 8687c478bd9Sstevel@tonic-gate * and a nexus driver simultaneously by calling the 8697c478bd9Sstevel@tonic-gate * requester's bus_dma_map function directly instead 8707c478bd9Sstevel@tonic-gate * of ddi_dma_map. 8717c478bd9Sstevel@tonic-gate */ 8727c478bd9Sstevel@tonic-gate bop = DEVI(dip)->devi_ops->devo_bus_ops; 8737c478bd9Sstevel@tonic-gate if (bop && bop->bus_dma_map) 8747c478bd9Sstevel@tonic-gate funcp = bop->bus_dma_map; 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate return ((*funcp)(dip, dip, &dmareq, handlep)); 8777c478bd9Sstevel@tonic-gate } 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate #if !defined(__sparc) 8807c478bd9Sstevel@tonic-gate /* 8817c478bd9Sstevel@tonic-gate * Request bus_dma_ctl parent to fiddle with a dma request. 8827c478bd9Sstevel@tonic-gate * 8837c478bd9Sstevel@tonic-gate * (The sparc version is in sparc_subr.s) 8847c478bd9Sstevel@tonic-gate */ 8857c478bd9Sstevel@tonic-gate int 8867c478bd9Sstevel@tonic-gate ddi_dma_mctl(dev_info_t *dip, dev_info_t *rdip, 8877c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, enum ddi_dma_ctlops request, 8887c478bd9Sstevel@tonic-gate off_t *offp, size_t *lenp, caddr_t *objp, uint_t flags) 8897c478bd9Sstevel@tonic-gate { 8907c478bd9Sstevel@tonic-gate int (*fp)(); 8917c478bd9Sstevel@tonic-gate 892b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 893b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_ctl; 8947c478bd9Sstevel@tonic-gate fp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_ctl; 8957c478bd9Sstevel@tonic-gate return ((*fp) (dip, rdip, handle, request, offp, lenp, objp, flags)); 8967c478bd9Sstevel@tonic-gate } 8977c478bd9Sstevel@tonic-gate #endif 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate /* 9007c478bd9Sstevel@tonic-gate * For all DMA control functions, call the DMA control 9017c478bd9Sstevel@tonic-gate * routine and return status. 9027c478bd9Sstevel@tonic-gate * 9037c478bd9Sstevel@tonic-gate * Just plain assume that the parent is to be called. 9047c478bd9Sstevel@tonic-gate * If a nexus driver or a thread outside the framework 9057c478bd9Sstevel@tonic-gate * of a nexus driver or a leaf driver calls these functions, 9067c478bd9Sstevel@tonic-gate * it is up to them to deal with the fact that the parent's 9077c478bd9Sstevel@tonic-gate * bus_dma_ctl function will be the first one called. 9087c478bd9Sstevel@tonic-gate */ 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate #define HD ((ddi_dma_impl_t *)h)->dmai_rdip 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate int 9137c478bd9Sstevel@tonic-gate ddi_dma_kvaddrp(ddi_dma_handle_t h, off_t off, size_t len, caddr_t *kp) 9147c478bd9Sstevel@tonic-gate { 9157c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_KVADDR, &off, &len, kp, 0)); 9167c478bd9Sstevel@tonic-gate } 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate int 9197c478bd9Sstevel@tonic-gate ddi_dma_htoc(ddi_dma_handle_t h, off_t o, ddi_dma_cookie_t *c) 9207c478bd9Sstevel@tonic-gate { 9217c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_HTOC, &o, 0, (caddr_t *)c, 0)); 9227c478bd9Sstevel@tonic-gate } 9237c478bd9Sstevel@tonic-gate 9247c478bd9Sstevel@tonic-gate int 9257c478bd9Sstevel@tonic-gate ddi_dma_coff(ddi_dma_handle_t h, ddi_dma_cookie_t *c, off_t *o) 9267c478bd9Sstevel@tonic-gate { 9277c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_COFF, 9287c478bd9Sstevel@tonic-gate (off_t *)c, 0, (caddr_t *)o, 0)); 9297c478bd9Sstevel@tonic-gate } 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate int 9327c478bd9Sstevel@tonic-gate ddi_dma_movwin(ddi_dma_handle_t h, off_t *o, size_t *l, ddi_dma_cookie_t *c) 9337c478bd9Sstevel@tonic-gate { 9347c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_MOVWIN, o, 9357c478bd9Sstevel@tonic-gate l, (caddr_t *)c, 0)); 9367c478bd9Sstevel@tonic-gate } 9377c478bd9Sstevel@tonic-gate 9387c478bd9Sstevel@tonic-gate int 9397c478bd9Sstevel@tonic-gate ddi_dma_curwin(ddi_dma_handle_t h, off_t *o, size_t *l) 9407c478bd9Sstevel@tonic-gate { 9417c478bd9Sstevel@tonic-gate if ((((ddi_dma_impl_t *)h)->dmai_rflags & DDI_DMA_PARTIAL) == 0) 9427c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 9437c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_REPWIN, o, l, 0, 0)); 9447c478bd9Sstevel@tonic-gate } 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate int 9477c478bd9Sstevel@tonic-gate ddi_dma_nextwin(ddi_dma_handle_t h, ddi_dma_win_t win, 9487c478bd9Sstevel@tonic-gate ddi_dma_win_t *nwin) 9497c478bd9Sstevel@tonic-gate { 9507c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_NEXTWIN, (off_t *)&win, 0, 9517c478bd9Sstevel@tonic-gate (caddr_t *)nwin, 0)); 9527c478bd9Sstevel@tonic-gate } 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate int 9557c478bd9Sstevel@tonic-gate ddi_dma_nextseg(ddi_dma_win_t win, ddi_dma_seg_t seg, ddi_dma_seg_t *nseg) 9567c478bd9Sstevel@tonic-gate { 9577c478bd9Sstevel@tonic-gate ddi_dma_handle_t h = (ddi_dma_handle_t)win; 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_NEXTSEG, (off_t *)&win, 9607c478bd9Sstevel@tonic-gate (size_t *)&seg, (caddr_t *)nseg, 0)); 9617c478bd9Sstevel@tonic-gate } 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate #if (defined(__i386) && !defined(__amd64)) || defined(__sparc) 9647c478bd9Sstevel@tonic-gate /* 9657c478bd9Sstevel@tonic-gate * This routine is Obsolete and should be removed from ALL architectures 9667c478bd9Sstevel@tonic-gate * in a future release of Solaris. 9677c478bd9Sstevel@tonic-gate * 9687c478bd9Sstevel@tonic-gate * It is deliberately NOT ported to amd64; please fix the code that 9697c478bd9Sstevel@tonic-gate * depends on this routine to use ddi_dma_nextcookie(9F). 97012f080e7Smrj * 97112f080e7Smrj * NOTE: even though we fixed the pointer through a 32-bit param issue (the fix 97212f080e7Smrj * is a side effect to some other cleanup), we're still not going to support 97312f080e7Smrj * this interface on x64. 9747c478bd9Sstevel@tonic-gate */ 9757c478bd9Sstevel@tonic-gate int 9767c478bd9Sstevel@tonic-gate ddi_dma_segtocookie(ddi_dma_seg_t seg, off_t *o, off_t *l, 9777c478bd9Sstevel@tonic-gate ddi_dma_cookie_t *cookiep) 9787c478bd9Sstevel@tonic-gate { 9797c478bd9Sstevel@tonic-gate ddi_dma_handle_t h = (ddi_dma_handle_t)seg; 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_SEGTOC, o, (size_t *)l, 9827c478bd9Sstevel@tonic-gate (caddr_t *)cookiep, 0)); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate #endif /* (__i386 && !__amd64) || __sparc */ 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate #if !defined(__sparc) 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate /* 9897c478bd9Sstevel@tonic-gate * The SPARC versions of these routines are done in assembler to 9907c478bd9Sstevel@tonic-gate * save register windows, so they're in sparc_subr.s. 9917c478bd9Sstevel@tonic-gate */ 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate int 9947c478bd9Sstevel@tonic-gate ddi_dma_map(dev_info_t *dip, dev_info_t *rdip, 9957c478bd9Sstevel@tonic-gate struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep) 9967c478bd9Sstevel@tonic-gate { 9977c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, struct ddi_dma_req *, 9987c478bd9Sstevel@tonic-gate ddi_dma_handle_t *); 9997c478bd9Sstevel@tonic-gate 1000b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1001b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_map; 10027c478bd9Sstevel@tonic-gate 1003b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_map; 1004b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, dmareqp, handlep)); 10057c478bd9Sstevel@tonic-gate } 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate int 10087c478bd9Sstevel@tonic-gate ddi_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr, 10097c478bd9Sstevel@tonic-gate int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep) 10107c478bd9Sstevel@tonic-gate { 10117c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_attr_t *, 10127c478bd9Sstevel@tonic-gate int (*)(caddr_t), caddr_t, ddi_dma_handle_t *); 10137c478bd9Sstevel@tonic-gate 1014b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1015b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_allochdl; 10167c478bd9Sstevel@tonic-gate 1017b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_allochdl; 1018b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, attr, waitfp, arg, handlep)); 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate int 10227c478bd9Sstevel@tonic-gate ddi_dma_freehdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_handle_t handlep) 10237c478bd9Sstevel@tonic-gate { 10247c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t); 10257c478bd9Sstevel@tonic-gate 1026b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1027b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_allochdl; 10287c478bd9Sstevel@tonic-gate 1029b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_freehdl; 1030b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handlep)); 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate int 10347c478bd9Sstevel@tonic-gate ddi_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip, 10357c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, struct ddi_dma_req *dmareq, 10367c478bd9Sstevel@tonic-gate ddi_dma_cookie_t *cp, uint_t *ccountp) 10377c478bd9Sstevel@tonic-gate { 10387c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t, 10397c478bd9Sstevel@tonic-gate struct ddi_dma_req *, ddi_dma_cookie_t *, uint_t *); 10407c478bd9Sstevel@tonic-gate 1041b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1042b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl; 10437c478bd9Sstevel@tonic-gate 1044b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_bindhdl; 1045b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handle, dmareq, cp, ccountp)); 10467c478bd9Sstevel@tonic-gate } 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate int 10497c478bd9Sstevel@tonic-gate ddi_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip, 10507c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle) 10517c478bd9Sstevel@tonic-gate { 10527c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t); 10537c478bd9Sstevel@tonic-gate 1054b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1055b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_unbindhdl; 10567c478bd9Sstevel@tonic-gate 1057b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_unbindhdl; 1058b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handle)); 10597c478bd9Sstevel@tonic-gate } 10607c478bd9Sstevel@tonic-gate 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate int 10637c478bd9Sstevel@tonic-gate ddi_dma_flush(dev_info_t *dip, dev_info_t *rdip, 10647c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, off_t off, size_t len, 10657c478bd9Sstevel@tonic-gate uint_t cache_flags) 10667c478bd9Sstevel@tonic-gate { 10677c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t, 10687c478bd9Sstevel@tonic-gate off_t, size_t, uint_t); 10697c478bd9Sstevel@tonic-gate 1070b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1071b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_flush; 10727c478bd9Sstevel@tonic-gate 1073b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_flush; 1074b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handle, off, len, cache_flags)); 10757c478bd9Sstevel@tonic-gate } 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate int 10787c478bd9Sstevel@tonic-gate ddi_dma_win(dev_info_t *dip, dev_info_t *rdip, 10797c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, uint_t win, off_t *offp, 10807c478bd9Sstevel@tonic-gate size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp) 10817c478bd9Sstevel@tonic-gate { 10827c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t, 10837c478bd9Sstevel@tonic-gate uint_t, off_t *, size_t *, ddi_dma_cookie_t *, uint_t *); 10847c478bd9Sstevel@tonic-gate 1085b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1086b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_win; 10877c478bd9Sstevel@tonic-gate 1088b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_win; 1089b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handle, win, offp, lenp, 10907c478bd9Sstevel@tonic-gate cookiep, ccountp)); 10917c478bd9Sstevel@tonic-gate } 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate int 10947c478bd9Sstevel@tonic-gate ddi_dma_sync(ddi_dma_handle_t h, off_t o, size_t l, uint_t whom) 10957c478bd9Sstevel@tonic-gate { 10967c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)h; 1097b51bbbf5SVikram Hegde dev_info_t *dip, *rdip; 10987c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t, off_t, 1099184cd04cScth size_t, uint_t); 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate /* 11027c478bd9Sstevel@tonic-gate * the DMA nexus driver will set DMP_NOSYNC if the 11037c478bd9Sstevel@tonic-gate * platform does not require any sync operation. For 11047c478bd9Sstevel@tonic-gate * example if the memory is uncached or consistent 11057c478bd9Sstevel@tonic-gate * and without any I/O write buffers involved. 11067c478bd9Sstevel@tonic-gate */ 11077c478bd9Sstevel@tonic-gate if ((hp->dmai_rflags & DMP_NOSYNC) == DMP_NOSYNC) 11087c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 11097c478bd9Sstevel@tonic-gate 1110b51bbbf5SVikram Hegde dip = rdip = hp->dmai_rdip; 1111b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1112b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_flush; 1113b51bbbf5SVikram Hegde funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_flush; 1114b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, h, o, l, whom)); 11157c478bd9Sstevel@tonic-gate } 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate int 11187c478bd9Sstevel@tonic-gate ddi_dma_unbind_handle(ddi_dma_handle_t h) 11197c478bd9Sstevel@tonic-gate { 11207c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)h; 1121b51bbbf5SVikram Hegde dev_info_t *dip, *rdip; 11227c478bd9Sstevel@tonic-gate int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t); 11237c478bd9Sstevel@tonic-gate 1124b51bbbf5SVikram Hegde dip = rdip = hp->dmai_rdip; 1125b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 1126b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_unbindhdl; 1127b51bbbf5SVikram Hegde funcp = DEVI(rdip)->devi_bus_dma_unbindfunc; 1128b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, h)); 11297c478bd9Sstevel@tonic-gate } 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate #endif /* !__sparc */ 11327c478bd9Sstevel@tonic-gate 11337c478bd9Sstevel@tonic-gate int 11347c478bd9Sstevel@tonic-gate ddi_dma_free(ddi_dma_handle_t h) 11357c478bd9Sstevel@tonic-gate { 11367c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_FREE, 0, 0, 0, 0)); 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate int 11407c478bd9Sstevel@tonic-gate ddi_iopb_alloc(dev_info_t *dip, ddi_dma_lim_t *limp, uint_t len, caddr_t *iopbp) 11417c478bd9Sstevel@tonic-gate { 11427c478bd9Sstevel@tonic-gate ddi_dma_lim_t defalt; 11437c478bd9Sstevel@tonic-gate size_t size = len; 11447c478bd9Sstevel@tonic-gate 11457c478bd9Sstevel@tonic-gate if (!limp) { 11467c478bd9Sstevel@tonic-gate defalt = standard_limits; 11477c478bd9Sstevel@tonic-gate limp = &defalt; 11487c478bd9Sstevel@tonic-gate } 11497c478bd9Sstevel@tonic-gate return (i_ddi_mem_alloc_lim(dip, limp, size, 0, 0, 0, 11507c478bd9Sstevel@tonic-gate iopbp, NULL, NULL)); 11517c478bd9Sstevel@tonic-gate } 11527c478bd9Sstevel@tonic-gate 11537c478bd9Sstevel@tonic-gate void 11547c478bd9Sstevel@tonic-gate ddi_iopb_free(caddr_t iopb) 11557c478bd9Sstevel@tonic-gate { 11567b93957cSeota i_ddi_mem_free(iopb, NULL); 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate int 11607c478bd9Sstevel@tonic-gate ddi_mem_alloc(dev_info_t *dip, ddi_dma_lim_t *limits, uint_t length, 11617c478bd9Sstevel@tonic-gate uint_t flags, caddr_t *kaddrp, uint_t *real_length) 11627c478bd9Sstevel@tonic-gate { 11637c478bd9Sstevel@tonic-gate ddi_dma_lim_t defalt; 11647c478bd9Sstevel@tonic-gate size_t size = length; 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate if (!limits) { 11677c478bd9Sstevel@tonic-gate defalt = standard_limits; 11687c478bd9Sstevel@tonic-gate limits = &defalt; 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate return (i_ddi_mem_alloc_lim(dip, limits, size, flags & 0x1, 11717c478bd9Sstevel@tonic-gate 1, 0, kaddrp, real_length, NULL)); 11727c478bd9Sstevel@tonic-gate } 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate void 11757c478bd9Sstevel@tonic-gate ddi_mem_free(caddr_t kaddr) 11767c478bd9Sstevel@tonic-gate { 11777b93957cSeota i_ddi_mem_free(kaddr, NULL); 11787c478bd9Sstevel@tonic-gate } 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate /* 11817c478bd9Sstevel@tonic-gate * DMA attributes, alignment, burst sizes, and transfer minimums 11827c478bd9Sstevel@tonic-gate */ 11837c478bd9Sstevel@tonic-gate int 11847c478bd9Sstevel@tonic-gate ddi_dma_get_attr(ddi_dma_handle_t handle, ddi_dma_attr_t *attrp) 11857c478bd9Sstevel@tonic-gate { 11867c478bd9Sstevel@tonic-gate ddi_dma_impl_t *dimp = (ddi_dma_impl_t *)handle; 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate if (attrp == NULL) 11897c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 11907c478bd9Sstevel@tonic-gate *attrp = dimp->dmai_attr; 11917c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 11927c478bd9Sstevel@tonic-gate } 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate int 11957c478bd9Sstevel@tonic-gate ddi_dma_burstsizes(ddi_dma_handle_t handle) 11967c478bd9Sstevel@tonic-gate { 11977c478bd9Sstevel@tonic-gate ddi_dma_impl_t *dimp = (ddi_dma_impl_t *)handle; 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate if (!dimp) 12007c478bd9Sstevel@tonic-gate return (0); 12017c478bd9Sstevel@tonic-gate else 12027c478bd9Sstevel@tonic-gate return (dimp->dmai_burstsizes); 12037c478bd9Sstevel@tonic-gate } 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate int 12067c478bd9Sstevel@tonic-gate ddi_dma_devalign(ddi_dma_handle_t handle, uint_t *alignment, uint_t *mineffect) 12077c478bd9Sstevel@tonic-gate { 12087c478bd9Sstevel@tonic-gate ddi_dma_impl_t *dimp = (ddi_dma_impl_t *)handle; 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate if (!dimp || !alignment || !mineffect) 12117c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 12127c478bd9Sstevel@tonic-gate if (!(dimp->dmai_rflags & DDI_DMA_SBUS_64BIT)) { 12137c478bd9Sstevel@tonic-gate *alignment = 1 << ddi_ffs(dimp->dmai_burstsizes); 12147c478bd9Sstevel@tonic-gate } else { 12157c478bd9Sstevel@tonic-gate if (dimp->dmai_burstsizes & 0xff0000) { 12167c478bd9Sstevel@tonic-gate *alignment = 1 << ddi_ffs(dimp->dmai_burstsizes >> 16); 12177c478bd9Sstevel@tonic-gate } else { 12187c478bd9Sstevel@tonic-gate *alignment = 1 << ddi_ffs(dimp->dmai_burstsizes); 12197c478bd9Sstevel@tonic-gate } 12207c478bd9Sstevel@tonic-gate } 12217c478bd9Sstevel@tonic-gate *mineffect = dimp->dmai_minxfer; 12227c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate int 12267c478bd9Sstevel@tonic-gate ddi_iomin(dev_info_t *a, int i, int stream) 12277c478bd9Sstevel@tonic-gate { 12287c478bd9Sstevel@tonic-gate int r; 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate /* 12317c478bd9Sstevel@tonic-gate * Make sure that the initial value is sane 12327c478bd9Sstevel@tonic-gate */ 12337c478bd9Sstevel@tonic-gate if (i & (i - 1)) 12347c478bd9Sstevel@tonic-gate return (0); 12357c478bd9Sstevel@tonic-gate if (i == 0) 12367c478bd9Sstevel@tonic-gate i = (stream) ? 4 : 1; 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate r = ddi_ctlops(a, a, 12397c478bd9Sstevel@tonic-gate DDI_CTLOPS_IOMIN, (void *)(uintptr_t)stream, (void *)&i); 12407c478bd9Sstevel@tonic-gate if (r != DDI_SUCCESS || (i & (i - 1))) 12417c478bd9Sstevel@tonic-gate return (0); 12427c478bd9Sstevel@tonic-gate return (i); 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate 12457c478bd9Sstevel@tonic-gate /* 12467c478bd9Sstevel@tonic-gate * Given two DMA attribute structures, apply the attributes 12477c478bd9Sstevel@tonic-gate * of one to the other, following the rules of attributes 12487c478bd9Sstevel@tonic-gate * and the wishes of the caller. 12497c478bd9Sstevel@tonic-gate * 12507c478bd9Sstevel@tonic-gate * The rules of DMA attribute structures are that you cannot 12517c478bd9Sstevel@tonic-gate * make things *less* restrictive as you apply one set 12527c478bd9Sstevel@tonic-gate * of attributes to another. 12537c478bd9Sstevel@tonic-gate * 12547c478bd9Sstevel@tonic-gate */ 12557c478bd9Sstevel@tonic-gate void 12567c478bd9Sstevel@tonic-gate ddi_dma_attr_merge(ddi_dma_attr_t *attr, ddi_dma_attr_t *mod) 12577c478bd9Sstevel@tonic-gate { 12587c478bd9Sstevel@tonic-gate attr->dma_attr_addr_lo = 12597c478bd9Sstevel@tonic-gate MAX(attr->dma_attr_addr_lo, mod->dma_attr_addr_lo); 12607c478bd9Sstevel@tonic-gate attr->dma_attr_addr_hi = 12617c478bd9Sstevel@tonic-gate MIN(attr->dma_attr_addr_hi, mod->dma_attr_addr_hi); 12627c478bd9Sstevel@tonic-gate attr->dma_attr_count_max = 12637c478bd9Sstevel@tonic-gate MIN(attr->dma_attr_count_max, mod->dma_attr_count_max); 12647c478bd9Sstevel@tonic-gate attr->dma_attr_align = 12657c478bd9Sstevel@tonic-gate MAX(attr->dma_attr_align, mod->dma_attr_align); 12667c478bd9Sstevel@tonic-gate attr->dma_attr_burstsizes = 12677c478bd9Sstevel@tonic-gate (uint_t)(attr->dma_attr_burstsizes & mod->dma_attr_burstsizes); 12687c478bd9Sstevel@tonic-gate attr->dma_attr_minxfer = 12697c478bd9Sstevel@tonic-gate maxbit(attr->dma_attr_minxfer, mod->dma_attr_minxfer); 12707c478bd9Sstevel@tonic-gate attr->dma_attr_maxxfer = 12717c478bd9Sstevel@tonic-gate MIN(attr->dma_attr_maxxfer, mod->dma_attr_maxxfer); 12727c478bd9Sstevel@tonic-gate attr->dma_attr_seg = MIN(attr->dma_attr_seg, mod->dma_attr_seg); 12737c478bd9Sstevel@tonic-gate attr->dma_attr_sgllen = MIN((uint_t)attr->dma_attr_sgllen, 12747c478bd9Sstevel@tonic-gate (uint_t)mod->dma_attr_sgllen); 12757c478bd9Sstevel@tonic-gate attr->dma_attr_granular = 12767c478bd9Sstevel@tonic-gate MAX(attr->dma_attr_granular, mod->dma_attr_granular); 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate /* 12807c478bd9Sstevel@tonic-gate * mmap/segmap interface: 12817c478bd9Sstevel@tonic-gate */ 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate /* 12847c478bd9Sstevel@tonic-gate * ddi_segmap: setup the default segment driver. Calls the drivers 12857c478bd9Sstevel@tonic-gate * XXmmap routine to validate the range to be mapped. 12867c478bd9Sstevel@tonic-gate * Return ENXIO of the range is not valid. Create 12877c478bd9Sstevel@tonic-gate * a seg_dev segment that contains all of the 12887c478bd9Sstevel@tonic-gate * necessary information and will reference the 12897c478bd9Sstevel@tonic-gate * default segment driver routines. It returns zero 12907c478bd9Sstevel@tonic-gate * on success or non-zero on failure. 12917c478bd9Sstevel@tonic-gate */ 12927c478bd9Sstevel@tonic-gate int 12937c478bd9Sstevel@tonic-gate ddi_segmap(dev_t dev, off_t offset, struct as *asp, caddr_t *addrp, off_t len, 12947c478bd9Sstevel@tonic-gate uint_t prot, uint_t maxprot, uint_t flags, cred_t *credp) 12957c478bd9Sstevel@tonic-gate { 12967c478bd9Sstevel@tonic-gate extern int spec_segmap(dev_t, off_t, struct as *, caddr_t *, 12977c478bd9Sstevel@tonic-gate off_t, uint_t, uint_t, uint_t, struct cred *); 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate return (spec_segmap(dev, offset, asp, addrp, len, 13007c478bd9Sstevel@tonic-gate prot, maxprot, flags, credp)); 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate /* 13047c478bd9Sstevel@tonic-gate * ddi_map_fault: Resolve mappings at fault time. Used by segment 13057c478bd9Sstevel@tonic-gate * drivers. Allows each successive parent to resolve 13067c478bd9Sstevel@tonic-gate * address translations and add its mappings to the 13077c478bd9Sstevel@tonic-gate * mapping list supplied in the page structure. It 13087c478bd9Sstevel@tonic-gate * returns zero on success or non-zero on failure. 13097c478bd9Sstevel@tonic-gate */ 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate int 13127c478bd9Sstevel@tonic-gate ddi_map_fault(dev_info_t *dip, struct hat *hat, struct seg *seg, 13137c478bd9Sstevel@tonic-gate caddr_t addr, struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock) 13147c478bd9Sstevel@tonic-gate { 13157c478bd9Sstevel@tonic-gate return (i_ddi_map_fault(dip, dip, hat, seg, addr, dp, pfn, prot, lock)); 13167c478bd9Sstevel@tonic-gate } 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate /* 13197c478bd9Sstevel@tonic-gate * ddi_device_mapping_check: Called from ddi_segmap_setup. 13207c478bd9Sstevel@tonic-gate * Invokes platform specific DDI to determine whether attributes specified 13217c478bd9Sstevel@tonic-gate * in attr(9s) are valid for the region of memory that will be made 13227c478bd9Sstevel@tonic-gate * available for direct access to user process via the mmap(2) system call. 13237c478bd9Sstevel@tonic-gate */ 13247c478bd9Sstevel@tonic-gate int 13257c478bd9Sstevel@tonic-gate ddi_device_mapping_check(dev_t dev, ddi_device_acc_attr_t *accattrp, 13267c478bd9Sstevel@tonic-gate uint_t rnumber, uint_t *hat_flags) 13277c478bd9Sstevel@tonic-gate { 13287c478bd9Sstevel@tonic-gate ddi_acc_handle_t handle; 13297c478bd9Sstevel@tonic-gate ddi_map_req_t mr; 13307c478bd9Sstevel@tonic-gate ddi_acc_hdl_t *hp; 13317c478bd9Sstevel@tonic-gate int result; 13327c478bd9Sstevel@tonic-gate dev_info_t *dip; 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate /* 13357c478bd9Sstevel@tonic-gate * we use e_ddi_hold_devi_by_dev to search for the devi. We 13367c478bd9Sstevel@tonic-gate * release it immediately since it should already be held by 13377c478bd9Sstevel@tonic-gate * a devfs vnode. 13387c478bd9Sstevel@tonic-gate */ 13397c478bd9Sstevel@tonic-gate if ((dip = 13407c478bd9Sstevel@tonic-gate e_ddi_hold_devi_by_dev(dev, E_DDI_HOLD_DEVI_NOATTACH)) == NULL) 13417c478bd9Sstevel@tonic-gate return (-1); 13427c478bd9Sstevel@tonic-gate ddi_release_devi(dip); /* for e_ddi_hold_devi_by_dev() */ 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate /* 13457c478bd9Sstevel@tonic-gate * Allocate and initialize the common elements of data 13467c478bd9Sstevel@tonic-gate * access handle. 13477c478bd9Sstevel@tonic-gate */ 13487c478bd9Sstevel@tonic-gate handle = impl_acc_hdl_alloc(KM_SLEEP, NULL); 13497c478bd9Sstevel@tonic-gate if (handle == NULL) 13507c478bd9Sstevel@tonic-gate return (-1); 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate hp = impl_acc_hdl_get(handle); 13537c478bd9Sstevel@tonic-gate hp->ah_vers = VERS_ACCHDL; 13547c478bd9Sstevel@tonic-gate hp->ah_dip = dip; 13557c478bd9Sstevel@tonic-gate hp->ah_rnumber = rnumber; 13567c478bd9Sstevel@tonic-gate hp->ah_offset = 0; 13577c478bd9Sstevel@tonic-gate hp->ah_len = 0; 13587c478bd9Sstevel@tonic-gate hp->ah_acc = *accattrp; 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate /* 13617c478bd9Sstevel@tonic-gate * Set up the mapping request and call to parent. 13627c478bd9Sstevel@tonic-gate */ 13637c478bd9Sstevel@tonic-gate mr.map_op = DDI_MO_MAP_HANDLE; 13647c478bd9Sstevel@tonic-gate mr.map_type = DDI_MT_RNUMBER; 13657c478bd9Sstevel@tonic-gate mr.map_obj.rnumber = rnumber; 13667c478bd9Sstevel@tonic-gate mr.map_prot = PROT_READ | PROT_WRITE; 13677c478bd9Sstevel@tonic-gate mr.map_flags = DDI_MF_KERNEL_MAPPING; 13687c478bd9Sstevel@tonic-gate mr.map_handlep = hp; 13697c478bd9Sstevel@tonic-gate mr.map_vers = DDI_MAP_VERSION; 13707c478bd9Sstevel@tonic-gate result = ddi_map(dip, &mr, 0, 0, NULL); 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate /* 13737c478bd9Sstevel@tonic-gate * Region must be mappable, pick up flags from the framework. 13747c478bd9Sstevel@tonic-gate */ 13757c478bd9Sstevel@tonic-gate *hat_flags = hp->ah_hat_flags; 13767c478bd9Sstevel@tonic-gate 13777c478bd9Sstevel@tonic-gate impl_acc_hdl_free(handle); 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate /* 13807c478bd9Sstevel@tonic-gate * check for end result. 13817c478bd9Sstevel@tonic-gate */ 13827c478bd9Sstevel@tonic-gate if (result != DDI_SUCCESS) 13837c478bd9Sstevel@tonic-gate return (-1); 13847c478bd9Sstevel@tonic-gate return (0); 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate 13887c478bd9Sstevel@tonic-gate /* 13897c478bd9Sstevel@tonic-gate * Property functions: See also, ddipropdefs.h. 13907c478bd9Sstevel@tonic-gate * 13917c478bd9Sstevel@tonic-gate * These functions are the framework for the property functions, 13927c478bd9Sstevel@tonic-gate * i.e. they support software defined properties. All implementation 13937c478bd9Sstevel@tonic-gate * specific property handling (i.e.: self-identifying devices and 13947c478bd9Sstevel@tonic-gate * PROM defined properties are handled in the implementation specific 13957c478bd9Sstevel@tonic-gate * functions (defined in ddi_implfuncs.h). 13967c478bd9Sstevel@tonic-gate */ 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate /* 13997c478bd9Sstevel@tonic-gate * nopropop: Shouldn't be called, right? 14007c478bd9Sstevel@tonic-gate */ 14017c478bd9Sstevel@tonic-gate int 14027c478bd9Sstevel@tonic-gate nopropop(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags, 14037c478bd9Sstevel@tonic-gate char *name, caddr_t valuep, int *lengthp) 14047c478bd9Sstevel@tonic-gate { 14057c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dev, dip, prop_op, mod_flags, name, valuep, lengthp)) 14067c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 14077c478bd9Sstevel@tonic-gate } 14087c478bd9Sstevel@tonic-gate 14097c478bd9Sstevel@tonic-gate #ifdef DDI_PROP_DEBUG 14107c478bd9Sstevel@tonic-gate int ddi_prop_debug_flag = 0; 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate int 14137c478bd9Sstevel@tonic-gate ddi_prop_debug(int enable) 14147c478bd9Sstevel@tonic-gate { 14157c478bd9Sstevel@tonic-gate int prev = ddi_prop_debug_flag; 14167c478bd9Sstevel@tonic-gate 14177c478bd9Sstevel@tonic-gate if ((enable != 0) || (prev != 0)) 14187c478bd9Sstevel@tonic-gate printf("ddi_prop_debug: debugging %s\n", 14197c478bd9Sstevel@tonic-gate enable ? "enabled" : "disabled"); 14207c478bd9Sstevel@tonic-gate ddi_prop_debug_flag = enable; 14217c478bd9Sstevel@tonic-gate return (prev); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate #endif /* DDI_PROP_DEBUG */ 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate /* 14277c478bd9Sstevel@tonic-gate * Search a property list for a match, if found return pointer 14287c478bd9Sstevel@tonic-gate * to matching prop struct, else return NULL. 14297c478bd9Sstevel@tonic-gate */ 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate ddi_prop_t * 14327c478bd9Sstevel@tonic-gate i_ddi_prop_search(dev_t dev, char *name, uint_t flags, ddi_prop_t **list_head) 14337c478bd9Sstevel@tonic-gate { 14347c478bd9Sstevel@tonic-gate ddi_prop_t *propp; 14357c478bd9Sstevel@tonic-gate 14367c478bd9Sstevel@tonic-gate /* 14377c478bd9Sstevel@tonic-gate * find the property in child's devinfo: 14389ac2ddeaScth * Search order defined by this search function is first matching 14399ac2ddeaScth * property with input dev == DDI_DEV_T_ANY matching any dev or 14409ac2ddeaScth * dev == propp->prop_dev, name == propp->name, and the correct 14419ac2ddeaScth * data type as specified in the flags. If a DDI_DEV_T_NONE dev 14429ac2ddeaScth * value made it this far then it implies a DDI_DEV_T_ANY search. 14437c478bd9Sstevel@tonic-gate */ 14449ac2ddeaScth if (dev == DDI_DEV_T_NONE) 14459ac2ddeaScth dev = DDI_DEV_T_ANY; 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate for (propp = *list_head; propp != NULL; propp = propp->prop_next) { 14487c478bd9Sstevel@tonic-gate 14492cd7878fScth if (!DDI_STRSAME(propp->prop_name, name)) 14507c478bd9Sstevel@tonic-gate continue; 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate if ((dev != DDI_DEV_T_ANY) && (propp->prop_dev != dev)) 14537c478bd9Sstevel@tonic-gate continue; 14547c478bd9Sstevel@tonic-gate 14557c478bd9Sstevel@tonic-gate if (((propp->prop_flags & flags) & DDI_PROP_TYPE_MASK) == 0) 14567c478bd9Sstevel@tonic-gate continue; 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate return (propp); 14597c478bd9Sstevel@tonic-gate } 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate return ((ddi_prop_t *)0); 14627c478bd9Sstevel@tonic-gate } 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate /* 14657c478bd9Sstevel@tonic-gate * Search for property within devnames structures 14667c478bd9Sstevel@tonic-gate */ 14677c478bd9Sstevel@tonic-gate ddi_prop_t * 14687c478bd9Sstevel@tonic-gate i_ddi_search_global_prop(dev_t dev, char *name, uint_t flags) 14697c478bd9Sstevel@tonic-gate { 14707c478bd9Sstevel@tonic-gate major_t major; 14717c478bd9Sstevel@tonic-gate struct devnames *dnp; 14727c478bd9Sstevel@tonic-gate ddi_prop_t *propp; 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate /* 14757c478bd9Sstevel@tonic-gate * Valid dev_t value is needed to index into the 14767c478bd9Sstevel@tonic-gate * correct devnames entry, therefore a dev_t 14777c478bd9Sstevel@tonic-gate * value of DDI_DEV_T_ANY is not appropriate. 14787c478bd9Sstevel@tonic-gate */ 14797c478bd9Sstevel@tonic-gate ASSERT(dev != DDI_DEV_T_ANY); 14807c478bd9Sstevel@tonic-gate if (dev == DDI_DEV_T_ANY) { 14817c478bd9Sstevel@tonic-gate return ((ddi_prop_t *)0); 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate major = getmajor(dev); 14857c478bd9Sstevel@tonic-gate dnp = &(devnamesp[major]); 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate if (dnp->dn_global_prop_ptr == NULL) 14887c478bd9Sstevel@tonic-gate return ((ddi_prop_t *)0); 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate for (propp = dnp->dn_global_prop_ptr->prop_list; 14937c478bd9Sstevel@tonic-gate propp != NULL; 14947c478bd9Sstevel@tonic-gate propp = (ddi_prop_t *)propp->prop_next) { 14957c478bd9Sstevel@tonic-gate 14962cd7878fScth if (!DDI_STRSAME(propp->prop_name, name)) 14977c478bd9Sstevel@tonic-gate continue; 14987c478bd9Sstevel@tonic-gate 149965cf7c95SVikram Hegde if ((!(flags & DDI_PROP_ROOTNEX_GLOBAL)) && 150065cf7c95SVikram Hegde (!(flags & LDI_DEV_T_ANY)) && (propp->prop_dev != dev)) 15017c478bd9Sstevel@tonic-gate continue; 15027c478bd9Sstevel@tonic-gate 15037c478bd9Sstevel@tonic-gate if (((propp->prop_flags & flags) & DDI_PROP_TYPE_MASK) == 0) 15047c478bd9Sstevel@tonic-gate continue; 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate /* Property found, return it */ 15077c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 15087c478bd9Sstevel@tonic-gate return (propp); 15097c478bd9Sstevel@tonic-gate } 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 15127c478bd9Sstevel@tonic-gate return ((ddi_prop_t *)0); 15137c478bd9Sstevel@tonic-gate } 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate static char prop_no_mem_msg[] = "can't allocate memory for ddi property <%s>"; 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate /* 15187c478bd9Sstevel@tonic-gate * ddi_prop_search_global: 15197c478bd9Sstevel@tonic-gate * Search the global property list within devnames 15207c478bd9Sstevel@tonic-gate * for the named property. Return the encoded value. 15217c478bd9Sstevel@tonic-gate */ 15227c478bd9Sstevel@tonic-gate static int 15237c478bd9Sstevel@tonic-gate i_ddi_prop_search_global(dev_t dev, uint_t flags, char *name, 15247c478bd9Sstevel@tonic-gate void *valuep, uint_t *lengthp) 15257c478bd9Sstevel@tonic-gate { 15267c478bd9Sstevel@tonic-gate ddi_prop_t *propp; 15277c478bd9Sstevel@tonic-gate caddr_t buffer; 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate propp = i_ddi_search_global_prop(dev, name, flags); 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate /* Property NOT found, bail */ 15327c478bd9Sstevel@tonic-gate if (propp == (ddi_prop_t *)0) 15337c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 15347c478bd9Sstevel@tonic-gate 15357c478bd9Sstevel@tonic-gate if (propp->prop_flags & DDI_PROP_UNDEF_IT) 15367c478bd9Sstevel@tonic-gate return (DDI_PROP_UNDEFINED); 15377c478bd9Sstevel@tonic-gate 15383b756dd3Scth if ((buffer = kmem_alloc(propp->prop_len, 15393b756dd3Scth (flags & DDI_PROP_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP)) == NULL) { 15407c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 15417c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 15427c478bd9Sstevel@tonic-gate } 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate /* 15457c478bd9Sstevel@tonic-gate * Return the encoded data 15467c478bd9Sstevel@tonic-gate */ 15477c478bd9Sstevel@tonic-gate *(caddr_t *)valuep = buffer; 15487c478bd9Sstevel@tonic-gate *lengthp = propp->prop_len; 15497c478bd9Sstevel@tonic-gate bcopy(propp->prop_val, buffer, propp->prop_len); 15507c478bd9Sstevel@tonic-gate 15517c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 15527c478bd9Sstevel@tonic-gate } 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate /* 15557c478bd9Sstevel@tonic-gate * ddi_prop_search_common: Lookup and return the encoded value 15567c478bd9Sstevel@tonic-gate */ 15577c478bd9Sstevel@tonic-gate int 15587c478bd9Sstevel@tonic-gate ddi_prop_search_common(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 15597c478bd9Sstevel@tonic-gate uint_t flags, char *name, void *valuep, uint_t *lengthp) 15607c478bd9Sstevel@tonic-gate { 15617c478bd9Sstevel@tonic-gate ddi_prop_t *propp; 15627c478bd9Sstevel@tonic-gate int i; 15637c478bd9Sstevel@tonic-gate caddr_t buffer; 15647c478bd9Sstevel@tonic-gate caddr_t prealloc = NULL; 15657c478bd9Sstevel@tonic-gate int plength = 0; 15667c478bd9Sstevel@tonic-gate dev_info_t *pdip; 15677c478bd9Sstevel@tonic-gate int (*bop)(); 15687c478bd9Sstevel@tonic-gate 15697c478bd9Sstevel@tonic-gate /*CONSTANTCONDITION*/ 15707c478bd9Sstevel@tonic-gate while (1) { 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate mutex_enter(&(DEVI(dip)->devi_lock)); 15737c478bd9Sstevel@tonic-gate 15747c478bd9Sstevel@tonic-gate 15757c478bd9Sstevel@tonic-gate /* 15767c478bd9Sstevel@tonic-gate * find the property in child's devinfo: 15777c478bd9Sstevel@tonic-gate * Search order is: 15787c478bd9Sstevel@tonic-gate * 1. driver defined properties 15797c478bd9Sstevel@tonic-gate * 2. system defined properties 15807c478bd9Sstevel@tonic-gate * 3. driver global properties 15817c478bd9Sstevel@tonic-gate * 4. boot defined properties 15827c478bd9Sstevel@tonic-gate */ 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate propp = i_ddi_prop_search(dev, name, flags, 15857c478bd9Sstevel@tonic-gate &(DEVI(dip)->devi_drv_prop_ptr)); 15867c478bd9Sstevel@tonic-gate if (propp == NULL) { 15877c478bd9Sstevel@tonic-gate propp = i_ddi_prop_search(dev, name, flags, 15887c478bd9Sstevel@tonic-gate &(DEVI(dip)->devi_sys_prop_ptr)); 15897c478bd9Sstevel@tonic-gate } 15907c478bd9Sstevel@tonic-gate if ((propp == NULL) && DEVI(dip)->devi_global_prop_list) { 15917c478bd9Sstevel@tonic-gate propp = i_ddi_prop_search(dev, name, flags, 15927c478bd9Sstevel@tonic-gate &DEVI(dip)->devi_global_prop_list->prop_list); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate if (propp == NULL) { 15967c478bd9Sstevel@tonic-gate propp = i_ddi_prop_search(dev, name, flags, 15977c478bd9Sstevel@tonic-gate &(DEVI(dip)->devi_hw_prop_ptr)); 15987c478bd9Sstevel@tonic-gate } 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate /* 16017c478bd9Sstevel@tonic-gate * Software property found? 16027c478bd9Sstevel@tonic-gate */ 16037c478bd9Sstevel@tonic-gate if (propp != (ddi_prop_t *)0) { 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate /* 16067c478bd9Sstevel@tonic-gate * If explicit undefine, return now. 16077c478bd9Sstevel@tonic-gate */ 16087c478bd9Sstevel@tonic-gate if (propp->prop_flags & DDI_PROP_UNDEF_IT) { 16097c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 16107c478bd9Sstevel@tonic-gate if (prealloc) 16117c478bd9Sstevel@tonic-gate kmem_free(prealloc, plength); 16127c478bd9Sstevel@tonic-gate return (DDI_PROP_UNDEFINED); 16137c478bd9Sstevel@tonic-gate } 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate /* 16167c478bd9Sstevel@tonic-gate * If we only want to know if it exists, return now 16177c478bd9Sstevel@tonic-gate */ 16187c478bd9Sstevel@tonic-gate if (prop_op == PROP_EXISTS) { 16197c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 16207c478bd9Sstevel@tonic-gate ASSERT(prealloc == NULL); 16217c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 16227c478bd9Sstevel@tonic-gate } 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate /* 16257c478bd9Sstevel@tonic-gate * If length only request or prop length == 0, 16267c478bd9Sstevel@tonic-gate * service request and return now. 16277c478bd9Sstevel@tonic-gate */ 16287c478bd9Sstevel@tonic-gate if ((prop_op == PROP_LEN) ||(propp->prop_len == 0)) { 16297c478bd9Sstevel@tonic-gate *lengthp = propp->prop_len; 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate /* 16327c478bd9Sstevel@tonic-gate * if prop_op is PROP_LEN_AND_VAL_ALLOC 16337c478bd9Sstevel@tonic-gate * that means prop_len is 0, so set valuep 16347c478bd9Sstevel@tonic-gate * also to NULL 16357c478bd9Sstevel@tonic-gate */ 16367c478bd9Sstevel@tonic-gate if (prop_op == PROP_LEN_AND_VAL_ALLOC) 16377c478bd9Sstevel@tonic-gate *(caddr_t *)valuep = NULL; 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 16407c478bd9Sstevel@tonic-gate if (prealloc) 16417c478bd9Sstevel@tonic-gate kmem_free(prealloc, plength); 16427c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 16437c478bd9Sstevel@tonic-gate } 16447c478bd9Sstevel@tonic-gate 16457c478bd9Sstevel@tonic-gate /* 16467c478bd9Sstevel@tonic-gate * If LEN_AND_VAL_ALLOC and the request can sleep, 16477c478bd9Sstevel@tonic-gate * drop the mutex, allocate the buffer, and go 16487c478bd9Sstevel@tonic-gate * through the loop again. If we already allocated 16497c478bd9Sstevel@tonic-gate * the buffer, and the size of the property changed, 16507c478bd9Sstevel@tonic-gate * keep trying... 16517c478bd9Sstevel@tonic-gate */ 16527c478bd9Sstevel@tonic-gate if ((prop_op == PROP_LEN_AND_VAL_ALLOC) && 16537c478bd9Sstevel@tonic-gate (flags & DDI_PROP_CANSLEEP)) { 16547c478bd9Sstevel@tonic-gate if (prealloc && (propp->prop_len != plength)) { 16557c478bd9Sstevel@tonic-gate kmem_free(prealloc, plength); 16567c478bd9Sstevel@tonic-gate prealloc = NULL; 16577c478bd9Sstevel@tonic-gate } 16587c478bd9Sstevel@tonic-gate if (prealloc == NULL) { 16597c478bd9Sstevel@tonic-gate plength = propp->prop_len; 16607c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 16617c478bd9Sstevel@tonic-gate prealloc = kmem_alloc(plength, 16627c478bd9Sstevel@tonic-gate KM_SLEEP); 16637c478bd9Sstevel@tonic-gate continue; 16647c478bd9Sstevel@tonic-gate } 16657c478bd9Sstevel@tonic-gate } 16667c478bd9Sstevel@tonic-gate 16677c478bd9Sstevel@tonic-gate /* 16687c478bd9Sstevel@tonic-gate * Allocate buffer, if required. Either way, 16697c478bd9Sstevel@tonic-gate * set `buffer' variable. 16707c478bd9Sstevel@tonic-gate */ 16717c478bd9Sstevel@tonic-gate i = *lengthp; /* Get callers length */ 16727c478bd9Sstevel@tonic-gate *lengthp = propp->prop_len; /* Set callers length */ 16737c478bd9Sstevel@tonic-gate 16747c478bd9Sstevel@tonic-gate switch (prop_op) { 16757c478bd9Sstevel@tonic-gate 16767c478bd9Sstevel@tonic-gate case PROP_LEN_AND_VAL_ALLOC: 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate if (prealloc == NULL) { 16797c478bd9Sstevel@tonic-gate buffer = kmem_alloc(propp->prop_len, 16807c478bd9Sstevel@tonic-gate KM_NOSLEEP); 16817c478bd9Sstevel@tonic-gate } else { 16827c478bd9Sstevel@tonic-gate buffer = prealloc; 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate if (buffer == NULL) { 16867c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 16877c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 16887c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 16897c478bd9Sstevel@tonic-gate } 16907c478bd9Sstevel@tonic-gate /* Set callers buf ptr */ 16917c478bd9Sstevel@tonic-gate *(caddr_t *)valuep = buffer; 16927c478bd9Sstevel@tonic-gate break; 16937c478bd9Sstevel@tonic-gate 16947c478bd9Sstevel@tonic-gate case PROP_LEN_AND_VAL_BUF: 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate if (propp->prop_len > (i)) { 16977c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 16987c478bd9Sstevel@tonic-gate return (DDI_PROP_BUF_TOO_SMALL); 16997c478bd9Sstevel@tonic-gate } 17007c478bd9Sstevel@tonic-gate 17017c478bd9Sstevel@tonic-gate buffer = valuep; /* Get callers buf ptr */ 17027c478bd9Sstevel@tonic-gate break; 17037c478bd9Sstevel@tonic-gate 17047c478bd9Sstevel@tonic-gate default: 17057c478bd9Sstevel@tonic-gate break; 17067c478bd9Sstevel@tonic-gate } 17077c478bd9Sstevel@tonic-gate 17087c478bd9Sstevel@tonic-gate /* 17097c478bd9Sstevel@tonic-gate * Do the copy. 17107c478bd9Sstevel@tonic-gate */ 17117c478bd9Sstevel@tonic-gate bcopy(propp->prop_val, buffer, propp->prop_len); 17127c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 17137c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 17177c478bd9Sstevel@tonic-gate if (prealloc) 17187c478bd9Sstevel@tonic-gate kmem_free(prealloc, plength); 17197c478bd9Sstevel@tonic-gate prealloc = NULL; 17207c478bd9Sstevel@tonic-gate 17217c478bd9Sstevel@tonic-gate /* 17227c478bd9Sstevel@tonic-gate * Prop not found, call parent bus_ops to deal with possible 17237c478bd9Sstevel@tonic-gate * h/w layer (possible PROM defined props, etc.) and to 17247c478bd9Sstevel@tonic-gate * possibly ascend the hierarchy, if allowed by flags. 17257c478bd9Sstevel@tonic-gate */ 17267c478bd9Sstevel@tonic-gate pdip = (dev_info_t *)DEVI(dip)->devi_parent; 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate /* 17297c478bd9Sstevel@tonic-gate * One last call for the root driver PROM props? 17307c478bd9Sstevel@tonic-gate */ 17317c478bd9Sstevel@tonic-gate if (dip == ddi_root_node()) { 17327c478bd9Sstevel@tonic-gate return (ddi_bus_prop_op(dev, dip, dip, prop_op, 17337c478bd9Sstevel@tonic-gate flags, name, valuep, (int *)lengthp)); 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate /* 17377c478bd9Sstevel@tonic-gate * We may have been called to check for properties 17387c478bd9Sstevel@tonic-gate * within a single devinfo node that has no parent - 17397c478bd9Sstevel@tonic-gate * see make_prop() 17407c478bd9Sstevel@tonic-gate */ 17417c478bd9Sstevel@tonic-gate if (pdip == NULL) { 17427c478bd9Sstevel@tonic-gate ASSERT((flags & 17437c478bd9Sstevel@tonic-gate (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM)) == 17447c478bd9Sstevel@tonic-gate (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM)); 17457c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 17467c478bd9Sstevel@tonic-gate } 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate /* 17497c478bd9Sstevel@tonic-gate * Instead of recursing, we do iterative calls up the tree. 17507c478bd9Sstevel@tonic-gate * As a bit of optimization, skip the bus_op level if the 17517c478bd9Sstevel@tonic-gate * node is a s/w node and if the parent's bus_prop_op function 17527c478bd9Sstevel@tonic-gate * is `ddi_bus_prop_op', because we know that in this case, 17537c478bd9Sstevel@tonic-gate * this function does nothing. 17547c478bd9Sstevel@tonic-gate * 17557c478bd9Sstevel@tonic-gate * 4225415: If the parent isn't attached, or the child 17567c478bd9Sstevel@tonic-gate * hasn't been named by the parent yet, use the default 17577c478bd9Sstevel@tonic-gate * ddi_bus_prop_op as a proxy for the parent. This 17587c478bd9Sstevel@tonic-gate * allows property lookups in any child/parent state to 17597c478bd9Sstevel@tonic-gate * include 'prom' and inherited properties, even when 17607c478bd9Sstevel@tonic-gate * there are no drivers attached to the child or parent. 17617c478bd9Sstevel@tonic-gate */ 17627c478bd9Sstevel@tonic-gate 17637c478bd9Sstevel@tonic-gate bop = ddi_bus_prop_op; 1764737d277aScth if (i_ddi_devi_attached(pdip) && 17657c478bd9Sstevel@tonic-gate (i_ddi_node_state(dip) >= DS_INITIALIZED)) 17667c478bd9Sstevel@tonic-gate bop = DEVI(pdip)->devi_ops->devo_bus_ops->bus_prop_op; 17677c478bd9Sstevel@tonic-gate 17687c478bd9Sstevel@tonic-gate i = DDI_PROP_NOT_FOUND; 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate if ((bop != ddi_bus_prop_op) || ndi_dev_is_prom_node(dip)) { 17717c478bd9Sstevel@tonic-gate i = (*bop)(dev, pdip, dip, prop_op, 17727c478bd9Sstevel@tonic-gate flags | DDI_PROP_DONTPASS, 17737c478bd9Sstevel@tonic-gate name, valuep, lengthp); 17747c478bd9Sstevel@tonic-gate } 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate if ((flags & DDI_PROP_DONTPASS) || 17777c478bd9Sstevel@tonic-gate (i != DDI_PROP_NOT_FOUND)) 17787c478bd9Sstevel@tonic-gate return (i); 17797c478bd9Sstevel@tonic-gate 17807c478bd9Sstevel@tonic-gate dip = pdip; 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 17837c478bd9Sstevel@tonic-gate } 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate /* 17877c478bd9Sstevel@tonic-gate * ddi_prop_op: The basic property operator for drivers. 17887c478bd9Sstevel@tonic-gate * 17897c478bd9Sstevel@tonic-gate * In ddi_prop_op, the type of valuep is interpreted based on prop_op: 17907c478bd9Sstevel@tonic-gate * 17917c478bd9Sstevel@tonic-gate * prop_op valuep 17927c478bd9Sstevel@tonic-gate * ------ ------ 17937c478bd9Sstevel@tonic-gate * 17947c478bd9Sstevel@tonic-gate * PROP_LEN <unused> 17957c478bd9Sstevel@tonic-gate * 17967c478bd9Sstevel@tonic-gate * PROP_LEN_AND_VAL_BUF Pointer to callers buffer 17977c478bd9Sstevel@tonic-gate * 17987c478bd9Sstevel@tonic-gate * PROP_LEN_AND_VAL_ALLOC Address of callers pointer (will be set to 17997c478bd9Sstevel@tonic-gate * address of allocated buffer, if successful) 18007c478bd9Sstevel@tonic-gate */ 18017c478bd9Sstevel@tonic-gate int 18027c478bd9Sstevel@tonic-gate ddi_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags, 18037c478bd9Sstevel@tonic-gate char *name, caddr_t valuep, int *lengthp) 18047c478bd9Sstevel@tonic-gate { 18057c478bd9Sstevel@tonic-gate int i; 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate ASSERT((mod_flags & DDI_PROP_TYPE_MASK) == 0); 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate /* 18107c478bd9Sstevel@tonic-gate * If this was originally an LDI prop lookup then we bail here. 18117c478bd9Sstevel@tonic-gate * The reason is that the LDI property lookup interfaces first call 18127c478bd9Sstevel@tonic-gate * a drivers prop_op() entry point to allow it to override 18137c478bd9Sstevel@tonic-gate * properties. But if we've made it here, then the driver hasn't 18147c478bd9Sstevel@tonic-gate * overriden any properties. We don't want to continue with the 18157c478bd9Sstevel@tonic-gate * property search here because we don't have any type inforamtion. 18167c478bd9Sstevel@tonic-gate * When we return failure, the LDI interfaces will then proceed to 18177c478bd9Sstevel@tonic-gate * call the typed property interfaces to look up the property. 18187c478bd9Sstevel@tonic-gate */ 18197c478bd9Sstevel@tonic-gate if (mod_flags & DDI_PROP_DYNAMIC) 18207c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 18217c478bd9Sstevel@tonic-gate 18227c478bd9Sstevel@tonic-gate /* 18237c478bd9Sstevel@tonic-gate * check for pre-typed property consumer asking for typed property: 18247c478bd9Sstevel@tonic-gate * see e_ddi_getprop_int64. 18257c478bd9Sstevel@tonic-gate */ 18267c478bd9Sstevel@tonic-gate if (mod_flags & DDI_PROP_CONSUMER_TYPED) 18277c478bd9Sstevel@tonic-gate mod_flags |= DDI_PROP_TYPE_INT64; 18287c478bd9Sstevel@tonic-gate mod_flags |= DDI_PROP_TYPE_ANY; 18297c478bd9Sstevel@tonic-gate 18307c478bd9Sstevel@tonic-gate i = ddi_prop_search_common(dev, dip, prop_op, 1831184cd04cScth mod_flags, name, valuep, (uint_t *)lengthp); 18327c478bd9Sstevel@tonic-gate if (i == DDI_PROP_FOUND_1275) 18337c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 18347c478bd9Sstevel@tonic-gate return (i); 18357c478bd9Sstevel@tonic-gate } 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate /* 1838184cd04cScth * ddi_prop_op_nblocks_blksize: The basic property operator for drivers that 1839184cd04cScth * maintain size in number of blksize blocks. Provides a dynamic property 1840184cd04cScth * implementation for size oriented properties based on nblocks64 and blksize 1841184cd04cScth * values passed in by the driver. Fallback to ddi_prop_op if the nblocks64 1842184cd04cScth * is too large. This interface should not be used with a nblocks64 that 1843184cd04cScth * represents the driver's idea of how to represent unknown, if nblocks is 1844184cd04cScth * unknown use ddi_prop_op. 18457c478bd9Sstevel@tonic-gate */ 18467c478bd9Sstevel@tonic-gate int 1847184cd04cScth ddi_prop_op_nblocks_blksize(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 1848184cd04cScth int mod_flags, char *name, caddr_t valuep, int *lengthp, 1849184cd04cScth uint64_t nblocks64, uint_t blksize) 18507c478bd9Sstevel@tonic-gate { 18517c478bd9Sstevel@tonic-gate uint64_t size64; 1852184cd04cScth int blkshift; 1853184cd04cScth 1854184cd04cScth /* convert block size to shift value */ 1855184cd04cScth ASSERT(BIT_ONLYONESET(blksize)); 1856184cd04cScth blkshift = highbit(blksize) - 1; 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate /* 18597c478bd9Sstevel@tonic-gate * There is no point in supporting nblocks64 values that don't have 18607c478bd9Sstevel@tonic-gate * an accurate uint64_t byte count representation. 18617c478bd9Sstevel@tonic-gate */ 1862184cd04cScth if (nblocks64 >= (UINT64_MAX >> blkshift)) 18637c478bd9Sstevel@tonic-gate return (ddi_prop_op(dev, dip, prop_op, mod_flags, 18647c478bd9Sstevel@tonic-gate name, valuep, lengthp)); 18657c478bd9Sstevel@tonic-gate 1866184cd04cScth size64 = nblocks64 << blkshift; 1867184cd04cScth return (ddi_prop_op_size_blksize(dev, dip, prop_op, mod_flags, 1868184cd04cScth name, valuep, lengthp, size64, blksize)); 18697c478bd9Sstevel@tonic-gate } 18707c478bd9Sstevel@tonic-gate 18717c478bd9Sstevel@tonic-gate /* 1872184cd04cScth * ddi_prop_op_nblocks: ddi_prop_op_nblocks_blksize with DEV_BSIZE blksize. 1873184cd04cScth */ 1874184cd04cScth int 1875184cd04cScth ddi_prop_op_nblocks(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 1876184cd04cScth int mod_flags, char *name, caddr_t valuep, int *lengthp, uint64_t nblocks64) 1877184cd04cScth { 1878184cd04cScth return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, 1879184cd04cScth mod_flags, name, valuep, lengthp, nblocks64, DEV_BSIZE)); 1880184cd04cScth } 1881184cd04cScth 1882184cd04cScth /* 1883184cd04cScth * ddi_prop_op_size_blksize: The basic property operator for block drivers that 1884184cd04cScth * maintain size in bytes. Provides a of dynamic property implementation for 1885184cd04cScth * size oriented properties based on size64 value and blksize passed in by the 1886184cd04cScth * driver. Fallback to ddi_prop_op if the size64 is too large. This interface 1887184cd04cScth * should not be used with a size64 that represents the driver's idea of how 1888184cd04cScth * to represent unknown, if size is unknown use ddi_prop_op. 18897c478bd9Sstevel@tonic-gate * 18907c478bd9Sstevel@tonic-gate * NOTE: the legacy "nblocks"/"size" properties are treated as 32-bit unsigned 18917c478bd9Sstevel@tonic-gate * integers. While the most likely interface to request them ([bc]devi_size) 18927c478bd9Sstevel@tonic-gate * is declared int (signed) there is no enforcement of this, which means we 18937c478bd9Sstevel@tonic-gate * can't enforce limitations here without risking regression. 18947c478bd9Sstevel@tonic-gate */ 18957c478bd9Sstevel@tonic-gate int 1896184cd04cScth ddi_prop_op_size_blksize(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 1897184cd04cScth int mod_flags, char *name, caddr_t valuep, int *lengthp, uint64_t size64, 1898184cd04cScth uint_t blksize) 18997c478bd9Sstevel@tonic-gate { 19007c478bd9Sstevel@tonic-gate uint64_t nblocks64; 19017c478bd9Sstevel@tonic-gate int callers_length; 19027c478bd9Sstevel@tonic-gate caddr_t buffer; 1903184cd04cScth int blkshift; 1904184cd04cScth 1905b9ccdc5aScth /* 1906b9ccdc5aScth * This is a kludge to support capture of size(9P) pure dynamic 1907b9ccdc5aScth * properties in snapshots for non-cmlb code (without exposing 1908b9ccdc5aScth * i_ddi_prop_dyn changes). When everyone uses cmlb, this code 1909b9ccdc5aScth * should be removed. 1910b9ccdc5aScth */ 1911b9ccdc5aScth if (i_ddi_prop_dyn_driver_get(dip) == NULL) { 1912b9ccdc5aScth static i_ddi_prop_dyn_t prop_dyn_size[] = { 1913b9ccdc5aScth {"Size", DDI_PROP_TYPE_INT64, S_IFCHR}, 1914b9ccdc5aScth {"Nblocks", DDI_PROP_TYPE_INT64, S_IFBLK}, 1915b9ccdc5aScth {NULL} 1916b9ccdc5aScth }; 1917b9ccdc5aScth i_ddi_prop_dyn_driver_set(dip, prop_dyn_size); 1918b9ccdc5aScth } 1919b9ccdc5aScth 1920184cd04cScth /* convert block size to shift value */ 1921184cd04cScth ASSERT(BIT_ONLYONESET(blksize)); 1922184cd04cScth blkshift = highbit(blksize) - 1; 19237c478bd9Sstevel@tonic-gate 19247c478bd9Sstevel@tonic-gate /* compute DEV_BSIZE nblocks value */ 1925184cd04cScth nblocks64 = size64 >> blkshift; 19267c478bd9Sstevel@tonic-gate 19277c478bd9Sstevel@tonic-gate /* get callers length, establish length of our dynamic properties */ 19287c478bd9Sstevel@tonic-gate callers_length = *lengthp; 19297c478bd9Sstevel@tonic-gate 19307c478bd9Sstevel@tonic-gate if (strcmp(name, "Nblocks") == 0) 19317c478bd9Sstevel@tonic-gate *lengthp = sizeof (uint64_t); 19327c478bd9Sstevel@tonic-gate else if (strcmp(name, "Size") == 0) 19337c478bd9Sstevel@tonic-gate *lengthp = sizeof (uint64_t); 19347c478bd9Sstevel@tonic-gate else if ((strcmp(name, "nblocks") == 0) && (nblocks64 < UINT_MAX)) 19357c478bd9Sstevel@tonic-gate *lengthp = sizeof (uint32_t); 19367c478bd9Sstevel@tonic-gate else if ((strcmp(name, "size") == 0) && (size64 < UINT_MAX)) 19377c478bd9Sstevel@tonic-gate *lengthp = sizeof (uint32_t); 1938184cd04cScth else if ((strcmp(name, "blksize") == 0) && (blksize < UINT_MAX)) 1939184cd04cScth *lengthp = sizeof (uint32_t); 19407c478bd9Sstevel@tonic-gate else { 19417c478bd9Sstevel@tonic-gate /* fallback to ddi_prop_op */ 19427c478bd9Sstevel@tonic-gate return (ddi_prop_op(dev, dip, prop_op, mod_flags, 19437c478bd9Sstevel@tonic-gate name, valuep, lengthp)); 19447c478bd9Sstevel@tonic-gate } 19457c478bd9Sstevel@tonic-gate 19467c478bd9Sstevel@tonic-gate /* service request for the length of the property */ 19477c478bd9Sstevel@tonic-gate if (prop_op == PROP_LEN) 19487c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 19497c478bd9Sstevel@tonic-gate 19507c478bd9Sstevel@tonic-gate switch (prop_op) { 19517c478bd9Sstevel@tonic-gate case PROP_LEN_AND_VAL_ALLOC: 19527c478bd9Sstevel@tonic-gate if ((buffer = kmem_alloc(*lengthp, 19537c478bd9Sstevel@tonic-gate (mod_flags & DDI_PROP_CANSLEEP) ? 19547c478bd9Sstevel@tonic-gate KM_SLEEP : KM_NOSLEEP)) == NULL) 19557c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 19567c478bd9Sstevel@tonic-gate 19577c478bd9Sstevel@tonic-gate *(caddr_t *)valuep = buffer; /* set callers buf ptr */ 19587c478bd9Sstevel@tonic-gate break; 19597c478bd9Sstevel@tonic-gate 19607c478bd9Sstevel@tonic-gate case PROP_LEN_AND_VAL_BUF: 1961b9ccdc5aScth /* the length of the property and the request must match */ 1962b9ccdc5aScth if (callers_length != *lengthp) 1963b9ccdc5aScth return (DDI_PROP_INVAL_ARG); 1964b9ccdc5aScth 19657c478bd9Sstevel@tonic-gate buffer = valuep; /* get callers buf ptr */ 19667c478bd9Sstevel@tonic-gate break; 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate default: 19697c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 19707c478bd9Sstevel@tonic-gate } 19717c478bd9Sstevel@tonic-gate 19727c478bd9Sstevel@tonic-gate /* transfer the value into the buffer */ 19737c478bd9Sstevel@tonic-gate if (strcmp(name, "Nblocks") == 0) 19747c478bd9Sstevel@tonic-gate *((uint64_t *)buffer) = nblocks64; 19757c478bd9Sstevel@tonic-gate else if (strcmp(name, "Size") == 0) 19767c478bd9Sstevel@tonic-gate *((uint64_t *)buffer) = size64; 19777c478bd9Sstevel@tonic-gate else if (strcmp(name, "nblocks") == 0) 19787c478bd9Sstevel@tonic-gate *((uint32_t *)buffer) = (uint32_t)nblocks64; 19797c478bd9Sstevel@tonic-gate else if (strcmp(name, "size") == 0) 19807c478bd9Sstevel@tonic-gate *((uint32_t *)buffer) = (uint32_t)size64; 1981184cd04cScth else if (strcmp(name, "blksize") == 0) 1982184cd04cScth *((uint32_t *)buffer) = (uint32_t)blksize; 19837c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate 1986184cd04cScth /* 1987184cd04cScth * ddi_prop_op_size: ddi_prop_op_size_blksize with DEV_BSIZE block size. 1988184cd04cScth */ 1989184cd04cScth int 1990184cd04cScth ddi_prop_op_size(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 1991184cd04cScth int mod_flags, char *name, caddr_t valuep, int *lengthp, uint64_t size64) 1992184cd04cScth { 1993184cd04cScth return (ddi_prop_op_size_blksize(dev, dip, prop_op, 1994184cd04cScth mod_flags, name, valuep, lengthp, size64, DEV_BSIZE)); 1995184cd04cScth } 1996184cd04cScth 19977c478bd9Sstevel@tonic-gate /* 19987c478bd9Sstevel@tonic-gate * Variable length props... 19997c478bd9Sstevel@tonic-gate */ 20007c478bd9Sstevel@tonic-gate 20017c478bd9Sstevel@tonic-gate /* 20027c478bd9Sstevel@tonic-gate * ddi_getlongprop: Get variable length property len+val into a buffer 20037c478bd9Sstevel@tonic-gate * allocated by property provider via kmem_alloc. Requester 20047c478bd9Sstevel@tonic-gate * is responsible for freeing returned property via kmem_free. 20057c478bd9Sstevel@tonic-gate * 20067c478bd9Sstevel@tonic-gate * Arguments: 20077c478bd9Sstevel@tonic-gate * 20087c478bd9Sstevel@tonic-gate * dev_t: Input: dev_t of property. 20097c478bd9Sstevel@tonic-gate * dip: Input: dev_info_t pointer of child. 20107c478bd9Sstevel@tonic-gate * flags: Input: Possible flag modifiers are: 20117c478bd9Sstevel@tonic-gate * DDI_PROP_DONTPASS: Don't pass to parent if prop not found. 20127c478bd9Sstevel@tonic-gate * DDI_PROP_CANSLEEP: Memory allocation may sleep. 20137c478bd9Sstevel@tonic-gate * name: Input: name of property. 20147c478bd9Sstevel@tonic-gate * valuep: Output: Addr of callers buffer pointer. 20157c478bd9Sstevel@tonic-gate * lengthp:Output: *lengthp will contain prop length on exit. 20167c478bd9Sstevel@tonic-gate * 20177c478bd9Sstevel@tonic-gate * Possible Returns: 20187c478bd9Sstevel@tonic-gate * 20197c478bd9Sstevel@tonic-gate * DDI_PROP_SUCCESS: Prop found and returned. 20207c478bd9Sstevel@tonic-gate * DDI_PROP_NOT_FOUND: Prop not found 20217c478bd9Sstevel@tonic-gate * DDI_PROP_UNDEFINED: Prop explicitly undefined. 20227c478bd9Sstevel@tonic-gate * DDI_PROP_NO_MEMORY: Prop found, but unable to alloc mem. 20237c478bd9Sstevel@tonic-gate */ 20247c478bd9Sstevel@tonic-gate 20257c478bd9Sstevel@tonic-gate int 20267c478bd9Sstevel@tonic-gate ddi_getlongprop(dev_t dev, dev_info_t *dip, int flags, 20277c478bd9Sstevel@tonic-gate char *name, caddr_t valuep, int *lengthp) 20287c478bd9Sstevel@tonic-gate { 20297c478bd9Sstevel@tonic-gate return (ddi_prop_op(dev, dip, PROP_LEN_AND_VAL_ALLOC, 20307c478bd9Sstevel@tonic-gate flags, name, valuep, lengthp)); 20317c478bd9Sstevel@tonic-gate } 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate /* 20347c478bd9Sstevel@tonic-gate * 20357c478bd9Sstevel@tonic-gate * ddi_getlongprop_buf: Get long prop into pre-allocated callers 20367c478bd9Sstevel@tonic-gate * buffer. (no memory allocation by provider). 20377c478bd9Sstevel@tonic-gate * 20387c478bd9Sstevel@tonic-gate * dev_t: Input: dev_t of property. 20397c478bd9Sstevel@tonic-gate * dip: Input: dev_info_t pointer of child. 20407c478bd9Sstevel@tonic-gate * flags: Input: DDI_PROP_DONTPASS or NULL 20417c478bd9Sstevel@tonic-gate * name: Input: name of property 20427c478bd9Sstevel@tonic-gate * valuep: Input: ptr to callers buffer. 20437c478bd9Sstevel@tonic-gate * lengthp:I/O: ptr to length of callers buffer on entry, 20447c478bd9Sstevel@tonic-gate * actual length of property on exit. 20457c478bd9Sstevel@tonic-gate * 20467c478bd9Sstevel@tonic-gate * Possible returns: 20477c478bd9Sstevel@tonic-gate * 20487c478bd9Sstevel@tonic-gate * DDI_PROP_SUCCESS Prop found and returned 20497c478bd9Sstevel@tonic-gate * DDI_PROP_NOT_FOUND Prop not found 20507c478bd9Sstevel@tonic-gate * DDI_PROP_UNDEFINED Prop explicitly undefined. 20517c478bd9Sstevel@tonic-gate * DDI_PROP_BUF_TOO_SMALL Prop found, callers buf too small, 20527c478bd9Sstevel@tonic-gate * no value returned, but actual prop 20537c478bd9Sstevel@tonic-gate * length returned in *lengthp 20547c478bd9Sstevel@tonic-gate * 20557c478bd9Sstevel@tonic-gate */ 20567c478bd9Sstevel@tonic-gate 20577c478bd9Sstevel@tonic-gate int 20587c478bd9Sstevel@tonic-gate ddi_getlongprop_buf(dev_t dev, dev_info_t *dip, int flags, 20597c478bd9Sstevel@tonic-gate char *name, caddr_t valuep, int *lengthp) 20607c478bd9Sstevel@tonic-gate { 20617c478bd9Sstevel@tonic-gate return (ddi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF, 20627c478bd9Sstevel@tonic-gate flags, name, valuep, lengthp)); 20637c478bd9Sstevel@tonic-gate } 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate /* 20667c478bd9Sstevel@tonic-gate * Integer/boolean sized props. 20677c478bd9Sstevel@tonic-gate * 20687c478bd9Sstevel@tonic-gate * Call is value only... returns found boolean or int sized prop value or 20697c478bd9Sstevel@tonic-gate * defvalue if prop not found or is wrong length or is explicitly undefined. 20707c478bd9Sstevel@tonic-gate * Only flag is DDI_PROP_DONTPASS... 20717c478bd9Sstevel@tonic-gate * 20727c478bd9Sstevel@tonic-gate * By convention, this interface returns boolean (0) sized properties 20737c478bd9Sstevel@tonic-gate * as value (int)1. 20747c478bd9Sstevel@tonic-gate * 20757c478bd9Sstevel@tonic-gate * This never returns an error, if property not found or specifically 20767c478bd9Sstevel@tonic-gate * undefined, the input `defvalue' is returned. 20777c478bd9Sstevel@tonic-gate */ 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate int 20807c478bd9Sstevel@tonic-gate ddi_getprop(dev_t dev, dev_info_t *dip, int flags, char *name, int defvalue) 20817c478bd9Sstevel@tonic-gate { 20827c478bd9Sstevel@tonic-gate int propvalue = defvalue; 20837c478bd9Sstevel@tonic-gate int proplength = sizeof (int); 20847c478bd9Sstevel@tonic-gate int error; 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate error = ddi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF, 20877c478bd9Sstevel@tonic-gate flags, name, (caddr_t)&propvalue, &proplength); 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate if ((error == DDI_PROP_SUCCESS) && (proplength == 0)) 20907c478bd9Sstevel@tonic-gate propvalue = 1; 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate return (propvalue); 20937c478bd9Sstevel@tonic-gate } 20947c478bd9Sstevel@tonic-gate 20957c478bd9Sstevel@tonic-gate /* 20967c478bd9Sstevel@tonic-gate * Get prop length interface: flags are 0 or DDI_PROP_DONTPASS 20977c478bd9Sstevel@tonic-gate * if returns DDI_PROP_SUCCESS, length returned in *lengthp. 20987c478bd9Sstevel@tonic-gate */ 20997c478bd9Sstevel@tonic-gate 21007c478bd9Sstevel@tonic-gate int 21017c478bd9Sstevel@tonic-gate ddi_getproplen(dev_t dev, dev_info_t *dip, int flags, char *name, int *lengthp) 21027c478bd9Sstevel@tonic-gate { 21037c478bd9Sstevel@tonic-gate return (ddi_prop_op(dev, dip, PROP_LEN, flags, name, NULL, lengthp)); 21047c478bd9Sstevel@tonic-gate } 21057c478bd9Sstevel@tonic-gate 21067c478bd9Sstevel@tonic-gate /* 21077c478bd9Sstevel@tonic-gate * Allocate a struct prop_driver_data, along with 'size' bytes 21087c478bd9Sstevel@tonic-gate * for decoded property data. This structure is freed by 21097c478bd9Sstevel@tonic-gate * calling ddi_prop_free(9F). 21107c478bd9Sstevel@tonic-gate */ 21117c478bd9Sstevel@tonic-gate static void * 21127c478bd9Sstevel@tonic-gate ddi_prop_decode_alloc(size_t size, void (*prop_free)(struct prop_driver_data *)) 21137c478bd9Sstevel@tonic-gate { 21147c478bd9Sstevel@tonic-gate struct prop_driver_data *pdd; 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate /* 21177c478bd9Sstevel@tonic-gate * Allocate a structure with enough memory to store the decoded data. 21187c478bd9Sstevel@tonic-gate */ 21197c478bd9Sstevel@tonic-gate pdd = kmem_zalloc(sizeof (struct prop_driver_data) + size, KM_SLEEP); 21207c478bd9Sstevel@tonic-gate pdd->pdd_size = (sizeof (struct prop_driver_data) + size); 21217c478bd9Sstevel@tonic-gate pdd->pdd_prop_free = prop_free; 21227c478bd9Sstevel@tonic-gate 21237c478bd9Sstevel@tonic-gate /* 21247c478bd9Sstevel@tonic-gate * Return a pointer to the location to put the decoded data. 21257c478bd9Sstevel@tonic-gate */ 21267c478bd9Sstevel@tonic-gate return ((void *)((caddr_t)pdd + sizeof (struct prop_driver_data))); 21277c478bd9Sstevel@tonic-gate } 21287c478bd9Sstevel@tonic-gate 21297c478bd9Sstevel@tonic-gate /* 21307c478bd9Sstevel@tonic-gate * Allocated the memory needed to store the encoded data in the property 21317c478bd9Sstevel@tonic-gate * handle. 21327c478bd9Sstevel@tonic-gate */ 21337c478bd9Sstevel@tonic-gate static int 21347c478bd9Sstevel@tonic-gate ddi_prop_encode_alloc(prop_handle_t *ph, size_t size) 21357c478bd9Sstevel@tonic-gate { 21367c478bd9Sstevel@tonic-gate /* 21377c478bd9Sstevel@tonic-gate * If size is zero, then set data to NULL and size to 0. This 21387c478bd9Sstevel@tonic-gate * is a boolean property. 21397c478bd9Sstevel@tonic-gate */ 21407c478bd9Sstevel@tonic-gate if (size == 0) { 21417c478bd9Sstevel@tonic-gate ph->ph_size = 0; 21427c478bd9Sstevel@tonic-gate ph->ph_data = NULL; 21437c478bd9Sstevel@tonic-gate ph->ph_cur_pos = NULL; 21447c478bd9Sstevel@tonic-gate ph->ph_save_pos = NULL; 21457c478bd9Sstevel@tonic-gate } else { 21467c478bd9Sstevel@tonic-gate if (ph->ph_flags == DDI_PROP_DONTSLEEP) { 21477c478bd9Sstevel@tonic-gate ph->ph_data = kmem_zalloc(size, KM_NOSLEEP); 21487c478bd9Sstevel@tonic-gate if (ph->ph_data == NULL) 21497c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 21507c478bd9Sstevel@tonic-gate } else 21517c478bd9Sstevel@tonic-gate ph->ph_data = kmem_zalloc(size, KM_SLEEP); 21527c478bd9Sstevel@tonic-gate ph->ph_size = size; 21537c478bd9Sstevel@tonic-gate ph->ph_cur_pos = ph->ph_data; 21547c478bd9Sstevel@tonic-gate ph->ph_save_pos = ph->ph_data; 21557c478bd9Sstevel@tonic-gate } 21567c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 21577c478bd9Sstevel@tonic-gate } 21587c478bd9Sstevel@tonic-gate 21597c478bd9Sstevel@tonic-gate /* 21607c478bd9Sstevel@tonic-gate * Free the space allocated by the lookup routines. Each lookup routine 21617c478bd9Sstevel@tonic-gate * returns a pointer to the decoded data to the driver. The driver then 21627c478bd9Sstevel@tonic-gate * passes this pointer back to us. This data actually lives in a struct 21637c478bd9Sstevel@tonic-gate * prop_driver_data. We use negative indexing to find the beginning of 21647c478bd9Sstevel@tonic-gate * the structure and then free the entire structure using the size and 21657c478bd9Sstevel@tonic-gate * the free routine stored in the structure. 21667c478bd9Sstevel@tonic-gate */ 21677c478bd9Sstevel@tonic-gate void 21687c478bd9Sstevel@tonic-gate ddi_prop_free(void *datap) 21697c478bd9Sstevel@tonic-gate { 21707c478bd9Sstevel@tonic-gate struct prop_driver_data *pdd; 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate /* 21737c478bd9Sstevel@tonic-gate * Get the structure 21747c478bd9Sstevel@tonic-gate */ 21757c478bd9Sstevel@tonic-gate pdd = (struct prop_driver_data *) 2176184cd04cScth ((caddr_t)datap - sizeof (struct prop_driver_data)); 21777c478bd9Sstevel@tonic-gate /* 21787c478bd9Sstevel@tonic-gate * Call the free routine to free it 21797c478bd9Sstevel@tonic-gate */ 21807c478bd9Sstevel@tonic-gate (*pdd->pdd_prop_free)(pdd); 21817c478bd9Sstevel@tonic-gate } 21827c478bd9Sstevel@tonic-gate 21837c478bd9Sstevel@tonic-gate /* 21847c478bd9Sstevel@tonic-gate * Free the data associated with an array of ints, 21857c478bd9Sstevel@tonic-gate * allocated with ddi_prop_decode_alloc(). 21867c478bd9Sstevel@tonic-gate */ 21877c478bd9Sstevel@tonic-gate static void 21887c478bd9Sstevel@tonic-gate ddi_prop_free_ints(struct prop_driver_data *pdd) 21897c478bd9Sstevel@tonic-gate { 21907c478bd9Sstevel@tonic-gate kmem_free(pdd, pdd->pdd_size); 21917c478bd9Sstevel@tonic-gate } 21927c478bd9Sstevel@tonic-gate 21937c478bd9Sstevel@tonic-gate /* 21947c478bd9Sstevel@tonic-gate * Free a single string property or a single string contained within 21957c478bd9Sstevel@tonic-gate * the argv style return value of an array of strings. 21967c478bd9Sstevel@tonic-gate */ 21977c478bd9Sstevel@tonic-gate static void 21987c478bd9Sstevel@tonic-gate ddi_prop_free_string(struct prop_driver_data *pdd) 21997c478bd9Sstevel@tonic-gate { 22007c478bd9Sstevel@tonic-gate kmem_free(pdd, pdd->pdd_size); 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate } 22037c478bd9Sstevel@tonic-gate 22047c478bd9Sstevel@tonic-gate /* 22057c478bd9Sstevel@tonic-gate * Free an array of strings. 22067c478bd9Sstevel@tonic-gate */ 22077c478bd9Sstevel@tonic-gate static void 22087c478bd9Sstevel@tonic-gate ddi_prop_free_strings(struct prop_driver_data *pdd) 22097c478bd9Sstevel@tonic-gate { 22107c478bd9Sstevel@tonic-gate kmem_free(pdd, pdd->pdd_size); 22117c478bd9Sstevel@tonic-gate } 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate /* 22147c478bd9Sstevel@tonic-gate * Free the data associated with an array of bytes. 22157c478bd9Sstevel@tonic-gate */ 22167c478bd9Sstevel@tonic-gate static void 22177c478bd9Sstevel@tonic-gate ddi_prop_free_bytes(struct prop_driver_data *pdd) 22187c478bd9Sstevel@tonic-gate { 22197c478bd9Sstevel@tonic-gate kmem_free(pdd, pdd->pdd_size); 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate 22227c478bd9Sstevel@tonic-gate /* 22237c478bd9Sstevel@tonic-gate * Reset the current location pointer in the property handle to the 22247c478bd9Sstevel@tonic-gate * beginning of the data. 22257c478bd9Sstevel@tonic-gate */ 22267c478bd9Sstevel@tonic-gate void 22277c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(prop_handle_t *ph) 22287c478bd9Sstevel@tonic-gate { 22297c478bd9Sstevel@tonic-gate ph->ph_cur_pos = ph->ph_data; 22307c478bd9Sstevel@tonic-gate ph->ph_save_pos = ph->ph_data; 22317c478bd9Sstevel@tonic-gate } 22327c478bd9Sstevel@tonic-gate 22337c478bd9Sstevel@tonic-gate /* 22347c478bd9Sstevel@tonic-gate * Restore the current location pointer in the property handle to the 22357c478bd9Sstevel@tonic-gate * saved position. 22367c478bd9Sstevel@tonic-gate */ 22377c478bd9Sstevel@tonic-gate void 22387c478bd9Sstevel@tonic-gate ddi_prop_save_pos(prop_handle_t *ph) 22397c478bd9Sstevel@tonic-gate { 22407c478bd9Sstevel@tonic-gate ph->ph_save_pos = ph->ph_cur_pos; 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate 22437c478bd9Sstevel@tonic-gate /* 22447c478bd9Sstevel@tonic-gate * Save the location that the current location pointer is pointing to.. 22457c478bd9Sstevel@tonic-gate */ 22467c478bd9Sstevel@tonic-gate void 22477c478bd9Sstevel@tonic-gate ddi_prop_restore_pos(prop_handle_t *ph) 22487c478bd9Sstevel@tonic-gate { 22497c478bd9Sstevel@tonic-gate ph->ph_cur_pos = ph->ph_save_pos; 22507c478bd9Sstevel@tonic-gate } 22517c478bd9Sstevel@tonic-gate 22527c478bd9Sstevel@tonic-gate /* 22537c478bd9Sstevel@tonic-gate * Property encode/decode functions 22547c478bd9Sstevel@tonic-gate */ 22557c478bd9Sstevel@tonic-gate 22567c478bd9Sstevel@tonic-gate /* 22577c478bd9Sstevel@tonic-gate * Decode a single integer property 22587c478bd9Sstevel@tonic-gate */ 22597c478bd9Sstevel@tonic-gate static int 22607c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_int(prop_handle_t *ph, void *data, uint_t *nelements) 22617c478bd9Sstevel@tonic-gate { 22627c478bd9Sstevel@tonic-gate int i; 22637c478bd9Sstevel@tonic-gate int tmp; 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate /* 22667c478bd9Sstevel@tonic-gate * If there is nothing to decode return an error 22677c478bd9Sstevel@tonic-gate */ 22687c478bd9Sstevel@tonic-gate if (ph->ph_size == 0) 22697c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 22707c478bd9Sstevel@tonic-gate 22717c478bd9Sstevel@tonic-gate /* 22727c478bd9Sstevel@tonic-gate * Decode the property as a single integer and return it 22737c478bd9Sstevel@tonic-gate * in data if we were able to decode it. 22747c478bd9Sstevel@tonic-gate */ 22757c478bd9Sstevel@tonic-gate i = DDI_PROP_INT(ph, DDI_PROP_CMD_DECODE, &tmp); 22767c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 22777c478bd9Sstevel@tonic-gate switch (i) { 22787c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 22797c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 22807c478bd9Sstevel@tonic-gate 22817c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 22827c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 22837c478bd9Sstevel@tonic-gate } 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate 22867c478bd9Sstevel@tonic-gate *(int *)data = tmp; 22877c478bd9Sstevel@tonic-gate *nelements = 1; 22887c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 22897c478bd9Sstevel@tonic-gate } 22907c478bd9Sstevel@tonic-gate 22917c478bd9Sstevel@tonic-gate /* 22927c478bd9Sstevel@tonic-gate * Decode a single 64 bit integer property 22937c478bd9Sstevel@tonic-gate */ 22947c478bd9Sstevel@tonic-gate static int 22957c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_int64(prop_handle_t *ph, void *data, uint_t *nelements) 22967c478bd9Sstevel@tonic-gate { 22977c478bd9Sstevel@tonic-gate int i; 22987c478bd9Sstevel@tonic-gate int64_t tmp; 22997c478bd9Sstevel@tonic-gate 23007c478bd9Sstevel@tonic-gate /* 23017c478bd9Sstevel@tonic-gate * If there is nothing to decode return an error 23027c478bd9Sstevel@tonic-gate */ 23037c478bd9Sstevel@tonic-gate if (ph->ph_size == 0) 23047c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate /* 23077c478bd9Sstevel@tonic-gate * Decode the property as a single integer and return it 23087c478bd9Sstevel@tonic-gate * in data if we were able to decode it. 23097c478bd9Sstevel@tonic-gate */ 23107c478bd9Sstevel@tonic-gate i = DDI_PROP_INT64(ph, DDI_PROP_CMD_DECODE, &tmp); 23117c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 23127c478bd9Sstevel@tonic-gate switch (i) { 23137c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 23147c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 23157c478bd9Sstevel@tonic-gate 23167c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 23177c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 23187c478bd9Sstevel@tonic-gate } 23197c478bd9Sstevel@tonic-gate } 23207c478bd9Sstevel@tonic-gate 23217c478bd9Sstevel@tonic-gate *(int64_t *)data = tmp; 23227c478bd9Sstevel@tonic-gate *nelements = 1; 23237c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 23247c478bd9Sstevel@tonic-gate } 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate /* 23277c478bd9Sstevel@tonic-gate * Decode an array of integers property 23287c478bd9Sstevel@tonic-gate */ 23297c478bd9Sstevel@tonic-gate static int 23307c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_ints(prop_handle_t *ph, void *data, uint_t *nelements) 23317c478bd9Sstevel@tonic-gate { 23327c478bd9Sstevel@tonic-gate int i; 23337c478bd9Sstevel@tonic-gate int cnt = 0; 23347c478bd9Sstevel@tonic-gate int *tmp; 23357c478bd9Sstevel@tonic-gate int *intp; 23367c478bd9Sstevel@tonic-gate int n; 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate /* 23397c478bd9Sstevel@tonic-gate * Figure out how many array elements there are by going through the 23407c478bd9Sstevel@tonic-gate * data without decoding it first and counting. 23417c478bd9Sstevel@tonic-gate */ 23427c478bd9Sstevel@tonic-gate for (;;) { 23437c478bd9Sstevel@tonic-gate i = DDI_PROP_INT(ph, DDI_PROP_CMD_SKIP, NULL); 23447c478bd9Sstevel@tonic-gate if (i < 0) 23457c478bd9Sstevel@tonic-gate break; 23467c478bd9Sstevel@tonic-gate cnt++; 23477c478bd9Sstevel@tonic-gate } 23487c478bd9Sstevel@tonic-gate 23497c478bd9Sstevel@tonic-gate /* 23507c478bd9Sstevel@tonic-gate * If there are no elements return an error 23517c478bd9Sstevel@tonic-gate */ 23527c478bd9Sstevel@tonic-gate if (cnt == 0) 23537c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 23547c478bd9Sstevel@tonic-gate 23557c478bd9Sstevel@tonic-gate /* 23567c478bd9Sstevel@tonic-gate * If we cannot skip through the data, we cannot decode it 23577c478bd9Sstevel@tonic-gate */ 23587c478bd9Sstevel@tonic-gate if (i == DDI_PROP_RESULT_ERROR) 23597c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 23607c478bd9Sstevel@tonic-gate 23617c478bd9Sstevel@tonic-gate /* 23627c478bd9Sstevel@tonic-gate * Reset the data pointer to the beginning of the encoded data 23637c478bd9Sstevel@tonic-gate */ 23647c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 23657c478bd9Sstevel@tonic-gate 23667c478bd9Sstevel@tonic-gate /* 23677c478bd9Sstevel@tonic-gate * Allocated memory to store the decoded value in. 23687c478bd9Sstevel@tonic-gate */ 23697c478bd9Sstevel@tonic-gate intp = ddi_prop_decode_alloc((cnt * sizeof (int)), 2370184cd04cScth ddi_prop_free_ints); 23717c478bd9Sstevel@tonic-gate 23727c478bd9Sstevel@tonic-gate /* 23737c478bd9Sstevel@tonic-gate * Decode each element and place it in the space we just allocated 23747c478bd9Sstevel@tonic-gate */ 23757c478bd9Sstevel@tonic-gate tmp = intp; 23767c478bd9Sstevel@tonic-gate for (n = 0; n < cnt; n++, tmp++) { 23777c478bd9Sstevel@tonic-gate i = DDI_PROP_INT(ph, DDI_PROP_CMD_DECODE, tmp); 23787c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 23797c478bd9Sstevel@tonic-gate /* 23807c478bd9Sstevel@tonic-gate * Free the space we just allocated 23817c478bd9Sstevel@tonic-gate * and return an error. 23827c478bd9Sstevel@tonic-gate */ 23837c478bd9Sstevel@tonic-gate ddi_prop_free(intp); 23847c478bd9Sstevel@tonic-gate switch (i) { 23857c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 23867c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 23877c478bd9Sstevel@tonic-gate 23887c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 23897c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate } 23927c478bd9Sstevel@tonic-gate } 23937c478bd9Sstevel@tonic-gate 23947c478bd9Sstevel@tonic-gate *nelements = cnt; 23957c478bd9Sstevel@tonic-gate *(int **)data = intp; 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 23987c478bd9Sstevel@tonic-gate } 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate /* 24017c478bd9Sstevel@tonic-gate * Decode a 64 bit integer array property 24027c478bd9Sstevel@tonic-gate */ 24037c478bd9Sstevel@tonic-gate static int 24047c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_int64_array(prop_handle_t *ph, void *data, uint_t *nelements) 24057c478bd9Sstevel@tonic-gate { 24067c478bd9Sstevel@tonic-gate int i; 24077c478bd9Sstevel@tonic-gate int n; 24087c478bd9Sstevel@tonic-gate int cnt = 0; 24097c478bd9Sstevel@tonic-gate int64_t *tmp; 24107c478bd9Sstevel@tonic-gate int64_t *intp; 24117c478bd9Sstevel@tonic-gate 24127c478bd9Sstevel@tonic-gate /* 24137c478bd9Sstevel@tonic-gate * Count the number of array elements by going 24147c478bd9Sstevel@tonic-gate * through the data without decoding it. 24157c478bd9Sstevel@tonic-gate */ 24167c478bd9Sstevel@tonic-gate for (;;) { 24177c478bd9Sstevel@tonic-gate i = DDI_PROP_INT64(ph, DDI_PROP_CMD_SKIP, NULL); 24187c478bd9Sstevel@tonic-gate if (i < 0) 24197c478bd9Sstevel@tonic-gate break; 24207c478bd9Sstevel@tonic-gate cnt++; 24217c478bd9Sstevel@tonic-gate } 24227c478bd9Sstevel@tonic-gate 24237c478bd9Sstevel@tonic-gate /* 24247c478bd9Sstevel@tonic-gate * If there are no elements return an error 24257c478bd9Sstevel@tonic-gate */ 24267c478bd9Sstevel@tonic-gate if (cnt == 0) 24277c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 24287c478bd9Sstevel@tonic-gate 24297c478bd9Sstevel@tonic-gate /* 24307c478bd9Sstevel@tonic-gate * If we cannot skip through the data, we cannot decode it 24317c478bd9Sstevel@tonic-gate */ 24327c478bd9Sstevel@tonic-gate if (i == DDI_PROP_RESULT_ERROR) 24337c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 24347c478bd9Sstevel@tonic-gate 24357c478bd9Sstevel@tonic-gate /* 24367c478bd9Sstevel@tonic-gate * Reset the data pointer to the beginning of the encoded data 24377c478bd9Sstevel@tonic-gate */ 24387c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate /* 24417c478bd9Sstevel@tonic-gate * Allocate memory to store the decoded value. 24427c478bd9Sstevel@tonic-gate */ 24437c478bd9Sstevel@tonic-gate intp = ddi_prop_decode_alloc((cnt * sizeof (int64_t)), 2444184cd04cScth ddi_prop_free_ints); 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate /* 24477c478bd9Sstevel@tonic-gate * Decode each element and place it in the space allocated 24487c478bd9Sstevel@tonic-gate */ 24497c478bd9Sstevel@tonic-gate tmp = intp; 24507c478bd9Sstevel@tonic-gate for (n = 0; n < cnt; n++, tmp++) { 24517c478bd9Sstevel@tonic-gate i = DDI_PROP_INT64(ph, DDI_PROP_CMD_DECODE, tmp); 24527c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 24537c478bd9Sstevel@tonic-gate /* 24547c478bd9Sstevel@tonic-gate * Free the space we just allocated 24557c478bd9Sstevel@tonic-gate * and return an error. 24567c478bd9Sstevel@tonic-gate */ 24577c478bd9Sstevel@tonic-gate ddi_prop_free(intp); 24587c478bd9Sstevel@tonic-gate switch (i) { 24597c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 24607c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 24617c478bd9Sstevel@tonic-gate 24627c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 24637c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 24647c478bd9Sstevel@tonic-gate } 24657c478bd9Sstevel@tonic-gate } 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate *nelements = cnt; 24697c478bd9Sstevel@tonic-gate *(int64_t **)data = intp; 24707c478bd9Sstevel@tonic-gate 24717c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate /* 24757c478bd9Sstevel@tonic-gate * Encode an array of integers property (Can be one element) 24767c478bd9Sstevel@tonic-gate */ 24777c478bd9Sstevel@tonic-gate int 24787c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_ints(prop_handle_t *ph, void *data, uint_t nelements) 24797c478bd9Sstevel@tonic-gate { 24807c478bd9Sstevel@tonic-gate int i; 24817c478bd9Sstevel@tonic-gate int *tmp; 24827c478bd9Sstevel@tonic-gate int cnt; 24837c478bd9Sstevel@tonic-gate int size; 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate /* 24867c478bd9Sstevel@tonic-gate * If there is no data, we cannot do anything 24877c478bd9Sstevel@tonic-gate */ 24887c478bd9Sstevel@tonic-gate if (nelements == 0) 24897c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 24907c478bd9Sstevel@tonic-gate 24917c478bd9Sstevel@tonic-gate /* 24927c478bd9Sstevel@tonic-gate * Get the size of an encoded int. 24937c478bd9Sstevel@tonic-gate */ 24947c478bd9Sstevel@tonic-gate size = DDI_PROP_INT(ph, DDI_PROP_CMD_GET_ESIZE, NULL); 24957c478bd9Sstevel@tonic-gate 24967c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 24977c478bd9Sstevel@tonic-gate switch (size) { 24987c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 24997c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 25027c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 25037c478bd9Sstevel@tonic-gate } 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate 25067c478bd9Sstevel@tonic-gate /* 25077c478bd9Sstevel@tonic-gate * Allocate space in the handle to store the encoded int. 25087c478bd9Sstevel@tonic-gate */ 25097c478bd9Sstevel@tonic-gate if (ddi_prop_encode_alloc(ph, size * nelements) != 2510184cd04cScth DDI_PROP_SUCCESS) 25117c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 25127c478bd9Sstevel@tonic-gate 25137c478bd9Sstevel@tonic-gate /* 25147c478bd9Sstevel@tonic-gate * Encode the array of ints. 25157c478bd9Sstevel@tonic-gate */ 25167c478bd9Sstevel@tonic-gate tmp = (int *)data; 25177c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < nelements; cnt++, tmp++) { 25187c478bd9Sstevel@tonic-gate i = DDI_PROP_INT(ph, DDI_PROP_CMD_ENCODE, tmp); 25197c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 25207c478bd9Sstevel@tonic-gate switch (i) { 25217c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 25227c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 25257c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 25267c478bd9Sstevel@tonic-gate } 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate } 25297c478bd9Sstevel@tonic-gate 25307c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 25317c478bd9Sstevel@tonic-gate } 25327c478bd9Sstevel@tonic-gate 25337c478bd9Sstevel@tonic-gate 25347c478bd9Sstevel@tonic-gate /* 25357c478bd9Sstevel@tonic-gate * Encode a 64 bit integer array property 25367c478bd9Sstevel@tonic-gate */ 25377c478bd9Sstevel@tonic-gate int 25387c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_int64(prop_handle_t *ph, void *data, uint_t nelements) 25397c478bd9Sstevel@tonic-gate { 25407c478bd9Sstevel@tonic-gate int i; 25417c478bd9Sstevel@tonic-gate int cnt; 25427c478bd9Sstevel@tonic-gate int size; 25437c478bd9Sstevel@tonic-gate int64_t *tmp; 25447c478bd9Sstevel@tonic-gate 25457c478bd9Sstevel@tonic-gate /* 25467c478bd9Sstevel@tonic-gate * If there is no data, we cannot do anything 25477c478bd9Sstevel@tonic-gate */ 25487c478bd9Sstevel@tonic-gate if (nelements == 0) 25497c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 25507c478bd9Sstevel@tonic-gate 25517c478bd9Sstevel@tonic-gate /* 25527c478bd9Sstevel@tonic-gate * Get the size of an encoded 64 bit int. 25537c478bd9Sstevel@tonic-gate */ 25547c478bd9Sstevel@tonic-gate size = DDI_PROP_INT64(ph, DDI_PROP_CMD_GET_ESIZE, NULL); 25557c478bd9Sstevel@tonic-gate 25567c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 25577c478bd9Sstevel@tonic-gate switch (size) { 25587c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 25597c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 25607c478bd9Sstevel@tonic-gate 25617c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 25627c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 25637c478bd9Sstevel@tonic-gate } 25647c478bd9Sstevel@tonic-gate } 25657c478bd9Sstevel@tonic-gate 25667c478bd9Sstevel@tonic-gate /* 25677c478bd9Sstevel@tonic-gate * Allocate space in the handle to store the encoded int. 25687c478bd9Sstevel@tonic-gate */ 25697c478bd9Sstevel@tonic-gate if (ddi_prop_encode_alloc(ph, size * nelements) != 25707c478bd9Sstevel@tonic-gate DDI_PROP_SUCCESS) 25717c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 25727c478bd9Sstevel@tonic-gate 25737c478bd9Sstevel@tonic-gate /* 25747c478bd9Sstevel@tonic-gate * Encode the array of ints. 25757c478bd9Sstevel@tonic-gate */ 25767c478bd9Sstevel@tonic-gate tmp = (int64_t *)data; 25777c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < nelements; cnt++, tmp++) { 25787c478bd9Sstevel@tonic-gate i = DDI_PROP_INT64(ph, DDI_PROP_CMD_ENCODE, tmp); 25797c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 25807c478bd9Sstevel@tonic-gate switch (i) { 25817c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 25827c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 25837c478bd9Sstevel@tonic-gate 25847c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 25857c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 25867c478bd9Sstevel@tonic-gate } 25877c478bd9Sstevel@tonic-gate } 25887c478bd9Sstevel@tonic-gate } 25897c478bd9Sstevel@tonic-gate 25907c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 25917c478bd9Sstevel@tonic-gate } 25927c478bd9Sstevel@tonic-gate 25937c478bd9Sstevel@tonic-gate /* 25947c478bd9Sstevel@tonic-gate * Decode a single string property 25957c478bd9Sstevel@tonic-gate */ 25967c478bd9Sstevel@tonic-gate static int 25977c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_string(prop_handle_t *ph, void *data, uint_t *nelements) 25987c478bd9Sstevel@tonic-gate { 25997c478bd9Sstevel@tonic-gate char *tmp; 26007c478bd9Sstevel@tonic-gate char *str; 26017c478bd9Sstevel@tonic-gate int i; 26027c478bd9Sstevel@tonic-gate int size; 26037c478bd9Sstevel@tonic-gate 26047c478bd9Sstevel@tonic-gate /* 26057c478bd9Sstevel@tonic-gate * If there is nothing to decode return an error 26067c478bd9Sstevel@tonic-gate */ 26077c478bd9Sstevel@tonic-gate if (ph->ph_size == 0) 26087c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 26097c478bd9Sstevel@tonic-gate 26107c478bd9Sstevel@tonic-gate /* 26117c478bd9Sstevel@tonic-gate * Get the decoded size of the encoded string. 26127c478bd9Sstevel@tonic-gate */ 26137c478bd9Sstevel@tonic-gate size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_DSIZE, NULL); 26147c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 26157c478bd9Sstevel@tonic-gate switch (size) { 26167c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 26177c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 26187c478bd9Sstevel@tonic-gate 26197c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 26207c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 26217c478bd9Sstevel@tonic-gate } 26227c478bd9Sstevel@tonic-gate } 26237c478bd9Sstevel@tonic-gate 26247c478bd9Sstevel@tonic-gate /* 26257c478bd9Sstevel@tonic-gate * Allocated memory to store the decoded value in. 26267c478bd9Sstevel@tonic-gate */ 26277c478bd9Sstevel@tonic-gate str = ddi_prop_decode_alloc((size_t)size, ddi_prop_free_string); 26287c478bd9Sstevel@tonic-gate 26297c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 26307c478bd9Sstevel@tonic-gate 26317c478bd9Sstevel@tonic-gate /* 26327c478bd9Sstevel@tonic-gate * Decode the str and place it in the space we just allocated 26337c478bd9Sstevel@tonic-gate */ 26347c478bd9Sstevel@tonic-gate tmp = str; 26357c478bd9Sstevel@tonic-gate i = DDI_PROP_STR(ph, DDI_PROP_CMD_DECODE, tmp); 26367c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 26377c478bd9Sstevel@tonic-gate /* 26387c478bd9Sstevel@tonic-gate * Free the space we just allocated 26397c478bd9Sstevel@tonic-gate * and return an error. 26407c478bd9Sstevel@tonic-gate */ 26417c478bd9Sstevel@tonic-gate ddi_prop_free(str); 26427c478bd9Sstevel@tonic-gate switch (i) { 26437c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 26447c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 26457c478bd9Sstevel@tonic-gate 26467c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 26477c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 26487c478bd9Sstevel@tonic-gate } 26497c478bd9Sstevel@tonic-gate } 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate *(char **)data = str; 26527c478bd9Sstevel@tonic-gate *nelements = 1; 26537c478bd9Sstevel@tonic-gate 26547c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 26557c478bd9Sstevel@tonic-gate } 26567c478bd9Sstevel@tonic-gate 26577c478bd9Sstevel@tonic-gate /* 26587c478bd9Sstevel@tonic-gate * Decode an array of strings. 26597c478bd9Sstevel@tonic-gate */ 26607c478bd9Sstevel@tonic-gate int 26617c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_strings(prop_handle_t *ph, void *data, uint_t *nelements) 26627c478bd9Sstevel@tonic-gate { 26637c478bd9Sstevel@tonic-gate int cnt = 0; 26647c478bd9Sstevel@tonic-gate char **strs; 26657c478bd9Sstevel@tonic-gate char **tmp; 26667c478bd9Sstevel@tonic-gate char *ptr; 26677c478bd9Sstevel@tonic-gate int i; 26687c478bd9Sstevel@tonic-gate int n; 26697c478bd9Sstevel@tonic-gate int size; 26707c478bd9Sstevel@tonic-gate size_t nbytes; 26717c478bd9Sstevel@tonic-gate 26727c478bd9Sstevel@tonic-gate /* 26737c478bd9Sstevel@tonic-gate * Figure out how many array elements there are by going through the 26747c478bd9Sstevel@tonic-gate * data without decoding it first and counting. 26757c478bd9Sstevel@tonic-gate */ 26767c478bd9Sstevel@tonic-gate for (;;) { 26777c478bd9Sstevel@tonic-gate i = DDI_PROP_STR(ph, DDI_PROP_CMD_SKIP, NULL); 26787c478bd9Sstevel@tonic-gate if (i < 0) 26797c478bd9Sstevel@tonic-gate break; 26807c478bd9Sstevel@tonic-gate cnt++; 26817c478bd9Sstevel@tonic-gate } 26827c478bd9Sstevel@tonic-gate 26837c478bd9Sstevel@tonic-gate /* 26847c478bd9Sstevel@tonic-gate * If there are no elements return an error 26857c478bd9Sstevel@tonic-gate */ 26867c478bd9Sstevel@tonic-gate if (cnt == 0) 26877c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 26887c478bd9Sstevel@tonic-gate 26897c478bd9Sstevel@tonic-gate /* 26907c478bd9Sstevel@tonic-gate * If we cannot skip through the data, we cannot decode it 26917c478bd9Sstevel@tonic-gate */ 26927c478bd9Sstevel@tonic-gate if (i == DDI_PROP_RESULT_ERROR) 26937c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 26947c478bd9Sstevel@tonic-gate 26957c478bd9Sstevel@tonic-gate /* 26967c478bd9Sstevel@tonic-gate * Reset the data pointer to the beginning of the encoded data 26977c478bd9Sstevel@tonic-gate */ 26987c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 26997c478bd9Sstevel@tonic-gate 27007c478bd9Sstevel@tonic-gate /* 27017c478bd9Sstevel@tonic-gate * Figure out how much memory we need for the sum total 27027c478bd9Sstevel@tonic-gate */ 27037c478bd9Sstevel@tonic-gate nbytes = (cnt + 1) * sizeof (char *); 27047c478bd9Sstevel@tonic-gate 27057c478bd9Sstevel@tonic-gate for (n = 0; n < cnt; n++) { 27067c478bd9Sstevel@tonic-gate /* 27077c478bd9Sstevel@tonic-gate * Get the decoded size of the current encoded string. 27087c478bd9Sstevel@tonic-gate */ 27097c478bd9Sstevel@tonic-gate size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_DSIZE, NULL); 27107c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 27117c478bd9Sstevel@tonic-gate switch (size) { 27127c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 27137c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 27147c478bd9Sstevel@tonic-gate 27157c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 27167c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 27177c478bd9Sstevel@tonic-gate } 27187c478bd9Sstevel@tonic-gate } 27197c478bd9Sstevel@tonic-gate 27207c478bd9Sstevel@tonic-gate nbytes += size; 27217c478bd9Sstevel@tonic-gate } 27227c478bd9Sstevel@tonic-gate 27237c478bd9Sstevel@tonic-gate /* 27247c478bd9Sstevel@tonic-gate * Allocate memory in which to store the decoded strings. 27257c478bd9Sstevel@tonic-gate */ 27267c478bd9Sstevel@tonic-gate strs = ddi_prop_decode_alloc(nbytes, ddi_prop_free_strings); 27277c478bd9Sstevel@tonic-gate 27287c478bd9Sstevel@tonic-gate /* 27297c478bd9Sstevel@tonic-gate * Set up pointers for each string by figuring out yet 27307c478bd9Sstevel@tonic-gate * again how long each string is. 27317c478bd9Sstevel@tonic-gate */ 27327c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 27337c478bd9Sstevel@tonic-gate ptr = (caddr_t)strs + ((cnt + 1) * sizeof (char *)); 27347c478bd9Sstevel@tonic-gate for (tmp = strs, n = 0; n < cnt; n++, tmp++) { 27357c478bd9Sstevel@tonic-gate /* 27367c478bd9Sstevel@tonic-gate * Get the decoded size of the current encoded string. 27377c478bd9Sstevel@tonic-gate */ 27387c478bd9Sstevel@tonic-gate size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_DSIZE, NULL); 27397c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 27407c478bd9Sstevel@tonic-gate ddi_prop_free(strs); 27417c478bd9Sstevel@tonic-gate switch (size) { 27427c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 27437c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 27447c478bd9Sstevel@tonic-gate 27457c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 27467c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 27477c478bd9Sstevel@tonic-gate } 27487c478bd9Sstevel@tonic-gate } 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate *tmp = ptr; 27517c478bd9Sstevel@tonic-gate ptr += size; 27527c478bd9Sstevel@tonic-gate } 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate /* 27557c478bd9Sstevel@tonic-gate * String array is terminated by a NULL 27567c478bd9Sstevel@tonic-gate */ 27577c478bd9Sstevel@tonic-gate *tmp = NULL; 27587c478bd9Sstevel@tonic-gate 27597c478bd9Sstevel@tonic-gate /* 27607c478bd9Sstevel@tonic-gate * Finally, we can decode each string 27617c478bd9Sstevel@tonic-gate */ 27627c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 27637c478bd9Sstevel@tonic-gate for (tmp = strs, n = 0; n < cnt; n++, tmp++) { 27647c478bd9Sstevel@tonic-gate i = DDI_PROP_STR(ph, DDI_PROP_CMD_DECODE, *tmp); 27657c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 27667c478bd9Sstevel@tonic-gate /* 27677c478bd9Sstevel@tonic-gate * Free the space we just allocated 27687c478bd9Sstevel@tonic-gate * and return an error 27697c478bd9Sstevel@tonic-gate */ 27707c478bd9Sstevel@tonic-gate ddi_prop_free(strs); 27717c478bd9Sstevel@tonic-gate switch (i) { 27727c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 27737c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 27747c478bd9Sstevel@tonic-gate 27757c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 27767c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 27777c478bd9Sstevel@tonic-gate } 27787c478bd9Sstevel@tonic-gate } 27797c478bd9Sstevel@tonic-gate } 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate *(char ***)data = strs; 27827c478bd9Sstevel@tonic-gate *nelements = cnt; 27837c478bd9Sstevel@tonic-gate 27847c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 27857c478bd9Sstevel@tonic-gate } 27867c478bd9Sstevel@tonic-gate 27877c478bd9Sstevel@tonic-gate /* 27887c478bd9Sstevel@tonic-gate * Encode a string. 27897c478bd9Sstevel@tonic-gate */ 27907c478bd9Sstevel@tonic-gate int 27917c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_string(prop_handle_t *ph, void *data, uint_t nelements) 27927c478bd9Sstevel@tonic-gate { 27937c478bd9Sstevel@tonic-gate char **tmp; 27947c478bd9Sstevel@tonic-gate int size; 27957c478bd9Sstevel@tonic-gate int i; 27967c478bd9Sstevel@tonic-gate 27977c478bd9Sstevel@tonic-gate /* 27987c478bd9Sstevel@tonic-gate * If there is no data, we cannot do anything 27997c478bd9Sstevel@tonic-gate */ 28007c478bd9Sstevel@tonic-gate if (nelements == 0) 28017c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 28027c478bd9Sstevel@tonic-gate 28037c478bd9Sstevel@tonic-gate /* 28047c478bd9Sstevel@tonic-gate * Get the size of the encoded string. 28057c478bd9Sstevel@tonic-gate */ 28067c478bd9Sstevel@tonic-gate tmp = (char **)data; 28077c478bd9Sstevel@tonic-gate size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_ESIZE, *tmp); 28087c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 28097c478bd9Sstevel@tonic-gate switch (size) { 28107c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 28117c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 28127c478bd9Sstevel@tonic-gate 28137c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 28147c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 28157c478bd9Sstevel@tonic-gate } 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate /* 28197c478bd9Sstevel@tonic-gate * Allocate space in the handle to store the encoded string. 28207c478bd9Sstevel@tonic-gate */ 28217c478bd9Sstevel@tonic-gate if (ddi_prop_encode_alloc(ph, size) != DDI_PROP_SUCCESS) 28227c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 28237c478bd9Sstevel@tonic-gate 28247c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 28257c478bd9Sstevel@tonic-gate 28267c478bd9Sstevel@tonic-gate /* 28277c478bd9Sstevel@tonic-gate * Encode the string. 28287c478bd9Sstevel@tonic-gate */ 28297c478bd9Sstevel@tonic-gate tmp = (char **)data; 28307c478bd9Sstevel@tonic-gate i = DDI_PROP_STR(ph, DDI_PROP_CMD_ENCODE, *tmp); 28317c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 28327c478bd9Sstevel@tonic-gate switch (i) { 28337c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 28347c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 28377c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 28387c478bd9Sstevel@tonic-gate } 28397c478bd9Sstevel@tonic-gate } 28407c478bd9Sstevel@tonic-gate 28417c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 28427c478bd9Sstevel@tonic-gate } 28437c478bd9Sstevel@tonic-gate 28447c478bd9Sstevel@tonic-gate 28457c478bd9Sstevel@tonic-gate /* 28467c478bd9Sstevel@tonic-gate * Encode an array of strings. 28477c478bd9Sstevel@tonic-gate */ 28487c478bd9Sstevel@tonic-gate int 28497c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_strings(prop_handle_t *ph, void *data, uint_t nelements) 28507c478bd9Sstevel@tonic-gate { 28517c478bd9Sstevel@tonic-gate int cnt = 0; 28527c478bd9Sstevel@tonic-gate char **tmp; 28537c478bd9Sstevel@tonic-gate int size; 28547c478bd9Sstevel@tonic-gate uint_t total_size; 28557c478bd9Sstevel@tonic-gate int i; 28567c478bd9Sstevel@tonic-gate 28577c478bd9Sstevel@tonic-gate /* 28587c478bd9Sstevel@tonic-gate * If there is no data, we cannot do anything 28597c478bd9Sstevel@tonic-gate */ 28607c478bd9Sstevel@tonic-gate if (nelements == 0) 28617c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 28627c478bd9Sstevel@tonic-gate 28637c478bd9Sstevel@tonic-gate /* 28647c478bd9Sstevel@tonic-gate * Get the total size required to encode all the strings. 28657c478bd9Sstevel@tonic-gate */ 28667c478bd9Sstevel@tonic-gate total_size = 0; 28677c478bd9Sstevel@tonic-gate tmp = (char **)data; 28687c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < nelements; cnt++, tmp++) { 28697c478bd9Sstevel@tonic-gate size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_ESIZE, *tmp); 28707c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 28717c478bd9Sstevel@tonic-gate switch (size) { 28727c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 28737c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 28767c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 28777c478bd9Sstevel@tonic-gate } 28787c478bd9Sstevel@tonic-gate } 28797c478bd9Sstevel@tonic-gate total_size += (uint_t)size; 28807c478bd9Sstevel@tonic-gate } 28817c478bd9Sstevel@tonic-gate 28827c478bd9Sstevel@tonic-gate /* 28837c478bd9Sstevel@tonic-gate * Allocate space in the handle to store the encoded strings. 28847c478bd9Sstevel@tonic-gate */ 28857c478bd9Sstevel@tonic-gate if (ddi_prop_encode_alloc(ph, total_size) != DDI_PROP_SUCCESS) 28867c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 28877c478bd9Sstevel@tonic-gate 28887c478bd9Sstevel@tonic-gate ddi_prop_reset_pos(ph); 28897c478bd9Sstevel@tonic-gate 28907c478bd9Sstevel@tonic-gate /* 28917c478bd9Sstevel@tonic-gate * Encode the array of strings. 28927c478bd9Sstevel@tonic-gate */ 28937c478bd9Sstevel@tonic-gate tmp = (char **)data; 28947c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < nelements; cnt++, tmp++) { 28957c478bd9Sstevel@tonic-gate i = DDI_PROP_STR(ph, DDI_PROP_CMD_ENCODE, *tmp); 28967c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 28977c478bd9Sstevel@tonic-gate switch (i) { 28987c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 28997c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 29007c478bd9Sstevel@tonic-gate 29017c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 29027c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 29037c478bd9Sstevel@tonic-gate } 29047c478bd9Sstevel@tonic-gate } 29057c478bd9Sstevel@tonic-gate } 29067c478bd9Sstevel@tonic-gate 29077c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 29087c478bd9Sstevel@tonic-gate } 29097c478bd9Sstevel@tonic-gate 29107c478bd9Sstevel@tonic-gate 29117c478bd9Sstevel@tonic-gate /* 29127c478bd9Sstevel@tonic-gate * Decode an array of bytes. 29137c478bd9Sstevel@tonic-gate */ 29147c478bd9Sstevel@tonic-gate static int 29157c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_bytes(prop_handle_t *ph, void *data, uint_t *nelements) 29167c478bd9Sstevel@tonic-gate { 29177c478bd9Sstevel@tonic-gate uchar_t *tmp; 29187c478bd9Sstevel@tonic-gate int nbytes; 29197c478bd9Sstevel@tonic-gate int i; 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate /* 29227c478bd9Sstevel@tonic-gate * If there are no elements return an error 29237c478bd9Sstevel@tonic-gate */ 29247c478bd9Sstevel@tonic-gate if (ph->ph_size == 0) 29257c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 29267c478bd9Sstevel@tonic-gate 29277c478bd9Sstevel@tonic-gate /* 29287c478bd9Sstevel@tonic-gate * Get the size of the encoded array of bytes. 29297c478bd9Sstevel@tonic-gate */ 29307c478bd9Sstevel@tonic-gate nbytes = DDI_PROP_BYTES(ph, DDI_PROP_CMD_GET_DSIZE, 2931184cd04cScth data, ph->ph_size); 29327c478bd9Sstevel@tonic-gate if (nbytes < DDI_PROP_RESULT_OK) { 29337c478bd9Sstevel@tonic-gate switch (nbytes) { 29347c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 29357c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 29367c478bd9Sstevel@tonic-gate 29377c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 29387c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 29397c478bd9Sstevel@tonic-gate } 29407c478bd9Sstevel@tonic-gate } 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate /* 29437c478bd9Sstevel@tonic-gate * Allocated memory to store the decoded value in. 29447c478bd9Sstevel@tonic-gate */ 29457c478bd9Sstevel@tonic-gate tmp = ddi_prop_decode_alloc(nbytes, ddi_prop_free_bytes); 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate /* 29487c478bd9Sstevel@tonic-gate * Decode each element and place it in the space we just allocated 29497c478bd9Sstevel@tonic-gate */ 29507c478bd9Sstevel@tonic-gate i = DDI_PROP_BYTES(ph, DDI_PROP_CMD_DECODE, tmp, nbytes); 29517c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 29527c478bd9Sstevel@tonic-gate /* 29537c478bd9Sstevel@tonic-gate * Free the space we just allocated 29547c478bd9Sstevel@tonic-gate * and return an error 29557c478bd9Sstevel@tonic-gate */ 29567c478bd9Sstevel@tonic-gate ddi_prop_free(tmp); 29577c478bd9Sstevel@tonic-gate switch (i) { 29587c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 29597c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 29607c478bd9Sstevel@tonic-gate 29617c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 29627c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 29637c478bd9Sstevel@tonic-gate } 29647c478bd9Sstevel@tonic-gate } 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate *(uchar_t **)data = tmp; 29677c478bd9Sstevel@tonic-gate *nelements = nbytes; 29687c478bd9Sstevel@tonic-gate 29697c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate 29727c478bd9Sstevel@tonic-gate /* 29737c478bd9Sstevel@tonic-gate * Encode an array of bytes. 29747c478bd9Sstevel@tonic-gate */ 29757c478bd9Sstevel@tonic-gate int 29767c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_bytes(prop_handle_t *ph, void *data, uint_t nelements) 29777c478bd9Sstevel@tonic-gate { 29787c478bd9Sstevel@tonic-gate int size; 29797c478bd9Sstevel@tonic-gate int i; 29807c478bd9Sstevel@tonic-gate 29817c478bd9Sstevel@tonic-gate /* 29827c478bd9Sstevel@tonic-gate * If there are no elements, then this is a boolean property, 29837c478bd9Sstevel@tonic-gate * so just create a property handle with no data and return. 29847c478bd9Sstevel@tonic-gate */ 29857c478bd9Sstevel@tonic-gate if (nelements == 0) { 29867c478bd9Sstevel@tonic-gate (void) ddi_prop_encode_alloc(ph, 0); 29877c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 29887c478bd9Sstevel@tonic-gate } 29897c478bd9Sstevel@tonic-gate 29907c478bd9Sstevel@tonic-gate /* 29917c478bd9Sstevel@tonic-gate * Get the size of the encoded array of bytes. 29927c478bd9Sstevel@tonic-gate */ 29937c478bd9Sstevel@tonic-gate size = DDI_PROP_BYTES(ph, DDI_PROP_CMD_GET_ESIZE, (uchar_t *)data, 2994184cd04cScth nelements); 29957c478bd9Sstevel@tonic-gate if (size < DDI_PROP_RESULT_OK) { 29967c478bd9Sstevel@tonic-gate switch (size) { 29977c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 29987c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 29997c478bd9Sstevel@tonic-gate 30007c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 30017c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_DECODE); 30027c478bd9Sstevel@tonic-gate } 30037c478bd9Sstevel@tonic-gate } 30047c478bd9Sstevel@tonic-gate 30057c478bd9Sstevel@tonic-gate /* 30067c478bd9Sstevel@tonic-gate * Allocate space in the handle to store the encoded bytes. 30077c478bd9Sstevel@tonic-gate */ 30087c478bd9Sstevel@tonic-gate if (ddi_prop_encode_alloc(ph, (uint_t)size) != DDI_PROP_SUCCESS) 30097c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate /* 30127c478bd9Sstevel@tonic-gate * Encode the array of bytes. 30137c478bd9Sstevel@tonic-gate */ 30147c478bd9Sstevel@tonic-gate i = DDI_PROP_BYTES(ph, DDI_PROP_CMD_ENCODE, (uchar_t *)data, 3015184cd04cScth nelements); 30167c478bd9Sstevel@tonic-gate if (i < DDI_PROP_RESULT_OK) { 30177c478bd9Sstevel@tonic-gate switch (i) { 30187c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_EOF: 30197c478bd9Sstevel@tonic-gate return (DDI_PROP_END_OF_DATA); 30207c478bd9Sstevel@tonic-gate 30217c478bd9Sstevel@tonic-gate case DDI_PROP_RESULT_ERROR: 30227c478bd9Sstevel@tonic-gate return (DDI_PROP_CANNOT_ENCODE); 30237c478bd9Sstevel@tonic-gate } 30247c478bd9Sstevel@tonic-gate } 30257c478bd9Sstevel@tonic-gate 30267c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 30277c478bd9Sstevel@tonic-gate } 30287c478bd9Sstevel@tonic-gate 30297c478bd9Sstevel@tonic-gate /* 30307c478bd9Sstevel@tonic-gate * OBP 1275 integer, string and byte operators. 30317c478bd9Sstevel@tonic-gate * 30327c478bd9Sstevel@tonic-gate * DDI_PROP_CMD_DECODE: 30337c478bd9Sstevel@tonic-gate * 30347c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_ERROR: cannot decode the data 30357c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_EOF: end of data 30367c478bd9Sstevel@tonic-gate * DDI_PROP_OK: data was decoded 30377c478bd9Sstevel@tonic-gate * 30387c478bd9Sstevel@tonic-gate * DDI_PROP_CMD_ENCODE: 30397c478bd9Sstevel@tonic-gate * 30407c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_ERROR: cannot encode the data 30417c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_EOF: end of data 30427c478bd9Sstevel@tonic-gate * DDI_PROP_OK: data was encoded 30437c478bd9Sstevel@tonic-gate * 30447c478bd9Sstevel@tonic-gate * DDI_PROP_CMD_SKIP: 30457c478bd9Sstevel@tonic-gate * 30467c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_ERROR: cannot skip the data 30477c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_EOF: end of data 30487c478bd9Sstevel@tonic-gate * DDI_PROP_OK: data was skipped 30497c478bd9Sstevel@tonic-gate * 30507c478bd9Sstevel@tonic-gate * DDI_PROP_CMD_GET_ESIZE: 30517c478bd9Sstevel@tonic-gate * 30527c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_ERROR: cannot get encoded size 30537c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_EOF: end of data 30547c478bd9Sstevel@tonic-gate * > 0: the encoded size 30557c478bd9Sstevel@tonic-gate * 30567c478bd9Sstevel@tonic-gate * DDI_PROP_CMD_GET_DSIZE: 30577c478bd9Sstevel@tonic-gate * 30587c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_ERROR: cannot get decoded size 30597c478bd9Sstevel@tonic-gate * DDI_PROP_RESULT_EOF: end of data 30607c478bd9Sstevel@tonic-gate * > 0: the decoded size 30617c478bd9Sstevel@tonic-gate */ 30627c478bd9Sstevel@tonic-gate 30637c478bd9Sstevel@tonic-gate /* 30647c478bd9Sstevel@tonic-gate * OBP 1275 integer operator 30657c478bd9Sstevel@tonic-gate * 30667c478bd9Sstevel@tonic-gate * OBP properties are a byte stream of data, so integers may not be 30677c478bd9Sstevel@tonic-gate * properly aligned. Therefore we need to copy them one byte at a time. 30687c478bd9Sstevel@tonic-gate */ 30697c478bd9Sstevel@tonic-gate int 30707c478bd9Sstevel@tonic-gate ddi_prop_1275_int(prop_handle_t *ph, uint_t cmd, int *data) 30717c478bd9Sstevel@tonic-gate { 30727c478bd9Sstevel@tonic-gate int i; 30737c478bd9Sstevel@tonic-gate 30747c478bd9Sstevel@tonic-gate switch (cmd) { 30757c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_DECODE: 30767c478bd9Sstevel@tonic-gate /* 30777c478bd9Sstevel@tonic-gate * Check that there is encoded data 30787c478bd9Sstevel@tonic-gate */ 30797c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0) 30807c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 30817c478bd9Sstevel@tonic-gate if (ph->ph_flags & PH_FROM_PROM) { 30827c478bd9Sstevel@tonic-gate i = MIN(ph->ph_size, PROP_1275_INT_SIZE); 30837c478bd9Sstevel@tonic-gate if ((int *)ph->ph_cur_pos > ((int *)ph->ph_data + 3084184cd04cScth ph->ph_size - i)) 30857c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 30867c478bd9Sstevel@tonic-gate } else { 30877c478bd9Sstevel@tonic-gate if (ph->ph_size < sizeof (int) || 3088184cd04cScth ((int *)ph->ph_cur_pos > ((int *)ph->ph_data + 3089184cd04cScth ph->ph_size - sizeof (int)))) 3090184cd04cScth return (DDI_PROP_RESULT_ERROR); 30917c478bd9Sstevel@tonic-gate } 30927c478bd9Sstevel@tonic-gate 30937c478bd9Sstevel@tonic-gate /* 30947c478bd9Sstevel@tonic-gate * Copy the integer, using the implementation-specific 30957c478bd9Sstevel@tonic-gate * copy function if the property is coming from the PROM. 30967c478bd9Sstevel@tonic-gate */ 30977c478bd9Sstevel@tonic-gate if (ph->ph_flags & PH_FROM_PROM) { 30987c478bd9Sstevel@tonic-gate *data = impl_ddi_prop_int_from_prom( 3099184cd04cScth (uchar_t *)ph->ph_cur_pos, 3100184cd04cScth (ph->ph_size < PROP_1275_INT_SIZE) ? 3101184cd04cScth ph->ph_size : PROP_1275_INT_SIZE); 31027c478bd9Sstevel@tonic-gate } else { 31037c478bd9Sstevel@tonic-gate bcopy(ph->ph_cur_pos, data, sizeof (int)); 31047c478bd9Sstevel@tonic-gate } 31057c478bd9Sstevel@tonic-gate 31067c478bd9Sstevel@tonic-gate /* 31077c478bd9Sstevel@tonic-gate * Move the current location to the start of the next 31087c478bd9Sstevel@tonic-gate * bit of undecoded data. 31097c478bd9Sstevel@tonic-gate */ 31107c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + 3111184cd04cScth PROP_1275_INT_SIZE; 31127c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 31137c478bd9Sstevel@tonic-gate 31147c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_ENCODE: 31157c478bd9Sstevel@tonic-gate /* 31167c478bd9Sstevel@tonic-gate * Check that there is room to encoded the data 31177c478bd9Sstevel@tonic-gate */ 31187c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 3119184cd04cScth ph->ph_size < PROP_1275_INT_SIZE || 3120184cd04cScth ((int *)ph->ph_cur_pos > ((int *)ph->ph_data + 3121184cd04cScth ph->ph_size - sizeof (int)))) 31227c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 31237c478bd9Sstevel@tonic-gate 31247c478bd9Sstevel@tonic-gate /* 31257c478bd9Sstevel@tonic-gate * Encode the integer into the byte stream one byte at a 31267c478bd9Sstevel@tonic-gate * time. 31277c478bd9Sstevel@tonic-gate */ 31287c478bd9Sstevel@tonic-gate bcopy(data, ph->ph_cur_pos, sizeof (int)); 31297c478bd9Sstevel@tonic-gate 31307c478bd9Sstevel@tonic-gate /* 31317c478bd9Sstevel@tonic-gate * Move the current location to the start of the next bit of 31327c478bd9Sstevel@tonic-gate * space where we can store encoded data. 31337c478bd9Sstevel@tonic-gate */ 31347c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + PROP_1275_INT_SIZE; 31357c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 31367c478bd9Sstevel@tonic-gate 31377c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_SKIP: 31387c478bd9Sstevel@tonic-gate /* 31397c478bd9Sstevel@tonic-gate * Check that there is encoded data 31407c478bd9Sstevel@tonic-gate */ 31417c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 3142184cd04cScth ph->ph_size < PROP_1275_INT_SIZE) 31437c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 31447c478bd9Sstevel@tonic-gate 31457c478bd9Sstevel@tonic-gate 31467c478bd9Sstevel@tonic-gate if ((caddr_t)ph->ph_cur_pos == 3147184cd04cScth (caddr_t)ph->ph_data + ph->ph_size) { 31487c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_EOF); 31497c478bd9Sstevel@tonic-gate } else if ((caddr_t)ph->ph_cur_pos > 3150184cd04cScth (caddr_t)ph->ph_data + ph->ph_size) { 31517c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_EOF); 31527c478bd9Sstevel@tonic-gate } 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate /* 31557c478bd9Sstevel@tonic-gate * Move the current location to the start of the next bit of 31567c478bd9Sstevel@tonic-gate * undecoded data. 31577c478bd9Sstevel@tonic-gate */ 31587c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + PROP_1275_INT_SIZE; 31597c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 31607c478bd9Sstevel@tonic-gate 31617c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_ESIZE: 31627c478bd9Sstevel@tonic-gate /* 31637c478bd9Sstevel@tonic-gate * Return the size of an encoded integer on OBP 31647c478bd9Sstevel@tonic-gate */ 31657c478bd9Sstevel@tonic-gate return (PROP_1275_INT_SIZE); 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_DSIZE: 31687c478bd9Sstevel@tonic-gate /* 31697c478bd9Sstevel@tonic-gate * Return the size of a decoded integer on the system. 31707c478bd9Sstevel@tonic-gate */ 31717c478bd9Sstevel@tonic-gate return (sizeof (int)); 31727c478bd9Sstevel@tonic-gate 31737c478bd9Sstevel@tonic-gate default: 31747c478bd9Sstevel@tonic-gate #ifdef DEBUG 31757c478bd9Sstevel@tonic-gate panic("ddi_prop_1275_int: %x impossible", cmd); 31767c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 31777c478bd9Sstevel@tonic-gate #else 31787c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 31797c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 31807c478bd9Sstevel@tonic-gate } 31817c478bd9Sstevel@tonic-gate } 31827c478bd9Sstevel@tonic-gate 31837c478bd9Sstevel@tonic-gate /* 31847c478bd9Sstevel@tonic-gate * 64 bit integer operator. 31857c478bd9Sstevel@tonic-gate * 31867c478bd9Sstevel@tonic-gate * This is an extension, defined by Sun, to the 1275 integer 31877c478bd9Sstevel@tonic-gate * operator. This routine handles the encoding/decoding of 31887c478bd9Sstevel@tonic-gate * 64 bit integer properties. 31897c478bd9Sstevel@tonic-gate */ 31907c478bd9Sstevel@tonic-gate int 31917c478bd9Sstevel@tonic-gate ddi_prop_int64_op(prop_handle_t *ph, uint_t cmd, int64_t *data) 31927c478bd9Sstevel@tonic-gate { 31937c478bd9Sstevel@tonic-gate 31947c478bd9Sstevel@tonic-gate switch (cmd) { 31957c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_DECODE: 31967c478bd9Sstevel@tonic-gate /* 31977c478bd9Sstevel@tonic-gate * Check that there is encoded data 31987c478bd9Sstevel@tonic-gate */ 31997c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0) 32007c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32017c478bd9Sstevel@tonic-gate if (ph->ph_flags & PH_FROM_PROM) { 32027c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32037c478bd9Sstevel@tonic-gate } else { 32047c478bd9Sstevel@tonic-gate if (ph->ph_size < sizeof (int64_t) || 32057c478bd9Sstevel@tonic-gate ((int64_t *)ph->ph_cur_pos > 32067c478bd9Sstevel@tonic-gate ((int64_t *)ph->ph_data + 32077c478bd9Sstevel@tonic-gate ph->ph_size - sizeof (int64_t)))) 32087c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32097c478bd9Sstevel@tonic-gate } 32107c478bd9Sstevel@tonic-gate /* 32117c478bd9Sstevel@tonic-gate * Copy the integer, using the implementation-specific 32127c478bd9Sstevel@tonic-gate * copy function if the property is coming from the PROM. 32137c478bd9Sstevel@tonic-gate */ 32147c478bd9Sstevel@tonic-gate if (ph->ph_flags & PH_FROM_PROM) { 32157c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32167c478bd9Sstevel@tonic-gate } else { 32177c478bd9Sstevel@tonic-gate bcopy(ph->ph_cur_pos, data, sizeof (int64_t)); 32187c478bd9Sstevel@tonic-gate } 32197c478bd9Sstevel@tonic-gate 32207c478bd9Sstevel@tonic-gate /* 32217c478bd9Sstevel@tonic-gate * Move the current location to the start of the next 32227c478bd9Sstevel@tonic-gate * bit of undecoded data. 32237c478bd9Sstevel@tonic-gate */ 32247c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + 32257c478bd9Sstevel@tonic-gate sizeof (int64_t); 32267c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 32277c478bd9Sstevel@tonic-gate 32287c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_ENCODE: 32297c478bd9Sstevel@tonic-gate /* 32307c478bd9Sstevel@tonic-gate * Check that there is room to encoded the data 32317c478bd9Sstevel@tonic-gate */ 32327c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 32337c478bd9Sstevel@tonic-gate ph->ph_size < sizeof (int64_t) || 32347c478bd9Sstevel@tonic-gate ((int64_t *)ph->ph_cur_pos > ((int64_t *)ph->ph_data + 32357c478bd9Sstevel@tonic-gate ph->ph_size - sizeof (int64_t)))) 32367c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32377c478bd9Sstevel@tonic-gate 32387c478bd9Sstevel@tonic-gate /* 32397c478bd9Sstevel@tonic-gate * Encode the integer into the byte stream one byte at a 32407c478bd9Sstevel@tonic-gate * time. 32417c478bd9Sstevel@tonic-gate */ 32427c478bd9Sstevel@tonic-gate bcopy(data, ph->ph_cur_pos, sizeof (int64_t)); 32437c478bd9Sstevel@tonic-gate 32447c478bd9Sstevel@tonic-gate /* 32457c478bd9Sstevel@tonic-gate * Move the current location to the start of the next bit of 32467c478bd9Sstevel@tonic-gate * space where we can store encoded data. 32477c478bd9Sstevel@tonic-gate */ 32487c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + 32497c478bd9Sstevel@tonic-gate sizeof (int64_t); 32507c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 32517c478bd9Sstevel@tonic-gate 32527c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_SKIP: 32537c478bd9Sstevel@tonic-gate /* 32547c478bd9Sstevel@tonic-gate * Check that there is encoded data 32557c478bd9Sstevel@tonic-gate */ 32567c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 32577c478bd9Sstevel@tonic-gate ph->ph_size < sizeof (int64_t)) 32587c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32597c478bd9Sstevel@tonic-gate 32607c478bd9Sstevel@tonic-gate if ((caddr_t)ph->ph_cur_pos == 32617c478bd9Sstevel@tonic-gate (caddr_t)ph->ph_data + ph->ph_size) { 32627c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_EOF); 32637c478bd9Sstevel@tonic-gate } else if ((caddr_t)ph->ph_cur_pos > 32647c478bd9Sstevel@tonic-gate (caddr_t)ph->ph_data + ph->ph_size) { 32657c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_EOF); 32667c478bd9Sstevel@tonic-gate } 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate /* 32697c478bd9Sstevel@tonic-gate * Move the current location to the start of 32707c478bd9Sstevel@tonic-gate * the next bit of undecoded data. 32717c478bd9Sstevel@tonic-gate */ 32727c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + 32737c478bd9Sstevel@tonic-gate sizeof (int64_t); 32747c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 32757c478bd9Sstevel@tonic-gate 32767c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_ESIZE: 32777c478bd9Sstevel@tonic-gate /* 32787c478bd9Sstevel@tonic-gate * Return the size of an encoded integer on OBP 32797c478bd9Sstevel@tonic-gate */ 32807c478bd9Sstevel@tonic-gate return (sizeof (int64_t)); 32817c478bd9Sstevel@tonic-gate 32827c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_DSIZE: 32837c478bd9Sstevel@tonic-gate /* 32847c478bd9Sstevel@tonic-gate * Return the size of a decoded integer on the system. 32857c478bd9Sstevel@tonic-gate */ 32867c478bd9Sstevel@tonic-gate return (sizeof (int64_t)); 32877c478bd9Sstevel@tonic-gate 32887c478bd9Sstevel@tonic-gate default: 32897c478bd9Sstevel@tonic-gate #ifdef DEBUG 32907c478bd9Sstevel@tonic-gate panic("ddi_prop_int64_op: %x impossible", cmd); 32917c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 32927c478bd9Sstevel@tonic-gate #else 32937c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 32947c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 32957c478bd9Sstevel@tonic-gate } 32967c478bd9Sstevel@tonic-gate } 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate /* 32997c478bd9Sstevel@tonic-gate * OBP 1275 string operator. 33007c478bd9Sstevel@tonic-gate * 33017c478bd9Sstevel@tonic-gate * OBP strings are NULL terminated. 33027c478bd9Sstevel@tonic-gate */ 33037c478bd9Sstevel@tonic-gate int 33047c478bd9Sstevel@tonic-gate ddi_prop_1275_string(prop_handle_t *ph, uint_t cmd, char *data) 33057c478bd9Sstevel@tonic-gate { 33067c478bd9Sstevel@tonic-gate int n; 33077c478bd9Sstevel@tonic-gate char *p; 33087c478bd9Sstevel@tonic-gate char *end; 33097c478bd9Sstevel@tonic-gate 33107c478bd9Sstevel@tonic-gate switch (cmd) { 33117c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_DECODE: 33127c478bd9Sstevel@tonic-gate /* 33137c478bd9Sstevel@tonic-gate * Check that there is encoded data 33147c478bd9Sstevel@tonic-gate */ 33157c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0) { 33167c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 33177c478bd9Sstevel@tonic-gate } 33187c478bd9Sstevel@tonic-gate 33197c478bd9Sstevel@tonic-gate /* 33209e1bcca2Scth * Match DDI_PROP_CMD_GET_DSIZE logic for when to stop and 33219e1bcca2Scth * how to NULL terminate result. 33227c478bd9Sstevel@tonic-gate */ 33239e1bcca2Scth p = (char *)ph->ph_cur_pos; 33249e1bcca2Scth end = (char *)ph->ph_data + ph->ph_size; 33259e1bcca2Scth if (p >= end) 33269e1bcca2Scth return (DDI_PROP_RESULT_EOF); 33279e1bcca2Scth 33289e1bcca2Scth while (p < end) { 33299e1bcca2Scth *data++ = *p; 33309e1bcca2Scth if (*p++ == 0) { /* NULL from OBP */ 33319e1bcca2Scth ph->ph_cur_pos = p; 33329e1bcca2Scth return (DDI_PROP_RESULT_OK); 33339e1bcca2Scth } 33349e1bcca2Scth } 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate /* 33379e1bcca2Scth * If OBP did not NULL terminate string, which happens 33389e1bcca2Scth * (at least) for 'true'/'false' boolean values, account for 33399e1bcca2Scth * the space and store null termination on decode. 33407c478bd9Sstevel@tonic-gate */ 33419e1bcca2Scth ph->ph_cur_pos = p; 33429e1bcca2Scth *data = 0; 33437c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 33447c478bd9Sstevel@tonic-gate 33457c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_ENCODE: 33467c478bd9Sstevel@tonic-gate /* 33477c478bd9Sstevel@tonic-gate * Check that there is room to encoded the data 33487c478bd9Sstevel@tonic-gate */ 33497c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0) { 33507c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 33517c478bd9Sstevel@tonic-gate } 33527c478bd9Sstevel@tonic-gate 33537c478bd9Sstevel@tonic-gate n = strlen(data) + 1; 33547c478bd9Sstevel@tonic-gate if ((char *)ph->ph_cur_pos > ((char *)ph->ph_data + 3355184cd04cScth ph->ph_size - n)) { 33567c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 33577c478bd9Sstevel@tonic-gate } 33587c478bd9Sstevel@tonic-gate 33597c478bd9Sstevel@tonic-gate /* 33607c478bd9Sstevel@tonic-gate * Copy the NULL terminated string 33617c478bd9Sstevel@tonic-gate */ 33627c478bd9Sstevel@tonic-gate bcopy(data, ph->ph_cur_pos, n); 33637c478bd9Sstevel@tonic-gate 33647c478bd9Sstevel@tonic-gate /* 33657c478bd9Sstevel@tonic-gate * Move the current location to the start of the next bit of 33667c478bd9Sstevel@tonic-gate * space where we can store encoded data. 33677c478bd9Sstevel@tonic-gate */ 33687c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (char *)ph->ph_cur_pos + n; 33697c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 33707c478bd9Sstevel@tonic-gate 33717c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_SKIP: 33727c478bd9Sstevel@tonic-gate /* 33737c478bd9Sstevel@tonic-gate * Check that there is encoded data 33747c478bd9Sstevel@tonic-gate */ 33757c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0) { 33767c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 33777c478bd9Sstevel@tonic-gate } 33787c478bd9Sstevel@tonic-gate 33797c478bd9Sstevel@tonic-gate /* 33807c478bd9Sstevel@tonic-gate * Return the string length plus one for the NULL 33817c478bd9Sstevel@tonic-gate * We know the size of the property, we need to 33827c478bd9Sstevel@tonic-gate * ensure that the string is properly formatted, 33837c478bd9Sstevel@tonic-gate * since we may be looking up random OBP data. 33847c478bd9Sstevel@tonic-gate */ 33857c478bd9Sstevel@tonic-gate p = (char *)ph->ph_cur_pos; 33867c478bd9Sstevel@tonic-gate end = (char *)ph->ph_data + ph->ph_size; 33879e1bcca2Scth if (p >= end) 33887c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_EOF); 33897c478bd9Sstevel@tonic-gate 33909e1bcca2Scth while (p < end) { 33919e1bcca2Scth if (*p++ == 0) { /* NULL from OBP */ 33927c478bd9Sstevel@tonic-gate ph->ph_cur_pos = p; 33937c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 33947c478bd9Sstevel@tonic-gate } 33957c478bd9Sstevel@tonic-gate } 33967c478bd9Sstevel@tonic-gate 33979e1bcca2Scth /* 33989e1bcca2Scth * Accommodate the fact that OBP does not always NULL 33999e1bcca2Scth * terminate strings. 34009e1bcca2Scth */ 34019e1bcca2Scth ph->ph_cur_pos = p; 34029e1bcca2Scth return (DDI_PROP_RESULT_OK); 34037c478bd9Sstevel@tonic-gate 34047c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_ESIZE: 34057c478bd9Sstevel@tonic-gate /* 34067c478bd9Sstevel@tonic-gate * Return the size of the encoded string on OBP. 34077c478bd9Sstevel@tonic-gate */ 34087c478bd9Sstevel@tonic-gate return (strlen(data) + 1); 34097c478bd9Sstevel@tonic-gate 34107c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_DSIZE: 34117c478bd9Sstevel@tonic-gate /* 34129e1bcca2Scth * Return the string length plus one for the NULL. 34137c478bd9Sstevel@tonic-gate * We know the size of the property, we need to 34147c478bd9Sstevel@tonic-gate * ensure that the string is properly formatted, 34157c478bd9Sstevel@tonic-gate * since we may be looking up random OBP data. 34167c478bd9Sstevel@tonic-gate */ 34177c478bd9Sstevel@tonic-gate p = (char *)ph->ph_cur_pos; 34187c478bd9Sstevel@tonic-gate end = (char *)ph->ph_data + ph->ph_size; 34199e1bcca2Scth if (p >= end) 34209e1bcca2Scth return (DDI_PROP_RESULT_EOF); 34219e1bcca2Scth 34227c478bd9Sstevel@tonic-gate for (n = 0; p < end; n++) { 34239e1bcca2Scth if (*p++ == 0) { /* NULL from OBP */ 34247c478bd9Sstevel@tonic-gate ph->ph_cur_pos = p; 34259e1bcca2Scth return (n + 1); 34267c478bd9Sstevel@tonic-gate } 34277c478bd9Sstevel@tonic-gate } 34289e1bcca2Scth 34299e1bcca2Scth /* 34309e1bcca2Scth * If OBP did not NULL terminate string, which happens for 34319e1bcca2Scth * 'true'/'false' boolean values, account for the space 34329e1bcca2Scth * to store null termination here. 34339e1bcca2Scth */ 34349e1bcca2Scth ph->ph_cur_pos = p; 34359e1bcca2Scth return (n + 1); 34367c478bd9Sstevel@tonic-gate 34377c478bd9Sstevel@tonic-gate default: 34387c478bd9Sstevel@tonic-gate #ifdef DEBUG 34397c478bd9Sstevel@tonic-gate panic("ddi_prop_1275_string: %x impossible", cmd); 34407c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 34417c478bd9Sstevel@tonic-gate #else 34427c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 34437c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 34447c478bd9Sstevel@tonic-gate } 34457c478bd9Sstevel@tonic-gate } 34467c478bd9Sstevel@tonic-gate 34477c478bd9Sstevel@tonic-gate /* 34487c478bd9Sstevel@tonic-gate * OBP 1275 byte operator 34497c478bd9Sstevel@tonic-gate * 34507c478bd9Sstevel@tonic-gate * Caller must specify the number of bytes to get. OBP encodes bytes 34517c478bd9Sstevel@tonic-gate * as a byte so there is a 1-to-1 translation. 34527c478bd9Sstevel@tonic-gate */ 34537c478bd9Sstevel@tonic-gate int 34547c478bd9Sstevel@tonic-gate ddi_prop_1275_bytes(prop_handle_t *ph, uint_t cmd, uchar_t *data, 34557c478bd9Sstevel@tonic-gate uint_t nelements) 34567c478bd9Sstevel@tonic-gate { 34577c478bd9Sstevel@tonic-gate switch (cmd) { 34587c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_DECODE: 34597c478bd9Sstevel@tonic-gate /* 34607c478bd9Sstevel@tonic-gate * Check that there is encoded data 34617c478bd9Sstevel@tonic-gate */ 34627c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 3463184cd04cScth ph->ph_size < nelements || 3464184cd04cScth ((char *)ph->ph_cur_pos > ((char *)ph->ph_data + 3465184cd04cScth ph->ph_size - nelements))) 34667c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 34677c478bd9Sstevel@tonic-gate 34687c478bd9Sstevel@tonic-gate /* 34697c478bd9Sstevel@tonic-gate * Copy out the bytes 34707c478bd9Sstevel@tonic-gate */ 34717c478bd9Sstevel@tonic-gate bcopy(ph->ph_cur_pos, data, nelements); 34727c478bd9Sstevel@tonic-gate 34737c478bd9Sstevel@tonic-gate /* 34747c478bd9Sstevel@tonic-gate * Move the current location 34757c478bd9Sstevel@tonic-gate */ 34767c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (char *)ph->ph_cur_pos + nelements; 34777c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 34787c478bd9Sstevel@tonic-gate 34797c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_ENCODE: 34807c478bd9Sstevel@tonic-gate /* 34817c478bd9Sstevel@tonic-gate * Check that there is room to encode the data 34827c478bd9Sstevel@tonic-gate */ 34837c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 3484184cd04cScth ph->ph_size < nelements || 3485184cd04cScth ((char *)ph->ph_cur_pos > ((char *)ph->ph_data + 3486184cd04cScth ph->ph_size - nelements))) 34877c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 34887c478bd9Sstevel@tonic-gate 34897c478bd9Sstevel@tonic-gate /* 34907c478bd9Sstevel@tonic-gate * Copy in the bytes 34917c478bd9Sstevel@tonic-gate */ 34927c478bd9Sstevel@tonic-gate bcopy(data, ph->ph_cur_pos, nelements); 34937c478bd9Sstevel@tonic-gate 34947c478bd9Sstevel@tonic-gate /* 34957c478bd9Sstevel@tonic-gate * Move the current location to the start of the next bit of 34967c478bd9Sstevel@tonic-gate * space where we can store encoded data. 34977c478bd9Sstevel@tonic-gate */ 34987c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (char *)ph->ph_cur_pos + nelements; 34997c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 35007c478bd9Sstevel@tonic-gate 35017c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_SKIP: 35027c478bd9Sstevel@tonic-gate /* 35037c478bd9Sstevel@tonic-gate * Check that there is encoded data 35047c478bd9Sstevel@tonic-gate */ 35057c478bd9Sstevel@tonic-gate if (ph->ph_cur_pos == NULL || ph->ph_size == 0 || 3506184cd04cScth ph->ph_size < nelements) 35077c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate if ((char *)ph->ph_cur_pos > ((char *)ph->ph_data + 3510184cd04cScth ph->ph_size - nelements)) 35117c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_EOF); 35127c478bd9Sstevel@tonic-gate 35137c478bd9Sstevel@tonic-gate /* 35147c478bd9Sstevel@tonic-gate * Move the current location 35157c478bd9Sstevel@tonic-gate */ 35167c478bd9Sstevel@tonic-gate ph->ph_cur_pos = (char *)ph->ph_cur_pos + nelements; 35177c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_OK); 35187c478bd9Sstevel@tonic-gate 35197c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_ESIZE: 35207c478bd9Sstevel@tonic-gate /* 35217c478bd9Sstevel@tonic-gate * The size in bytes of the encoded size is the 35227c478bd9Sstevel@tonic-gate * same as the decoded size provided by the caller. 35237c478bd9Sstevel@tonic-gate */ 35247c478bd9Sstevel@tonic-gate return (nelements); 35257c478bd9Sstevel@tonic-gate 35267c478bd9Sstevel@tonic-gate case DDI_PROP_CMD_GET_DSIZE: 35277c478bd9Sstevel@tonic-gate /* 35287c478bd9Sstevel@tonic-gate * Just return the number of bytes specified by the caller. 35297c478bd9Sstevel@tonic-gate */ 35307c478bd9Sstevel@tonic-gate return (nelements); 35317c478bd9Sstevel@tonic-gate 35327c478bd9Sstevel@tonic-gate default: 35337c478bd9Sstevel@tonic-gate #ifdef DEBUG 35347c478bd9Sstevel@tonic-gate panic("ddi_prop_1275_bytes: %x impossible", cmd); 35357c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 35367c478bd9Sstevel@tonic-gate #else 35377c478bd9Sstevel@tonic-gate return (DDI_PROP_RESULT_ERROR); 35387c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 35397c478bd9Sstevel@tonic-gate } 35407c478bd9Sstevel@tonic-gate } 35417c478bd9Sstevel@tonic-gate 35427c478bd9Sstevel@tonic-gate /* 35437c478bd9Sstevel@tonic-gate * Used for properties that come from the OBP, hardware configuration files, 35447c478bd9Sstevel@tonic-gate * or that are created by calls to ddi_prop_update(9F). 35457c478bd9Sstevel@tonic-gate */ 35467c478bd9Sstevel@tonic-gate static struct prop_handle_ops prop_1275_ops = { 35477c478bd9Sstevel@tonic-gate ddi_prop_1275_int, 35487c478bd9Sstevel@tonic-gate ddi_prop_1275_string, 35497c478bd9Sstevel@tonic-gate ddi_prop_1275_bytes, 35507c478bd9Sstevel@tonic-gate ddi_prop_int64_op 35517c478bd9Sstevel@tonic-gate }; 35527c478bd9Sstevel@tonic-gate 35537c478bd9Sstevel@tonic-gate 35547c478bd9Sstevel@tonic-gate /* 35557c478bd9Sstevel@tonic-gate * Interface to create/modify a managed property on child's behalf... 35567c478bd9Sstevel@tonic-gate * Flags interpreted are: 35577c478bd9Sstevel@tonic-gate * DDI_PROP_CANSLEEP: Allow memory allocation to sleep. 35587c478bd9Sstevel@tonic-gate * DDI_PROP_SYSTEM_DEF: Manipulate system list rather than driver list. 35597c478bd9Sstevel@tonic-gate * 35607c478bd9Sstevel@tonic-gate * Use same dev_t when modifying or undefining a property. 35617c478bd9Sstevel@tonic-gate * Search for properties with DDI_DEV_T_ANY to match first named 35627c478bd9Sstevel@tonic-gate * property on the list. 35637c478bd9Sstevel@tonic-gate * 35647c478bd9Sstevel@tonic-gate * Properties are stored LIFO and subsequently will match the first 35657c478bd9Sstevel@tonic-gate * `matching' instance. 35667c478bd9Sstevel@tonic-gate */ 35677c478bd9Sstevel@tonic-gate 35687c478bd9Sstevel@tonic-gate /* 35697c478bd9Sstevel@tonic-gate * ddi_prop_add: Add a software defined property 35707c478bd9Sstevel@tonic-gate */ 35717c478bd9Sstevel@tonic-gate 35727c478bd9Sstevel@tonic-gate /* 35737c478bd9Sstevel@tonic-gate * define to get a new ddi_prop_t. 35747c478bd9Sstevel@tonic-gate * km_flags are KM_SLEEP or KM_NOSLEEP. 35757c478bd9Sstevel@tonic-gate */ 35767c478bd9Sstevel@tonic-gate 35777c478bd9Sstevel@tonic-gate #define DDI_NEW_PROP_T(km_flags) \ 35787c478bd9Sstevel@tonic-gate (kmem_zalloc(sizeof (ddi_prop_t), km_flags)) 35797c478bd9Sstevel@tonic-gate 35807c478bd9Sstevel@tonic-gate static int 35817c478bd9Sstevel@tonic-gate ddi_prop_add(dev_t dev, dev_info_t *dip, int flags, 35827c478bd9Sstevel@tonic-gate char *name, caddr_t value, int length) 35837c478bd9Sstevel@tonic-gate { 35847c478bd9Sstevel@tonic-gate ddi_prop_t *new_propp, *propp; 35857c478bd9Sstevel@tonic-gate ddi_prop_t **list_head = &(DEVI(dip)->devi_drv_prop_ptr); 35867c478bd9Sstevel@tonic-gate int km_flags = KM_NOSLEEP; 35877c478bd9Sstevel@tonic-gate int name_buf_len; 35887c478bd9Sstevel@tonic-gate 35897c478bd9Sstevel@tonic-gate /* 35907c478bd9Sstevel@tonic-gate * If dev_t is DDI_DEV_T_ANY or name's length is zero return error. 35917c478bd9Sstevel@tonic-gate */ 35927c478bd9Sstevel@tonic-gate 35937c478bd9Sstevel@tonic-gate if (dev == DDI_DEV_T_ANY || name == (char *)0 || strlen(name) == 0) 35947c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 35957c478bd9Sstevel@tonic-gate 35967c478bd9Sstevel@tonic-gate if (flags & DDI_PROP_CANSLEEP) 35977c478bd9Sstevel@tonic-gate km_flags = KM_SLEEP; 35987c478bd9Sstevel@tonic-gate 35997c478bd9Sstevel@tonic-gate if (flags & DDI_PROP_SYSTEM_DEF) 36007c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_sys_prop_ptr); 36017c478bd9Sstevel@tonic-gate else if (flags & DDI_PROP_HW_DEF) 36027c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_hw_prop_ptr); 36037c478bd9Sstevel@tonic-gate 36047c478bd9Sstevel@tonic-gate if ((new_propp = DDI_NEW_PROP_T(km_flags)) == NULL) { 36057c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 36067c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 36077c478bd9Sstevel@tonic-gate } 36087c478bd9Sstevel@tonic-gate 36097c478bd9Sstevel@tonic-gate /* 36107c478bd9Sstevel@tonic-gate * If dev is major number 0, then we need to do a ddi_name_to_major 36117c478bd9Sstevel@tonic-gate * to get the real major number for the device. This needs to be 36127c478bd9Sstevel@tonic-gate * done because some drivers need to call ddi_prop_create in their 36137c478bd9Sstevel@tonic-gate * attach routines but they don't have a dev. By creating the dev 36147c478bd9Sstevel@tonic-gate * ourself if the major number is 0, drivers will not have to know what 36157c478bd9Sstevel@tonic-gate * their major number. They can just create a dev with major number 36167c478bd9Sstevel@tonic-gate * 0 and pass it in. For device 0, we will be doing a little extra 36177c478bd9Sstevel@tonic-gate * work by recreating the same dev that we already have, but its the 36187c478bd9Sstevel@tonic-gate * price you pay :-). 36197c478bd9Sstevel@tonic-gate * 36207c478bd9Sstevel@tonic-gate * This fixes bug #1098060. 36217c478bd9Sstevel@tonic-gate */ 36227c478bd9Sstevel@tonic-gate if (getmajor(dev) == DDI_MAJOR_T_UNKNOWN) { 36237c478bd9Sstevel@tonic-gate new_propp->prop_dev = 36247c478bd9Sstevel@tonic-gate makedevice(ddi_name_to_major(DEVI(dip)->devi_binding_name), 36257c478bd9Sstevel@tonic-gate getminor(dev)); 36267c478bd9Sstevel@tonic-gate } else 36277c478bd9Sstevel@tonic-gate new_propp->prop_dev = dev; 36287c478bd9Sstevel@tonic-gate 36297c478bd9Sstevel@tonic-gate /* 36307c478bd9Sstevel@tonic-gate * Allocate space for property name and copy it in... 36317c478bd9Sstevel@tonic-gate */ 36327c478bd9Sstevel@tonic-gate 36337c478bd9Sstevel@tonic-gate name_buf_len = strlen(name) + 1; 36347c478bd9Sstevel@tonic-gate new_propp->prop_name = kmem_alloc(name_buf_len, km_flags); 36357c478bd9Sstevel@tonic-gate if (new_propp->prop_name == 0) { 36367c478bd9Sstevel@tonic-gate kmem_free(new_propp, sizeof (ddi_prop_t)); 36377c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 36387c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 36397c478bd9Sstevel@tonic-gate } 36407c478bd9Sstevel@tonic-gate bcopy(name, new_propp->prop_name, name_buf_len); 36417c478bd9Sstevel@tonic-gate 36427c478bd9Sstevel@tonic-gate /* 36437c478bd9Sstevel@tonic-gate * Set the property type 36447c478bd9Sstevel@tonic-gate */ 36457c478bd9Sstevel@tonic-gate new_propp->prop_flags = flags & DDI_PROP_TYPE_MASK; 36467c478bd9Sstevel@tonic-gate 36477c478bd9Sstevel@tonic-gate /* 36487c478bd9Sstevel@tonic-gate * Set length and value ONLY if not an explicit property undefine: 36497c478bd9Sstevel@tonic-gate * NOTE: value and length are zero for explicit undefines. 36507c478bd9Sstevel@tonic-gate */ 36517c478bd9Sstevel@tonic-gate 36527c478bd9Sstevel@tonic-gate if (flags & DDI_PROP_UNDEF_IT) { 36537c478bd9Sstevel@tonic-gate new_propp->prop_flags |= DDI_PROP_UNDEF_IT; 36547c478bd9Sstevel@tonic-gate } else { 36557c478bd9Sstevel@tonic-gate if ((new_propp->prop_len = length) != 0) { 36567c478bd9Sstevel@tonic-gate new_propp->prop_val = kmem_alloc(length, km_flags); 36577c478bd9Sstevel@tonic-gate if (new_propp->prop_val == 0) { 36587c478bd9Sstevel@tonic-gate kmem_free(new_propp->prop_name, name_buf_len); 36597c478bd9Sstevel@tonic-gate kmem_free(new_propp, sizeof (ddi_prop_t)); 36607c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 36617c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 36627c478bd9Sstevel@tonic-gate } 36637c478bd9Sstevel@tonic-gate bcopy(value, new_propp->prop_val, length); 36647c478bd9Sstevel@tonic-gate } 36657c478bd9Sstevel@tonic-gate } 36667c478bd9Sstevel@tonic-gate 36677c478bd9Sstevel@tonic-gate /* 36687c478bd9Sstevel@tonic-gate * Link property into beginning of list. (Properties are LIFO order.) 36697c478bd9Sstevel@tonic-gate */ 36707c478bd9Sstevel@tonic-gate 36717c478bd9Sstevel@tonic-gate mutex_enter(&(DEVI(dip)->devi_lock)); 36727c478bd9Sstevel@tonic-gate propp = *list_head; 36737c478bd9Sstevel@tonic-gate new_propp->prop_next = propp; 36747c478bd9Sstevel@tonic-gate *list_head = new_propp; 36757c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 36767c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 36777c478bd9Sstevel@tonic-gate } 36787c478bd9Sstevel@tonic-gate 36797c478bd9Sstevel@tonic-gate 36807c478bd9Sstevel@tonic-gate /* 36817c478bd9Sstevel@tonic-gate * ddi_prop_change: Modify a software managed property value 36827c478bd9Sstevel@tonic-gate * 36837c478bd9Sstevel@tonic-gate * Set new length and value if found. 36847c478bd9Sstevel@tonic-gate * returns DDI_PROP_INVAL_ARG if dev is DDI_DEV_T_ANY or 36857c478bd9Sstevel@tonic-gate * input name is the NULL string. 36867c478bd9Sstevel@tonic-gate * returns DDI_PROP_NO_MEMORY if unable to allocate memory 36877c478bd9Sstevel@tonic-gate * 36887c478bd9Sstevel@tonic-gate * Note: an undef can be modified to be a define, 36897c478bd9Sstevel@tonic-gate * (you can't go the other way.) 36907c478bd9Sstevel@tonic-gate */ 36917c478bd9Sstevel@tonic-gate 36927c478bd9Sstevel@tonic-gate static int 36937c478bd9Sstevel@tonic-gate ddi_prop_change(dev_t dev, dev_info_t *dip, int flags, 36947c478bd9Sstevel@tonic-gate char *name, caddr_t value, int length) 36957c478bd9Sstevel@tonic-gate { 36967c478bd9Sstevel@tonic-gate ddi_prop_t *propp; 36979ac2ddeaScth ddi_prop_t **ppropp; 36987c478bd9Sstevel@tonic-gate caddr_t p = NULL; 36997c478bd9Sstevel@tonic-gate 37009ac2ddeaScth if ((dev == DDI_DEV_T_ANY) || (name == NULL) || (strlen(name) == 0)) 37017c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 37027c478bd9Sstevel@tonic-gate 37037c478bd9Sstevel@tonic-gate /* 37047c478bd9Sstevel@tonic-gate * Preallocate buffer, even if we don't need it... 37057c478bd9Sstevel@tonic-gate */ 37067c478bd9Sstevel@tonic-gate if (length != 0) { 37079ac2ddeaScth p = kmem_alloc(length, (flags & DDI_PROP_CANSLEEP) ? 37089ac2ddeaScth KM_SLEEP : KM_NOSLEEP); 37097c478bd9Sstevel@tonic-gate if (p == NULL) { 37107c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 37117c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 37127c478bd9Sstevel@tonic-gate } 37137c478bd9Sstevel@tonic-gate } 37147c478bd9Sstevel@tonic-gate 37159ac2ddeaScth /* 37169ac2ddeaScth * If the dev_t value contains DDI_MAJOR_T_UNKNOWN for the major 37179ac2ddeaScth * number, a real dev_t value should be created based upon the dip's 37189ac2ddeaScth * binding driver. See ddi_prop_add... 37199ac2ddeaScth */ 37209ac2ddeaScth if (getmajor(dev) == DDI_MAJOR_T_UNKNOWN) 37219ac2ddeaScth dev = makedevice( 37229ac2ddeaScth ddi_name_to_major(DEVI(dip)->devi_binding_name), 37239ac2ddeaScth getminor(dev)); 37249ac2ddeaScth 37257c478bd9Sstevel@tonic-gate /* 37267c478bd9Sstevel@tonic-gate * Check to see if the property exists. If so we modify it. 37277c478bd9Sstevel@tonic-gate * Else we create it by calling ddi_prop_add(). 37287c478bd9Sstevel@tonic-gate */ 37297c478bd9Sstevel@tonic-gate mutex_enter(&(DEVI(dip)->devi_lock)); 37309ac2ddeaScth ppropp = &DEVI(dip)->devi_drv_prop_ptr; 37317c478bd9Sstevel@tonic-gate if (flags & DDI_PROP_SYSTEM_DEF) 37329ac2ddeaScth ppropp = &DEVI(dip)->devi_sys_prop_ptr; 37337c478bd9Sstevel@tonic-gate else if (flags & DDI_PROP_HW_DEF) 37349ac2ddeaScth ppropp = &DEVI(dip)->devi_hw_prop_ptr; 37357c478bd9Sstevel@tonic-gate 37369ac2ddeaScth if ((propp = i_ddi_prop_search(dev, name, flags, ppropp)) != NULL) { 37379ac2ddeaScth /* 37389ac2ddeaScth * Need to reallocate buffer? If so, do it 37399ac2ddeaScth * carefully (reuse same space if new prop 37409ac2ddeaScth * is same size and non-NULL sized). 37419ac2ddeaScth */ 37429ac2ddeaScth if (length != 0) 37439ac2ddeaScth bcopy(value, p, length); 37447c478bd9Sstevel@tonic-gate 37459ac2ddeaScth if (propp->prop_len != 0) 37469ac2ddeaScth kmem_free(propp->prop_val, propp->prop_len); 37477c478bd9Sstevel@tonic-gate 37489ac2ddeaScth propp->prop_len = length; 37499ac2ddeaScth propp->prop_val = p; 37509ac2ddeaScth propp->prop_flags &= ~DDI_PROP_UNDEF_IT; 37519ac2ddeaScth mutex_exit(&(DEVI(dip)->devi_lock)); 37529ac2ddeaScth return (DDI_PROP_SUCCESS); 37537c478bd9Sstevel@tonic-gate } 37547c478bd9Sstevel@tonic-gate 37557c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 37567c478bd9Sstevel@tonic-gate if (length != 0) 37577c478bd9Sstevel@tonic-gate kmem_free(p, length); 37589ac2ddeaScth 37597c478bd9Sstevel@tonic-gate return (ddi_prop_add(dev, dip, flags, name, value, length)); 37607c478bd9Sstevel@tonic-gate } 37617c478bd9Sstevel@tonic-gate 37627c478bd9Sstevel@tonic-gate /* 37637c478bd9Sstevel@tonic-gate * Common update routine used to update and encode a property. Creates 37647c478bd9Sstevel@tonic-gate * a property handle, calls the property encode routine, figures out if 37657c478bd9Sstevel@tonic-gate * the property already exists and updates if it does. Otherwise it 37667c478bd9Sstevel@tonic-gate * creates if it does not exist. 37677c478bd9Sstevel@tonic-gate */ 37687c478bd9Sstevel@tonic-gate int 37697c478bd9Sstevel@tonic-gate ddi_prop_update_common(dev_t match_dev, dev_info_t *dip, int flags, 37707c478bd9Sstevel@tonic-gate char *name, void *data, uint_t nelements, 37717c478bd9Sstevel@tonic-gate int (*prop_create)(prop_handle_t *, void *data, uint_t nelements)) 37727c478bd9Sstevel@tonic-gate { 37737c478bd9Sstevel@tonic-gate prop_handle_t ph; 37747c478bd9Sstevel@tonic-gate int rval; 37757c478bd9Sstevel@tonic-gate uint_t ourflags; 37767c478bd9Sstevel@tonic-gate 37777c478bd9Sstevel@tonic-gate /* 37787c478bd9Sstevel@tonic-gate * If dev_t is DDI_DEV_T_ANY or name's length is zero, 37797c478bd9Sstevel@tonic-gate * return error. 37807c478bd9Sstevel@tonic-gate */ 37817c478bd9Sstevel@tonic-gate if (match_dev == DDI_DEV_T_ANY || name == NULL || strlen(name) == 0) 37827c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 37837c478bd9Sstevel@tonic-gate 37847c478bd9Sstevel@tonic-gate /* 37857c478bd9Sstevel@tonic-gate * Create the handle 37867c478bd9Sstevel@tonic-gate */ 37877c478bd9Sstevel@tonic-gate ph.ph_data = NULL; 37887c478bd9Sstevel@tonic-gate ph.ph_cur_pos = NULL; 37897c478bd9Sstevel@tonic-gate ph.ph_save_pos = NULL; 37907c478bd9Sstevel@tonic-gate ph.ph_size = 0; 37917c478bd9Sstevel@tonic-gate ph.ph_ops = &prop_1275_ops; 37927c478bd9Sstevel@tonic-gate 37937c478bd9Sstevel@tonic-gate /* 37947c478bd9Sstevel@tonic-gate * ourflags: 37957c478bd9Sstevel@tonic-gate * For compatibility with the old interfaces. The old interfaces 37967c478bd9Sstevel@tonic-gate * didn't sleep by default and slept when the flag was set. These 37977c478bd9Sstevel@tonic-gate * interfaces to the opposite. So the old interfaces now set the 37987c478bd9Sstevel@tonic-gate * DDI_PROP_DONTSLEEP flag by default which tells us not to sleep. 37997c478bd9Sstevel@tonic-gate * 38007c478bd9Sstevel@tonic-gate * ph.ph_flags: 38017c478bd9Sstevel@tonic-gate * Blocked data or unblocked data allocation 38027c478bd9Sstevel@tonic-gate * for ph.ph_data in ddi_prop_encode_alloc() 38037c478bd9Sstevel@tonic-gate */ 38047c478bd9Sstevel@tonic-gate if (flags & DDI_PROP_DONTSLEEP) { 38057c478bd9Sstevel@tonic-gate ourflags = flags; 38067c478bd9Sstevel@tonic-gate ph.ph_flags = DDI_PROP_DONTSLEEP; 38077c478bd9Sstevel@tonic-gate } else { 38087c478bd9Sstevel@tonic-gate ourflags = flags | DDI_PROP_CANSLEEP; 38097c478bd9Sstevel@tonic-gate ph.ph_flags = DDI_PROP_CANSLEEP; 38107c478bd9Sstevel@tonic-gate } 38117c478bd9Sstevel@tonic-gate 38127c478bd9Sstevel@tonic-gate /* 38137c478bd9Sstevel@tonic-gate * Encode the data and store it in the property handle by 38147c478bd9Sstevel@tonic-gate * calling the prop_encode routine. 38157c478bd9Sstevel@tonic-gate */ 38167c478bd9Sstevel@tonic-gate if ((rval = (*prop_create)(&ph, data, nelements)) != 38177c478bd9Sstevel@tonic-gate DDI_PROP_SUCCESS) { 38187c478bd9Sstevel@tonic-gate if (rval == DDI_PROP_NO_MEMORY) 38197c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 38207c478bd9Sstevel@tonic-gate if (ph.ph_size != 0) 38217c478bd9Sstevel@tonic-gate kmem_free(ph.ph_data, ph.ph_size); 38227c478bd9Sstevel@tonic-gate return (rval); 38237c478bd9Sstevel@tonic-gate } 38247c478bd9Sstevel@tonic-gate 38257c478bd9Sstevel@tonic-gate /* 38267c478bd9Sstevel@tonic-gate * The old interfaces use a stacking approach to creating 38277c478bd9Sstevel@tonic-gate * properties. If we are being called from the old interfaces, 38287c478bd9Sstevel@tonic-gate * the DDI_PROP_STACK_CREATE flag will be set, so we just do a 38297c478bd9Sstevel@tonic-gate * create without checking. 38307c478bd9Sstevel@tonic-gate */ 38317c478bd9Sstevel@tonic-gate if (flags & DDI_PROP_STACK_CREATE) { 38327c478bd9Sstevel@tonic-gate rval = ddi_prop_add(match_dev, dip, 38337c478bd9Sstevel@tonic-gate ourflags, name, ph.ph_data, ph.ph_size); 38347c478bd9Sstevel@tonic-gate } else { 38357c478bd9Sstevel@tonic-gate rval = ddi_prop_change(match_dev, dip, 38367c478bd9Sstevel@tonic-gate ourflags, name, ph.ph_data, ph.ph_size); 38377c478bd9Sstevel@tonic-gate } 38387c478bd9Sstevel@tonic-gate 38397c478bd9Sstevel@tonic-gate /* 38407c478bd9Sstevel@tonic-gate * Free the encoded data allocated in the prop_encode routine. 38417c478bd9Sstevel@tonic-gate */ 38427c478bd9Sstevel@tonic-gate if (ph.ph_size != 0) 38437c478bd9Sstevel@tonic-gate kmem_free(ph.ph_data, ph.ph_size); 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate return (rval); 38467c478bd9Sstevel@tonic-gate } 38477c478bd9Sstevel@tonic-gate 38487c478bd9Sstevel@tonic-gate 38497c478bd9Sstevel@tonic-gate /* 38507c478bd9Sstevel@tonic-gate * ddi_prop_create: Define a managed property: 38517c478bd9Sstevel@tonic-gate * See above for details. 38527c478bd9Sstevel@tonic-gate */ 38537c478bd9Sstevel@tonic-gate 38547c478bd9Sstevel@tonic-gate int 38557c478bd9Sstevel@tonic-gate ddi_prop_create(dev_t dev, dev_info_t *dip, int flag, 38567c478bd9Sstevel@tonic-gate char *name, caddr_t value, int length) 38577c478bd9Sstevel@tonic-gate { 38587c478bd9Sstevel@tonic-gate if (!(flag & DDI_PROP_CANSLEEP)) { 38597c478bd9Sstevel@tonic-gate flag |= DDI_PROP_DONTSLEEP; 38607c478bd9Sstevel@tonic-gate #ifdef DDI_PROP_DEBUG 38617c478bd9Sstevel@tonic-gate if (length != 0) 38627c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!ddi_prop_create: interface obsolete," 38637c478bd9Sstevel@tonic-gate "use ddi_prop_update (prop = %s, node = %s%d)", 38647c478bd9Sstevel@tonic-gate name, ddi_driver_name(dip), ddi_get_instance(dip)); 38657c478bd9Sstevel@tonic-gate #endif /* DDI_PROP_DEBUG */ 38667c478bd9Sstevel@tonic-gate } 38677c478bd9Sstevel@tonic-gate flag &= ~DDI_PROP_SYSTEM_DEF; 3868b9ccdc5aScth flag |= DDI_PROP_STACK_CREATE | DDI_PROP_TYPE_ANY; 3869b9ccdc5aScth return (ddi_prop_update_common(dev, dip, flag, name, 38707c478bd9Sstevel@tonic-gate value, length, ddi_prop_fm_encode_bytes)); 38717c478bd9Sstevel@tonic-gate } 38727c478bd9Sstevel@tonic-gate 38737c478bd9Sstevel@tonic-gate int 38747c478bd9Sstevel@tonic-gate e_ddi_prop_create(dev_t dev, dev_info_t *dip, int flag, 38757c478bd9Sstevel@tonic-gate char *name, caddr_t value, int length) 38767c478bd9Sstevel@tonic-gate { 38777c478bd9Sstevel@tonic-gate if (!(flag & DDI_PROP_CANSLEEP)) 38787c478bd9Sstevel@tonic-gate flag |= DDI_PROP_DONTSLEEP; 3879b9ccdc5aScth flag |= DDI_PROP_SYSTEM_DEF | DDI_PROP_STACK_CREATE | DDI_PROP_TYPE_ANY; 3880b9ccdc5aScth return (ddi_prop_update_common(dev, dip, flag, 38817c478bd9Sstevel@tonic-gate name, value, length, ddi_prop_fm_encode_bytes)); 38827c478bd9Sstevel@tonic-gate } 38837c478bd9Sstevel@tonic-gate 38847c478bd9Sstevel@tonic-gate int 38857c478bd9Sstevel@tonic-gate ddi_prop_modify(dev_t dev, dev_info_t *dip, int flag, 38867c478bd9Sstevel@tonic-gate char *name, caddr_t value, int length) 38877c478bd9Sstevel@tonic-gate { 38887c478bd9Sstevel@tonic-gate ASSERT((flag & DDI_PROP_TYPE_MASK) == 0); 38897c478bd9Sstevel@tonic-gate 38907c478bd9Sstevel@tonic-gate /* 38917c478bd9Sstevel@tonic-gate * If dev_t is DDI_DEV_T_ANY or name's length is zero, 38927c478bd9Sstevel@tonic-gate * return error. 38937c478bd9Sstevel@tonic-gate */ 38947c478bd9Sstevel@tonic-gate if (dev == DDI_DEV_T_ANY || name == NULL || strlen(name) == 0) 38957c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 38967c478bd9Sstevel@tonic-gate 38977c478bd9Sstevel@tonic-gate if (!(flag & DDI_PROP_CANSLEEP)) 38987c478bd9Sstevel@tonic-gate flag |= DDI_PROP_DONTSLEEP; 38997c478bd9Sstevel@tonic-gate flag &= ~DDI_PROP_SYSTEM_DEF; 39009ac2ddeaScth if (ddi_prop_exists(dev, dip, (flag | DDI_PROP_NOTPROM), name) == 0) 39017c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 39027c478bd9Sstevel@tonic-gate 39037c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(dev, dip, 39047c478bd9Sstevel@tonic-gate (flag | DDI_PROP_TYPE_BYTE), name, 39057c478bd9Sstevel@tonic-gate value, length, ddi_prop_fm_encode_bytes)); 39067c478bd9Sstevel@tonic-gate } 39077c478bd9Sstevel@tonic-gate 39087c478bd9Sstevel@tonic-gate int 39097c478bd9Sstevel@tonic-gate e_ddi_prop_modify(dev_t dev, dev_info_t *dip, int flag, 39107c478bd9Sstevel@tonic-gate char *name, caddr_t value, int length) 39117c478bd9Sstevel@tonic-gate { 39127c478bd9Sstevel@tonic-gate ASSERT((flag & DDI_PROP_TYPE_MASK) == 0); 39137c478bd9Sstevel@tonic-gate 39147c478bd9Sstevel@tonic-gate /* 39157c478bd9Sstevel@tonic-gate * If dev_t is DDI_DEV_T_ANY or name's length is zero, 39167c478bd9Sstevel@tonic-gate * return error. 39177c478bd9Sstevel@tonic-gate */ 39187c478bd9Sstevel@tonic-gate if (dev == DDI_DEV_T_ANY || name == NULL || strlen(name) == 0) 39197c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 39207c478bd9Sstevel@tonic-gate 39219ac2ddeaScth if (ddi_prop_exists(dev, dip, (flag | DDI_PROP_SYSTEM_DEF), name) == 0) 39227c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 39237c478bd9Sstevel@tonic-gate 39247c478bd9Sstevel@tonic-gate if (!(flag & DDI_PROP_CANSLEEP)) 39257c478bd9Sstevel@tonic-gate flag |= DDI_PROP_DONTSLEEP; 39267c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(dev, dip, 3927184cd04cScth (flag | DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_BYTE), 3928184cd04cScth name, value, length, ddi_prop_fm_encode_bytes)); 39297c478bd9Sstevel@tonic-gate } 39307c478bd9Sstevel@tonic-gate 39317c478bd9Sstevel@tonic-gate 39327c478bd9Sstevel@tonic-gate /* 39337c478bd9Sstevel@tonic-gate * Common lookup routine used to lookup and decode a property. 39347c478bd9Sstevel@tonic-gate * Creates a property handle, searches for the raw encoded data, 39357c478bd9Sstevel@tonic-gate * fills in the handle, and calls the property decode functions 39367c478bd9Sstevel@tonic-gate * passed in. 39377c478bd9Sstevel@tonic-gate * 39387c478bd9Sstevel@tonic-gate * This routine is not static because ddi_bus_prop_op() which lives in 39397c478bd9Sstevel@tonic-gate * ddi_impl.c calls it. No driver should be calling this routine. 39407c478bd9Sstevel@tonic-gate */ 39417c478bd9Sstevel@tonic-gate int 39427c478bd9Sstevel@tonic-gate ddi_prop_lookup_common(dev_t match_dev, dev_info_t *dip, 39437c478bd9Sstevel@tonic-gate uint_t flags, char *name, void *data, uint_t *nelements, 39447c478bd9Sstevel@tonic-gate int (*prop_decoder)(prop_handle_t *, void *data, uint_t *nelements)) 39457c478bd9Sstevel@tonic-gate { 39467c478bd9Sstevel@tonic-gate int rval; 39477c478bd9Sstevel@tonic-gate uint_t ourflags; 39487c478bd9Sstevel@tonic-gate prop_handle_t ph; 39497c478bd9Sstevel@tonic-gate 39507c478bd9Sstevel@tonic-gate if ((match_dev == DDI_DEV_T_NONE) || 39519ac2ddeaScth (name == NULL) || (strlen(name) == 0)) 39527c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 39537c478bd9Sstevel@tonic-gate 39547c478bd9Sstevel@tonic-gate ourflags = (flags & DDI_PROP_DONTSLEEP) ? flags : 3955184cd04cScth flags | DDI_PROP_CANSLEEP; 39567c478bd9Sstevel@tonic-gate 39577c478bd9Sstevel@tonic-gate /* 39587c478bd9Sstevel@tonic-gate * Get the encoded data 39597c478bd9Sstevel@tonic-gate */ 39607c478bd9Sstevel@tonic-gate bzero(&ph, sizeof (prop_handle_t)); 39617c478bd9Sstevel@tonic-gate 396265cf7c95SVikram Hegde if ((flags & DDI_UNBND_DLPI2) || (flags & DDI_PROP_ROOTNEX_GLOBAL)) { 39637c478bd9Sstevel@tonic-gate /* 396465cf7c95SVikram Hegde * For rootnex and unbound dlpi style-2 devices, index into 39657c478bd9Sstevel@tonic-gate * the devnames' array and search the global 39667c478bd9Sstevel@tonic-gate * property list. 39677c478bd9Sstevel@tonic-gate */ 39687c478bd9Sstevel@tonic-gate ourflags &= ~DDI_UNBND_DLPI2; 39697c478bd9Sstevel@tonic-gate rval = i_ddi_prop_search_global(match_dev, 39707c478bd9Sstevel@tonic-gate ourflags, name, &ph.ph_data, &ph.ph_size); 39717c478bd9Sstevel@tonic-gate } else { 39727c478bd9Sstevel@tonic-gate rval = ddi_prop_search_common(match_dev, dip, 39737c478bd9Sstevel@tonic-gate PROP_LEN_AND_VAL_ALLOC, ourflags, name, 39747c478bd9Sstevel@tonic-gate &ph.ph_data, &ph.ph_size); 39757c478bd9Sstevel@tonic-gate 39767c478bd9Sstevel@tonic-gate } 39777c478bd9Sstevel@tonic-gate 39787c478bd9Sstevel@tonic-gate if (rval != DDI_PROP_SUCCESS && rval != DDI_PROP_FOUND_1275) { 39797c478bd9Sstevel@tonic-gate ASSERT(ph.ph_data == NULL); 39807c478bd9Sstevel@tonic-gate ASSERT(ph.ph_size == 0); 39817c478bd9Sstevel@tonic-gate return (rval); 39827c478bd9Sstevel@tonic-gate } 39837c478bd9Sstevel@tonic-gate 39847c478bd9Sstevel@tonic-gate /* 39857c478bd9Sstevel@tonic-gate * If the encoded data came from a OBP or software 39867c478bd9Sstevel@tonic-gate * use the 1275 OBP decode/encode routines. 39877c478bd9Sstevel@tonic-gate */ 39887c478bd9Sstevel@tonic-gate ph.ph_cur_pos = ph.ph_data; 39897c478bd9Sstevel@tonic-gate ph.ph_save_pos = ph.ph_data; 39907c478bd9Sstevel@tonic-gate ph.ph_ops = &prop_1275_ops; 39917c478bd9Sstevel@tonic-gate ph.ph_flags = (rval == DDI_PROP_FOUND_1275) ? PH_FROM_PROM : 0; 39927c478bd9Sstevel@tonic-gate 39937c478bd9Sstevel@tonic-gate rval = (*prop_decoder)(&ph, data, nelements); 39947c478bd9Sstevel@tonic-gate 39957c478bd9Sstevel@tonic-gate /* 39967c478bd9Sstevel@tonic-gate * Free the encoded data 39977c478bd9Sstevel@tonic-gate */ 39987c478bd9Sstevel@tonic-gate if (ph.ph_size != 0) 39997c478bd9Sstevel@tonic-gate kmem_free(ph.ph_data, ph.ph_size); 40007c478bd9Sstevel@tonic-gate 40017c478bd9Sstevel@tonic-gate return (rval); 40027c478bd9Sstevel@tonic-gate } 40037c478bd9Sstevel@tonic-gate 40047c478bd9Sstevel@tonic-gate /* 40057c478bd9Sstevel@tonic-gate * Lookup and return an array of composite properties. The driver must 40067c478bd9Sstevel@tonic-gate * provide the decode routine. 40077c478bd9Sstevel@tonic-gate */ 40087c478bd9Sstevel@tonic-gate int 40097c478bd9Sstevel@tonic-gate ddi_prop_lookup(dev_t match_dev, dev_info_t *dip, 40107c478bd9Sstevel@tonic-gate uint_t flags, char *name, void *data, uint_t *nelements, 40117c478bd9Sstevel@tonic-gate int (*prop_decoder)(prop_handle_t *, void *data, uint_t *nelements)) 40127c478bd9Sstevel@tonic-gate { 40137c478bd9Sstevel@tonic-gate return (ddi_prop_lookup_common(match_dev, dip, 40147c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_COMPOSITE), name, 40157c478bd9Sstevel@tonic-gate data, nelements, prop_decoder)); 40167c478bd9Sstevel@tonic-gate } 40177c478bd9Sstevel@tonic-gate 40187c478bd9Sstevel@tonic-gate /* 40197c478bd9Sstevel@tonic-gate * Return 1 if a property exists (no type checking done). 40207c478bd9Sstevel@tonic-gate * Return 0 if it does not exist. 40217c478bd9Sstevel@tonic-gate */ 40227c478bd9Sstevel@tonic-gate int 40237c478bd9Sstevel@tonic-gate ddi_prop_exists(dev_t match_dev, dev_info_t *dip, uint_t flags, char *name) 40247c478bd9Sstevel@tonic-gate { 40257c478bd9Sstevel@tonic-gate int i; 40267c478bd9Sstevel@tonic-gate uint_t x = 0; 40277c478bd9Sstevel@tonic-gate 40287c478bd9Sstevel@tonic-gate i = ddi_prop_search_common(match_dev, dip, PROP_EXISTS, 4029184cd04cScth flags | DDI_PROP_TYPE_MASK, name, NULL, &x); 40307c478bd9Sstevel@tonic-gate return (i == DDI_PROP_SUCCESS || i == DDI_PROP_FOUND_1275); 40317c478bd9Sstevel@tonic-gate } 40327c478bd9Sstevel@tonic-gate 40337c478bd9Sstevel@tonic-gate 40347c478bd9Sstevel@tonic-gate /* 40357c478bd9Sstevel@tonic-gate * Update an array of composite properties. The driver must 40367c478bd9Sstevel@tonic-gate * provide the encode routine. 40377c478bd9Sstevel@tonic-gate */ 40387c478bd9Sstevel@tonic-gate int 40397c478bd9Sstevel@tonic-gate ddi_prop_update(dev_t match_dev, dev_info_t *dip, 40407c478bd9Sstevel@tonic-gate char *name, void *data, uint_t nelements, 40417c478bd9Sstevel@tonic-gate int (*prop_create)(prop_handle_t *, void *data, uint_t nelements)) 40427c478bd9Sstevel@tonic-gate { 40437c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_COMPOSITE, 40447c478bd9Sstevel@tonic-gate name, data, nelements, prop_create)); 40457c478bd9Sstevel@tonic-gate } 40467c478bd9Sstevel@tonic-gate 40477c478bd9Sstevel@tonic-gate /* 40487c478bd9Sstevel@tonic-gate * Get a single integer or boolean property and return it. 40497c478bd9Sstevel@tonic-gate * If the property does not exists, or cannot be decoded, 40507c478bd9Sstevel@tonic-gate * then return the defvalue passed in. 40517c478bd9Sstevel@tonic-gate * 40527c478bd9Sstevel@tonic-gate * This routine always succeeds. 40537c478bd9Sstevel@tonic-gate */ 40547c478bd9Sstevel@tonic-gate int 40557c478bd9Sstevel@tonic-gate ddi_prop_get_int(dev_t match_dev, dev_info_t *dip, uint_t flags, 40567c478bd9Sstevel@tonic-gate char *name, int defvalue) 40577c478bd9Sstevel@tonic-gate { 40587c478bd9Sstevel@tonic-gate int data; 40597c478bd9Sstevel@tonic-gate uint_t nelements; 40607c478bd9Sstevel@tonic-gate int rval; 40617c478bd9Sstevel@tonic-gate 40627c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 406365cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 40647c478bd9Sstevel@tonic-gate #ifdef DEBUG 40657c478bd9Sstevel@tonic-gate if (dip != NULL) { 40667c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_prop_get_int: invalid flag" 40677c478bd9Sstevel@tonic-gate " 0x%x (prop = %s, node = %s%d)", flags, 40687c478bd9Sstevel@tonic-gate name, ddi_driver_name(dip), ddi_get_instance(dip)); 40697c478bd9Sstevel@tonic-gate } 40707c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 40717c478bd9Sstevel@tonic-gate flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 40727c478bd9Sstevel@tonic-gate LDI_DEV_T_ANY | DDI_UNBND_DLPI2; 40737c478bd9Sstevel@tonic-gate } 40747c478bd9Sstevel@tonic-gate 40757c478bd9Sstevel@tonic-gate if ((rval = ddi_prop_lookup_common(match_dev, dip, 40767c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_INT), name, &data, &nelements, 40777c478bd9Sstevel@tonic-gate ddi_prop_fm_decode_int)) != DDI_PROP_SUCCESS) { 40787c478bd9Sstevel@tonic-gate if (rval == DDI_PROP_END_OF_DATA) 40797c478bd9Sstevel@tonic-gate data = 1; 40807c478bd9Sstevel@tonic-gate else 40817c478bd9Sstevel@tonic-gate data = defvalue; 40827c478bd9Sstevel@tonic-gate } 40837c478bd9Sstevel@tonic-gate return (data); 40847c478bd9Sstevel@tonic-gate } 40857c478bd9Sstevel@tonic-gate 40867c478bd9Sstevel@tonic-gate /* 40877c478bd9Sstevel@tonic-gate * Get a single 64 bit integer or boolean property and return it. 40887c478bd9Sstevel@tonic-gate * If the property does not exists, or cannot be decoded, 40897c478bd9Sstevel@tonic-gate * then return the defvalue passed in. 40907c478bd9Sstevel@tonic-gate * 40917c478bd9Sstevel@tonic-gate * This routine always succeeds. 40927c478bd9Sstevel@tonic-gate */ 40937c478bd9Sstevel@tonic-gate int64_t 40947c478bd9Sstevel@tonic-gate ddi_prop_get_int64(dev_t match_dev, dev_info_t *dip, uint_t flags, 40957c478bd9Sstevel@tonic-gate char *name, int64_t defvalue) 40967c478bd9Sstevel@tonic-gate { 40977c478bd9Sstevel@tonic-gate int64_t data; 40987c478bd9Sstevel@tonic-gate uint_t nelements; 40997c478bd9Sstevel@tonic-gate int rval; 41007c478bd9Sstevel@tonic-gate 41017c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 410265cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 41037c478bd9Sstevel@tonic-gate #ifdef DEBUG 41047c478bd9Sstevel@tonic-gate if (dip != NULL) { 41057c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_prop_get_int64: invalid flag" 41067c478bd9Sstevel@tonic-gate " 0x%x (prop = %s, node = %s%d)", flags, 41077c478bd9Sstevel@tonic-gate name, ddi_driver_name(dip), ddi_get_instance(dip)); 41087c478bd9Sstevel@tonic-gate } 41097c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 41107c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 41117c478bd9Sstevel@tonic-gate } 41127c478bd9Sstevel@tonic-gate 41137c478bd9Sstevel@tonic-gate if ((rval = ddi_prop_lookup_common(match_dev, dip, 41147c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_INT64 | DDI_PROP_NOTPROM), 41157c478bd9Sstevel@tonic-gate name, &data, &nelements, ddi_prop_fm_decode_int64)) 41167c478bd9Sstevel@tonic-gate != DDI_PROP_SUCCESS) { 41177c478bd9Sstevel@tonic-gate if (rval == DDI_PROP_END_OF_DATA) 41187c478bd9Sstevel@tonic-gate data = 1; 41197c478bd9Sstevel@tonic-gate else 41207c478bd9Sstevel@tonic-gate data = defvalue; 41217c478bd9Sstevel@tonic-gate } 41227c478bd9Sstevel@tonic-gate return (data); 41237c478bd9Sstevel@tonic-gate } 41247c478bd9Sstevel@tonic-gate 41257c478bd9Sstevel@tonic-gate /* 41267c478bd9Sstevel@tonic-gate * Get an array of integer property 41277c478bd9Sstevel@tonic-gate */ 41287c478bd9Sstevel@tonic-gate int 41297c478bd9Sstevel@tonic-gate ddi_prop_lookup_int_array(dev_t match_dev, dev_info_t *dip, uint_t flags, 41307c478bd9Sstevel@tonic-gate char *name, int **data, uint_t *nelements) 41317c478bd9Sstevel@tonic-gate { 41327c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 413365cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 41347c478bd9Sstevel@tonic-gate #ifdef DEBUG 41357c478bd9Sstevel@tonic-gate if (dip != NULL) { 41367c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_prop_lookup_int_array: " 41377c478bd9Sstevel@tonic-gate "invalid flag 0x%x (prop = %s, node = %s%d)", 41387c478bd9Sstevel@tonic-gate flags, name, ddi_driver_name(dip), 41397c478bd9Sstevel@tonic-gate ddi_get_instance(dip)); 41407c478bd9Sstevel@tonic-gate } 41417c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 41427c478bd9Sstevel@tonic-gate flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 4143184cd04cScth LDI_DEV_T_ANY | DDI_UNBND_DLPI2; 41447c478bd9Sstevel@tonic-gate } 41457c478bd9Sstevel@tonic-gate 41467c478bd9Sstevel@tonic-gate return (ddi_prop_lookup_common(match_dev, dip, 41477c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_INT), name, data, 41487c478bd9Sstevel@tonic-gate nelements, ddi_prop_fm_decode_ints)); 41497c478bd9Sstevel@tonic-gate } 41507c478bd9Sstevel@tonic-gate 41517c478bd9Sstevel@tonic-gate /* 41527c478bd9Sstevel@tonic-gate * Get an array of 64 bit integer properties 41537c478bd9Sstevel@tonic-gate */ 41547c478bd9Sstevel@tonic-gate int 41557c478bd9Sstevel@tonic-gate ddi_prop_lookup_int64_array(dev_t match_dev, dev_info_t *dip, uint_t flags, 41567c478bd9Sstevel@tonic-gate char *name, int64_t **data, uint_t *nelements) 41577c478bd9Sstevel@tonic-gate { 41587c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 415965cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 41607c478bd9Sstevel@tonic-gate #ifdef DEBUG 41617c478bd9Sstevel@tonic-gate if (dip != NULL) { 41627c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_prop_lookup_int64_array: " 41637c478bd9Sstevel@tonic-gate "invalid flag 0x%x (prop = %s, node = %s%d)", 41647c478bd9Sstevel@tonic-gate flags, name, ddi_driver_name(dip), 41657c478bd9Sstevel@tonic-gate ddi_get_instance(dip)); 41667c478bd9Sstevel@tonic-gate } 41677c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 41687c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 41697c478bd9Sstevel@tonic-gate } 41707c478bd9Sstevel@tonic-gate 41717c478bd9Sstevel@tonic-gate return (ddi_prop_lookup_common(match_dev, dip, 41727c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_INT64 | DDI_PROP_NOTPROM), 41737c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_decode_int64_array)); 41747c478bd9Sstevel@tonic-gate } 41757c478bd9Sstevel@tonic-gate 41767c478bd9Sstevel@tonic-gate /* 41777c478bd9Sstevel@tonic-gate * Update a single integer property. If the property exists on the drivers 41787c478bd9Sstevel@tonic-gate * property list it updates, else it creates it. 41797c478bd9Sstevel@tonic-gate */ 41807c478bd9Sstevel@tonic-gate int 41817c478bd9Sstevel@tonic-gate ddi_prop_update_int(dev_t match_dev, dev_info_t *dip, 41827c478bd9Sstevel@tonic-gate char *name, int data) 41837c478bd9Sstevel@tonic-gate { 41847c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT, 41857c478bd9Sstevel@tonic-gate name, &data, 1, ddi_prop_fm_encode_ints)); 41867c478bd9Sstevel@tonic-gate } 41877c478bd9Sstevel@tonic-gate 41887c478bd9Sstevel@tonic-gate /* 41897c478bd9Sstevel@tonic-gate * Update a single 64 bit integer property. 41907c478bd9Sstevel@tonic-gate * Update the driver property list if it exists, else create it. 41917c478bd9Sstevel@tonic-gate */ 41927c478bd9Sstevel@tonic-gate int 41937c478bd9Sstevel@tonic-gate ddi_prop_update_int64(dev_t match_dev, dev_info_t *dip, 41947c478bd9Sstevel@tonic-gate char *name, int64_t data) 41957c478bd9Sstevel@tonic-gate { 41967c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT64, 41977c478bd9Sstevel@tonic-gate name, &data, 1, ddi_prop_fm_encode_int64)); 41987c478bd9Sstevel@tonic-gate } 41997c478bd9Sstevel@tonic-gate 42007c478bd9Sstevel@tonic-gate int 42017c478bd9Sstevel@tonic-gate e_ddi_prop_update_int(dev_t match_dev, dev_info_t *dip, 42027c478bd9Sstevel@tonic-gate char *name, int data) 42037c478bd9Sstevel@tonic-gate { 42047c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 42057c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT, 42067c478bd9Sstevel@tonic-gate name, &data, 1, ddi_prop_fm_encode_ints)); 42077c478bd9Sstevel@tonic-gate } 42087c478bd9Sstevel@tonic-gate 42097c478bd9Sstevel@tonic-gate int 42107c478bd9Sstevel@tonic-gate e_ddi_prop_update_int64(dev_t match_dev, dev_info_t *dip, 42117c478bd9Sstevel@tonic-gate char *name, int64_t data) 42127c478bd9Sstevel@tonic-gate { 42137c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 42147c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT64, 42157c478bd9Sstevel@tonic-gate name, &data, 1, ddi_prop_fm_encode_int64)); 42167c478bd9Sstevel@tonic-gate } 42177c478bd9Sstevel@tonic-gate 42187c478bd9Sstevel@tonic-gate /* 42197c478bd9Sstevel@tonic-gate * Update an array of integer property. If the property exists on the drivers 42207c478bd9Sstevel@tonic-gate * property list it updates, else it creates it. 42217c478bd9Sstevel@tonic-gate */ 42227c478bd9Sstevel@tonic-gate int 42237c478bd9Sstevel@tonic-gate ddi_prop_update_int_array(dev_t match_dev, dev_info_t *dip, 42247c478bd9Sstevel@tonic-gate char *name, int *data, uint_t nelements) 42257c478bd9Sstevel@tonic-gate { 42267c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT, 42277c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_encode_ints)); 42287c478bd9Sstevel@tonic-gate } 42297c478bd9Sstevel@tonic-gate 42307c478bd9Sstevel@tonic-gate /* 42317c478bd9Sstevel@tonic-gate * Update an array of 64 bit integer properties. 42327c478bd9Sstevel@tonic-gate * Update the driver property list if it exists, else create it. 42337c478bd9Sstevel@tonic-gate */ 42347c478bd9Sstevel@tonic-gate int 42357c478bd9Sstevel@tonic-gate ddi_prop_update_int64_array(dev_t match_dev, dev_info_t *dip, 42367c478bd9Sstevel@tonic-gate char *name, int64_t *data, uint_t nelements) 42377c478bd9Sstevel@tonic-gate { 42387c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT64, 42397c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_encode_int64)); 42407c478bd9Sstevel@tonic-gate } 42417c478bd9Sstevel@tonic-gate 42427c478bd9Sstevel@tonic-gate int 42437c478bd9Sstevel@tonic-gate e_ddi_prop_update_int64_array(dev_t match_dev, dev_info_t *dip, 42447c478bd9Sstevel@tonic-gate char *name, int64_t *data, uint_t nelements) 42457c478bd9Sstevel@tonic-gate { 42467c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 42477c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT64, 42487c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_encode_int64)); 42497c478bd9Sstevel@tonic-gate } 42507c478bd9Sstevel@tonic-gate 42517c478bd9Sstevel@tonic-gate int 42527c478bd9Sstevel@tonic-gate e_ddi_prop_update_int_array(dev_t match_dev, dev_info_t *dip, 42537c478bd9Sstevel@tonic-gate char *name, int *data, uint_t nelements) 42547c478bd9Sstevel@tonic-gate { 42557c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 42567c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT, 42577c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_encode_ints)); 42587c478bd9Sstevel@tonic-gate } 42597c478bd9Sstevel@tonic-gate 42607c478bd9Sstevel@tonic-gate /* 42617c478bd9Sstevel@tonic-gate * Get a single string property. 42627c478bd9Sstevel@tonic-gate */ 42637c478bd9Sstevel@tonic-gate int 42647c478bd9Sstevel@tonic-gate ddi_prop_lookup_string(dev_t match_dev, dev_info_t *dip, uint_t flags, 42657c478bd9Sstevel@tonic-gate char *name, char **data) 42667c478bd9Sstevel@tonic-gate { 42677c478bd9Sstevel@tonic-gate uint_t x; 42687c478bd9Sstevel@tonic-gate 42697c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 427065cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 42717c478bd9Sstevel@tonic-gate #ifdef DEBUG 42727c478bd9Sstevel@tonic-gate if (dip != NULL) { 42737c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s: invalid flag 0x%x " 42747c478bd9Sstevel@tonic-gate "(prop = %s, node = %s%d); invalid bits ignored", 42757c478bd9Sstevel@tonic-gate "ddi_prop_lookup_string", flags, name, 42767c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip)); 42777c478bd9Sstevel@tonic-gate } 42787c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 42797c478bd9Sstevel@tonic-gate flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 42807c478bd9Sstevel@tonic-gate LDI_DEV_T_ANY | DDI_UNBND_DLPI2; 42817c478bd9Sstevel@tonic-gate } 42827c478bd9Sstevel@tonic-gate 42837c478bd9Sstevel@tonic-gate return (ddi_prop_lookup_common(match_dev, dip, 42847c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_STRING), name, data, 42857c478bd9Sstevel@tonic-gate &x, ddi_prop_fm_decode_string)); 42867c478bd9Sstevel@tonic-gate } 42877c478bd9Sstevel@tonic-gate 42887c478bd9Sstevel@tonic-gate /* 42897c478bd9Sstevel@tonic-gate * Get an array of strings property. 42907c478bd9Sstevel@tonic-gate */ 42917c478bd9Sstevel@tonic-gate int 42927c478bd9Sstevel@tonic-gate ddi_prop_lookup_string_array(dev_t match_dev, dev_info_t *dip, uint_t flags, 42937c478bd9Sstevel@tonic-gate char *name, char ***data, uint_t *nelements) 42947c478bd9Sstevel@tonic-gate { 42957c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 429665cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 42977c478bd9Sstevel@tonic-gate #ifdef DEBUG 42987c478bd9Sstevel@tonic-gate if (dip != NULL) { 42997c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_prop_lookup_string_array: " 43007c478bd9Sstevel@tonic-gate "invalid flag 0x%x (prop = %s, node = %s%d)", 43017c478bd9Sstevel@tonic-gate flags, name, ddi_driver_name(dip), 43027c478bd9Sstevel@tonic-gate ddi_get_instance(dip)); 43037c478bd9Sstevel@tonic-gate } 43047c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 43057c478bd9Sstevel@tonic-gate flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 43067c478bd9Sstevel@tonic-gate LDI_DEV_T_ANY | DDI_UNBND_DLPI2; 43077c478bd9Sstevel@tonic-gate } 43087c478bd9Sstevel@tonic-gate 43097c478bd9Sstevel@tonic-gate return (ddi_prop_lookup_common(match_dev, dip, 43107c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_STRING), name, data, 43117c478bd9Sstevel@tonic-gate nelements, ddi_prop_fm_decode_strings)); 43127c478bd9Sstevel@tonic-gate } 43137c478bd9Sstevel@tonic-gate 43147c478bd9Sstevel@tonic-gate /* 43157c478bd9Sstevel@tonic-gate * Update a single string property. 43167c478bd9Sstevel@tonic-gate */ 43177c478bd9Sstevel@tonic-gate int 43187c478bd9Sstevel@tonic-gate ddi_prop_update_string(dev_t match_dev, dev_info_t *dip, 43197c478bd9Sstevel@tonic-gate char *name, char *data) 43207c478bd9Sstevel@tonic-gate { 43217c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 43227c478bd9Sstevel@tonic-gate DDI_PROP_TYPE_STRING, name, &data, 1, 43237c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_string)); 43247c478bd9Sstevel@tonic-gate } 43257c478bd9Sstevel@tonic-gate 43267c478bd9Sstevel@tonic-gate int 43277c478bd9Sstevel@tonic-gate e_ddi_prop_update_string(dev_t match_dev, dev_info_t *dip, 43287c478bd9Sstevel@tonic-gate char *name, char *data) 43297c478bd9Sstevel@tonic-gate { 43307c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 43317c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_STRING, 43327c478bd9Sstevel@tonic-gate name, &data, 1, ddi_prop_fm_encode_string)); 43337c478bd9Sstevel@tonic-gate } 43347c478bd9Sstevel@tonic-gate 43357c478bd9Sstevel@tonic-gate 43367c478bd9Sstevel@tonic-gate /* 43377c478bd9Sstevel@tonic-gate * Update an array of strings property. 43387c478bd9Sstevel@tonic-gate */ 43397c478bd9Sstevel@tonic-gate int 43407c478bd9Sstevel@tonic-gate ddi_prop_update_string_array(dev_t match_dev, dev_info_t *dip, 43417c478bd9Sstevel@tonic-gate char *name, char **data, uint_t nelements) 43427c478bd9Sstevel@tonic-gate { 43437c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 43447c478bd9Sstevel@tonic-gate DDI_PROP_TYPE_STRING, name, data, nelements, 43457c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_strings)); 43467c478bd9Sstevel@tonic-gate } 43477c478bd9Sstevel@tonic-gate 43487c478bd9Sstevel@tonic-gate int 43497c478bd9Sstevel@tonic-gate e_ddi_prop_update_string_array(dev_t match_dev, dev_info_t *dip, 43507c478bd9Sstevel@tonic-gate char *name, char **data, uint_t nelements) 43517c478bd9Sstevel@tonic-gate { 43527c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 43537c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_STRING, 43547c478bd9Sstevel@tonic-gate name, data, nelements, 43557c478bd9Sstevel@tonic-gate ddi_prop_fm_encode_strings)); 43567c478bd9Sstevel@tonic-gate } 43577c478bd9Sstevel@tonic-gate 43587c478bd9Sstevel@tonic-gate 43597c478bd9Sstevel@tonic-gate /* 43607c478bd9Sstevel@tonic-gate * Get an array of bytes property. 43617c478bd9Sstevel@tonic-gate */ 43627c478bd9Sstevel@tonic-gate int 43637c478bd9Sstevel@tonic-gate ddi_prop_lookup_byte_array(dev_t match_dev, dev_info_t *dip, uint_t flags, 43647c478bd9Sstevel@tonic-gate char *name, uchar_t **data, uint_t *nelements) 43657c478bd9Sstevel@tonic-gate { 43667c478bd9Sstevel@tonic-gate if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 436765cf7c95SVikram Hegde LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) { 43687c478bd9Sstevel@tonic-gate #ifdef DEBUG 43697c478bd9Sstevel@tonic-gate if (dip != NULL) { 43707c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_prop_lookup_byte_array: " 43717c478bd9Sstevel@tonic-gate " invalid flag 0x%x (prop = %s, node = %s%d)", 43727c478bd9Sstevel@tonic-gate flags, name, ddi_driver_name(dip), 43737c478bd9Sstevel@tonic-gate ddi_get_instance(dip)); 43747c478bd9Sstevel@tonic-gate } 43757c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 43767c478bd9Sstevel@tonic-gate flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM | 43777c478bd9Sstevel@tonic-gate LDI_DEV_T_ANY | DDI_UNBND_DLPI2; 43787c478bd9Sstevel@tonic-gate } 43797c478bd9Sstevel@tonic-gate 43807c478bd9Sstevel@tonic-gate return (ddi_prop_lookup_common(match_dev, dip, 43817c478bd9Sstevel@tonic-gate (flags | DDI_PROP_TYPE_BYTE), name, data, 43827c478bd9Sstevel@tonic-gate nelements, ddi_prop_fm_decode_bytes)); 43837c478bd9Sstevel@tonic-gate } 43847c478bd9Sstevel@tonic-gate 43857c478bd9Sstevel@tonic-gate /* 43867c478bd9Sstevel@tonic-gate * Update an array of bytes property. 43877c478bd9Sstevel@tonic-gate */ 43887c478bd9Sstevel@tonic-gate int 43897c478bd9Sstevel@tonic-gate ddi_prop_update_byte_array(dev_t match_dev, dev_info_t *dip, 43907c478bd9Sstevel@tonic-gate char *name, uchar_t *data, uint_t nelements) 43917c478bd9Sstevel@tonic-gate { 43927c478bd9Sstevel@tonic-gate if (nelements == 0) 43937c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 43947c478bd9Sstevel@tonic-gate 43957c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_BYTE, 43967c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_encode_bytes)); 43977c478bd9Sstevel@tonic-gate } 43987c478bd9Sstevel@tonic-gate 43997c478bd9Sstevel@tonic-gate 44007c478bd9Sstevel@tonic-gate int 44017c478bd9Sstevel@tonic-gate e_ddi_prop_update_byte_array(dev_t match_dev, dev_info_t *dip, 44027c478bd9Sstevel@tonic-gate char *name, uchar_t *data, uint_t nelements) 44037c478bd9Sstevel@tonic-gate { 44047c478bd9Sstevel@tonic-gate if (nelements == 0) 44057c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 44067c478bd9Sstevel@tonic-gate 44077c478bd9Sstevel@tonic-gate return (ddi_prop_update_common(match_dev, dip, 44087c478bd9Sstevel@tonic-gate DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_BYTE, 44097c478bd9Sstevel@tonic-gate name, data, nelements, ddi_prop_fm_encode_bytes)); 44107c478bd9Sstevel@tonic-gate } 44117c478bd9Sstevel@tonic-gate 44127c478bd9Sstevel@tonic-gate 44137c478bd9Sstevel@tonic-gate /* 44147c478bd9Sstevel@tonic-gate * ddi_prop_remove_common: Undefine a managed property: 44157c478bd9Sstevel@tonic-gate * Input dev_t must match dev_t when defined. 44167c478bd9Sstevel@tonic-gate * Returns DDI_PROP_NOT_FOUND, possibly. 44177c478bd9Sstevel@tonic-gate * DDI_PROP_INVAL_ARG is also possible if dev is 44187c478bd9Sstevel@tonic-gate * DDI_DEV_T_ANY or incoming name is the NULL string. 44197c478bd9Sstevel@tonic-gate */ 44207c478bd9Sstevel@tonic-gate int 44217c478bd9Sstevel@tonic-gate ddi_prop_remove_common(dev_t dev, dev_info_t *dip, char *name, int flag) 44227c478bd9Sstevel@tonic-gate { 44237c478bd9Sstevel@tonic-gate ddi_prop_t **list_head = &(DEVI(dip)->devi_drv_prop_ptr); 44247c478bd9Sstevel@tonic-gate ddi_prop_t *propp; 44257c478bd9Sstevel@tonic-gate ddi_prop_t *lastpropp = NULL; 44267c478bd9Sstevel@tonic-gate 44277c478bd9Sstevel@tonic-gate if ((dev == DDI_DEV_T_ANY) || (name == (char *)0) || 44287c478bd9Sstevel@tonic-gate (strlen(name) == 0)) { 44297c478bd9Sstevel@tonic-gate return (DDI_PROP_INVAL_ARG); 44307c478bd9Sstevel@tonic-gate } 44317c478bd9Sstevel@tonic-gate 44327c478bd9Sstevel@tonic-gate if (flag & DDI_PROP_SYSTEM_DEF) 44337c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_sys_prop_ptr); 44347c478bd9Sstevel@tonic-gate else if (flag & DDI_PROP_HW_DEF) 44357c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_hw_prop_ptr); 44367c478bd9Sstevel@tonic-gate 44377c478bd9Sstevel@tonic-gate mutex_enter(&(DEVI(dip)->devi_lock)); 44387c478bd9Sstevel@tonic-gate 44397c478bd9Sstevel@tonic-gate for (propp = *list_head; propp != NULL; propp = propp->prop_next) { 44402cd7878fScth if (DDI_STRSAME(propp->prop_name, name) && 44417c478bd9Sstevel@tonic-gate (dev == propp->prop_dev)) { 44427c478bd9Sstevel@tonic-gate /* 44437c478bd9Sstevel@tonic-gate * Unlink this propp allowing for it to 44447c478bd9Sstevel@tonic-gate * be first in the list: 44457c478bd9Sstevel@tonic-gate */ 44467c478bd9Sstevel@tonic-gate 44477c478bd9Sstevel@tonic-gate if (lastpropp == NULL) 44487c478bd9Sstevel@tonic-gate *list_head = propp->prop_next; 44497c478bd9Sstevel@tonic-gate else 44507c478bd9Sstevel@tonic-gate lastpropp->prop_next = propp->prop_next; 44517c478bd9Sstevel@tonic-gate 44527c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 44537c478bd9Sstevel@tonic-gate 44547c478bd9Sstevel@tonic-gate /* 44557c478bd9Sstevel@tonic-gate * Free memory and return... 44567c478bd9Sstevel@tonic-gate */ 44577c478bd9Sstevel@tonic-gate kmem_free(propp->prop_name, 44587c478bd9Sstevel@tonic-gate strlen(propp->prop_name) + 1); 44597c478bd9Sstevel@tonic-gate if (propp->prop_len != 0) 44607c478bd9Sstevel@tonic-gate kmem_free(propp->prop_val, propp->prop_len); 44617c478bd9Sstevel@tonic-gate kmem_free(propp, sizeof (ddi_prop_t)); 44627c478bd9Sstevel@tonic-gate return (DDI_PROP_SUCCESS); 44637c478bd9Sstevel@tonic-gate } 44647c478bd9Sstevel@tonic-gate lastpropp = propp; 44657c478bd9Sstevel@tonic-gate } 44667c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 44677c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 44687c478bd9Sstevel@tonic-gate } 44697c478bd9Sstevel@tonic-gate 44707c478bd9Sstevel@tonic-gate int 44717c478bd9Sstevel@tonic-gate ddi_prop_remove(dev_t dev, dev_info_t *dip, char *name) 44727c478bd9Sstevel@tonic-gate { 44737c478bd9Sstevel@tonic-gate return (ddi_prop_remove_common(dev, dip, name, 0)); 44747c478bd9Sstevel@tonic-gate } 44757c478bd9Sstevel@tonic-gate 44767c478bd9Sstevel@tonic-gate int 44777c478bd9Sstevel@tonic-gate e_ddi_prop_remove(dev_t dev, dev_info_t *dip, char *name) 44787c478bd9Sstevel@tonic-gate { 44797c478bd9Sstevel@tonic-gate return (ddi_prop_remove_common(dev, dip, name, DDI_PROP_SYSTEM_DEF)); 44807c478bd9Sstevel@tonic-gate } 44817c478bd9Sstevel@tonic-gate 44827c478bd9Sstevel@tonic-gate /* 44837c478bd9Sstevel@tonic-gate * e_ddi_prop_list_delete: remove a list of properties 44847c478bd9Sstevel@tonic-gate * Note that the caller needs to provide the required protection 44857c478bd9Sstevel@tonic-gate * (eg. devi_lock if these properties are still attached to a devi) 44867c478bd9Sstevel@tonic-gate */ 44877c478bd9Sstevel@tonic-gate void 44887c478bd9Sstevel@tonic-gate e_ddi_prop_list_delete(ddi_prop_t *props) 44897c478bd9Sstevel@tonic-gate { 44907c478bd9Sstevel@tonic-gate i_ddi_prop_list_delete(props); 44917c478bd9Sstevel@tonic-gate } 44927c478bd9Sstevel@tonic-gate 44937c478bd9Sstevel@tonic-gate /* 44947c478bd9Sstevel@tonic-gate * ddi_prop_remove_all_common: 44957c478bd9Sstevel@tonic-gate * Used before unloading a driver to remove 44967c478bd9Sstevel@tonic-gate * all properties. (undefines all dev_t's props.) 44977c478bd9Sstevel@tonic-gate * Also removes `explicitly undefined' props. 44987c478bd9Sstevel@tonic-gate * No errors possible. 44997c478bd9Sstevel@tonic-gate */ 45007c478bd9Sstevel@tonic-gate void 45017c478bd9Sstevel@tonic-gate ddi_prop_remove_all_common(dev_info_t *dip, int flag) 45027c478bd9Sstevel@tonic-gate { 45037c478bd9Sstevel@tonic-gate ddi_prop_t **list_head; 45047c478bd9Sstevel@tonic-gate 45057c478bd9Sstevel@tonic-gate mutex_enter(&(DEVI(dip)->devi_lock)); 45067c478bd9Sstevel@tonic-gate if (flag & DDI_PROP_SYSTEM_DEF) { 45077c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_sys_prop_ptr); 45087c478bd9Sstevel@tonic-gate } else if (flag & DDI_PROP_HW_DEF) { 45097c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_hw_prop_ptr); 45107c478bd9Sstevel@tonic-gate } else { 45117c478bd9Sstevel@tonic-gate list_head = &(DEVI(dip)->devi_drv_prop_ptr); 45127c478bd9Sstevel@tonic-gate } 45137c478bd9Sstevel@tonic-gate i_ddi_prop_list_delete(*list_head); 45147c478bd9Sstevel@tonic-gate *list_head = NULL; 45157c478bd9Sstevel@tonic-gate mutex_exit(&(DEVI(dip)->devi_lock)); 45167c478bd9Sstevel@tonic-gate } 45177c478bd9Sstevel@tonic-gate 45187c478bd9Sstevel@tonic-gate 45197c478bd9Sstevel@tonic-gate /* 45207c478bd9Sstevel@tonic-gate * ddi_prop_remove_all: Remove all driver prop definitions. 45217c478bd9Sstevel@tonic-gate */ 45227c478bd9Sstevel@tonic-gate 45237c478bd9Sstevel@tonic-gate void 45247c478bd9Sstevel@tonic-gate ddi_prop_remove_all(dev_info_t *dip) 45257c478bd9Sstevel@tonic-gate { 4526b9ccdc5aScth i_ddi_prop_dyn_driver_set(dip, NULL); 45277c478bd9Sstevel@tonic-gate ddi_prop_remove_all_common(dip, 0); 45287c478bd9Sstevel@tonic-gate } 45297c478bd9Sstevel@tonic-gate 45307c478bd9Sstevel@tonic-gate /* 45317c478bd9Sstevel@tonic-gate * e_ddi_prop_remove_all: Remove all system prop definitions. 45327c478bd9Sstevel@tonic-gate */ 45337c478bd9Sstevel@tonic-gate 45347c478bd9Sstevel@tonic-gate void 45357c478bd9Sstevel@tonic-gate e_ddi_prop_remove_all(dev_info_t *dip) 45367c478bd9Sstevel@tonic-gate { 45377c478bd9Sstevel@tonic-gate ddi_prop_remove_all_common(dip, (int)DDI_PROP_SYSTEM_DEF); 45387c478bd9Sstevel@tonic-gate } 45397c478bd9Sstevel@tonic-gate 45407c478bd9Sstevel@tonic-gate 45417c478bd9Sstevel@tonic-gate /* 45427c478bd9Sstevel@tonic-gate * ddi_prop_undefine: Explicitly undefine a property. Property 45437c478bd9Sstevel@tonic-gate * searches which match this property return 45447c478bd9Sstevel@tonic-gate * the error code DDI_PROP_UNDEFINED. 45457c478bd9Sstevel@tonic-gate * 45467c478bd9Sstevel@tonic-gate * Use ddi_prop_remove to negate effect of 45477c478bd9Sstevel@tonic-gate * ddi_prop_undefine 45487c478bd9Sstevel@tonic-gate * 45497c478bd9Sstevel@tonic-gate * See above for error returns. 45507c478bd9Sstevel@tonic-gate */ 45517c478bd9Sstevel@tonic-gate 45527c478bd9Sstevel@tonic-gate int 45537c478bd9Sstevel@tonic-gate ddi_prop_undefine(dev_t dev, dev_info_t *dip, int flag, char *name) 45547c478bd9Sstevel@tonic-gate { 45557c478bd9Sstevel@tonic-gate if (!(flag & DDI_PROP_CANSLEEP)) 45567c478bd9Sstevel@tonic-gate flag |= DDI_PROP_DONTSLEEP; 4557b9ccdc5aScth flag |= DDI_PROP_STACK_CREATE | DDI_PROP_UNDEF_IT | DDI_PROP_TYPE_ANY; 4558b9ccdc5aScth return (ddi_prop_update_common(dev, dip, flag, 4559b9ccdc5aScth name, NULL, 0, ddi_prop_fm_encode_bytes)); 45607c478bd9Sstevel@tonic-gate } 45617c478bd9Sstevel@tonic-gate 45627c478bd9Sstevel@tonic-gate int 45637c478bd9Sstevel@tonic-gate e_ddi_prop_undefine(dev_t dev, dev_info_t *dip, int flag, char *name) 45647c478bd9Sstevel@tonic-gate { 45657c478bd9Sstevel@tonic-gate if (!(flag & DDI_PROP_CANSLEEP)) 45667c478bd9Sstevel@tonic-gate flag |= DDI_PROP_DONTSLEEP; 4567b9ccdc5aScth flag |= DDI_PROP_SYSTEM_DEF | DDI_PROP_STACK_CREATE | 4568b9ccdc5aScth DDI_PROP_UNDEF_IT | DDI_PROP_TYPE_ANY; 4569b9ccdc5aScth return (ddi_prop_update_common(dev, dip, flag, 45707c478bd9Sstevel@tonic-gate name, NULL, 0, ddi_prop_fm_encode_bytes)); 45717c478bd9Sstevel@tonic-gate } 45727c478bd9Sstevel@tonic-gate 4573b9ccdc5aScth /* 4574b9ccdc5aScth * Support for gathering dynamic properties in devinfo snapshot. 4575b9ccdc5aScth */ 4576b9ccdc5aScth void 4577b9ccdc5aScth i_ddi_prop_dyn_driver_set(dev_info_t *dip, i_ddi_prop_dyn_t *dp) 4578b9ccdc5aScth { 4579b9ccdc5aScth DEVI(dip)->devi_prop_dyn_driver = dp; 4580b9ccdc5aScth } 4581b9ccdc5aScth 4582b9ccdc5aScth i_ddi_prop_dyn_t * 4583b9ccdc5aScth i_ddi_prop_dyn_driver_get(dev_info_t *dip) 4584b9ccdc5aScth { 4585b9ccdc5aScth return (DEVI(dip)->devi_prop_dyn_driver); 4586b9ccdc5aScth } 4587b9ccdc5aScth 4588b9ccdc5aScth void 4589b9ccdc5aScth i_ddi_prop_dyn_parent_set(dev_info_t *dip, i_ddi_prop_dyn_t *dp) 4590b9ccdc5aScth { 4591b9ccdc5aScth DEVI(dip)->devi_prop_dyn_parent = dp; 4592b9ccdc5aScth } 4593b9ccdc5aScth 4594b9ccdc5aScth i_ddi_prop_dyn_t * 4595b9ccdc5aScth i_ddi_prop_dyn_parent_get(dev_info_t *dip) 4596b9ccdc5aScth { 4597b9ccdc5aScth return (DEVI(dip)->devi_prop_dyn_parent); 4598b9ccdc5aScth } 4599b9ccdc5aScth 4600b9ccdc5aScth void 4601b9ccdc5aScth i_ddi_prop_dyn_cache_invalidate(dev_info_t *dip, i_ddi_prop_dyn_t *dp) 4602b9ccdc5aScth { 4603b9ccdc5aScth /* for now we invalidate the entire cached snapshot */ 4604b9ccdc5aScth if (dip && dp) 46054c06356bSdh i_ddi_di_cache_invalidate(); 4606b9ccdc5aScth } 4607b9ccdc5aScth 4608b9ccdc5aScth /* ARGSUSED */ 4609b9ccdc5aScth void 4610b9ccdc5aScth ddi_prop_cache_invalidate(dev_t dev, dev_info_t *dip, char *name, int flags) 4611b9ccdc5aScth { 4612b9ccdc5aScth /* for now we invalidate the entire cached snapshot */ 46134c06356bSdh i_ddi_di_cache_invalidate(); 4614b9ccdc5aScth } 4615b9ccdc5aScth 4616b9ccdc5aScth 46177c478bd9Sstevel@tonic-gate /* 46187c478bd9Sstevel@tonic-gate * Code to search hardware layer (PROM), if it exists, on behalf of child. 46197c478bd9Sstevel@tonic-gate * 46207c478bd9Sstevel@tonic-gate * if input dip != child_dip, then call is on behalf of child 46217c478bd9Sstevel@tonic-gate * to search PROM, do it via ddi_prop_search_common() and ascend only 46227c478bd9Sstevel@tonic-gate * if allowed. 46237c478bd9Sstevel@tonic-gate * 46247c478bd9Sstevel@tonic-gate * if input dip == ch_dip (child_dip), call is on behalf of root driver, 46257c478bd9Sstevel@tonic-gate * to search for PROM defined props only. 46267c478bd9Sstevel@tonic-gate * 46277c478bd9Sstevel@tonic-gate * Note that the PROM search is done only if the requested dev 46287c478bd9Sstevel@tonic-gate * is either DDI_DEV_T_ANY or DDI_DEV_T_NONE. PROM properties 46297c478bd9Sstevel@tonic-gate * have no associated dev, thus are automatically associated with 46307c478bd9Sstevel@tonic-gate * DDI_DEV_T_NONE. 46317c478bd9Sstevel@tonic-gate * 46327c478bd9Sstevel@tonic-gate * Modifying flag DDI_PROP_NOTPROM inhibits the search in the h/w layer. 46337c478bd9Sstevel@tonic-gate * 46347c478bd9Sstevel@tonic-gate * Returns DDI_PROP_FOUND_1275 if found to indicate to framework 46357c478bd9Sstevel@tonic-gate * that the property resides in the prom. 46367c478bd9Sstevel@tonic-gate */ 46377c478bd9Sstevel@tonic-gate int 46387c478bd9Sstevel@tonic-gate impl_ddi_bus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip, 46397c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op, int mod_flags, 46407c478bd9Sstevel@tonic-gate char *name, caddr_t valuep, int *lengthp) 46417c478bd9Sstevel@tonic-gate { 46427c478bd9Sstevel@tonic-gate int len; 46437c478bd9Sstevel@tonic-gate caddr_t buffer; 46447c478bd9Sstevel@tonic-gate 46457c478bd9Sstevel@tonic-gate /* 46467c478bd9Sstevel@tonic-gate * If requested dev is DDI_DEV_T_NONE or DDI_DEV_T_ANY, then 46477c478bd9Sstevel@tonic-gate * look in caller's PROM if it's a self identifying device... 46487c478bd9Sstevel@tonic-gate * 46497c478bd9Sstevel@tonic-gate * Note that this is very similar to ddi_prop_op, but we 46507c478bd9Sstevel@tonic-gate * search the PROM instead of the s/w defined properties, 46517c478bd9Sstevel@tonic-gate * and we are called on by the parent driver to do this for 46527c478bd9Sstevel@tonic-gate * the child. 46537c478bd9Sstevel@tonic-gate */ 46547c478bd9Sstevel@tonic-gate 46557c478bd9Sstevel@tonic-gate if (((dev == DDI_DEV_T_NONE) || (dev == DDI_DEV_T_ANY)) && 46567c478bd9Sstevel@tonic-gate ndi_dev_is_prom_node(ch_dip) && 46577c478bd9Sstevel@tonic-gate ((mod_flags & DDI_PROP_NOTPROM) == 0)) { 4658fa9e4066Sahrens len = prom_getproplen((pnode_t)DEVI(ch_dip)->devi_nodeid, name); 46597c478bd9Sstevel@tonic-gate if (len == -1) { 46607c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 46617c478bd9Sstevel@tonic-gate } 46627c478bd9Sstevel@tonic-gate 46637c478bd9Sstevel@tonic-gate /* 46647c478bd9Sstevel@tonic-gate * If exists only request, we're done 46657c478bd9Sstevel@tonic-gate */ 46667c478bd9Sstevel@tonic-gate if (prop_op == PROP_EXISTS) { 46677c478bd9Sstevel@tonic-gate return (DDI_PROP_FOUND_1275); 46687c478bd9Sstevel@tonic-gate } 46697c478bd9Sstevel@tonic-gate 46707c478bd9Sstevel@tonic-gate /* 46717c478bd9Sstevel@tonic-gate * If length only request or prop length == 0, get out 46727c478bd9Sstevel@tonic-gate */ 46737c478bd9Sstevel@tonic-gate if ((prop_op == PROP_LEN) || (len == 0)) { 46747c478bd9Sstevel@tonic-gate *lengthp = len; 46757c478bd9Sstevel@tonic-gate return (DDI_PROP_FOUND_1275); 46767c478bd9Sstevel@tonic-gate } 46777c478bd9Sstevel@tonic-gate 46787c478bd9Sstevel@tonic-gate /* 46797c478bd9Sstevel@tonic-gate * Allocate buffer if required... (either way `buffer' 46807c478bd9Sstevel@tonic-gate * is receiving address). 46817c478bd9Sstevel@tonic-gate */ 46827c478bd9Sstevel@tonic-gate 46837c478bd9Sstevel@tonic-gate switch (prop_op) { 46847c478bd9Sstevel@tonic-gate 46857c478bd9Sstevel@tonic-gate case PROP_LEN_AND_VAL_ALLOC: 46867c478bd9Sstevel@tonic-gate 46877c478bd9Sstevel@tonic-gate buffer = kmem_alloc((size_t)len, 46887c478bd9Sstevel@tonic-gate mod_flags & DDI_PROP_CANSLEEP ? 46897c478bd9Sstevel@tonic-gate KM_SLEEP : KM_NOSLEEP); 46907c478bd9Sstevel@tonic-gate if (buffer == NULL) { 46917c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 46927c478bd9Sstevel@tonic-gate } 46937c478bd9Sstevel@tonic-gate *(caddr_t *)valuep = buffer; 46947c478bd9Sstevel@tonic-gate break; 46957c478bd9Sstevel@tonic-gate 46967c478bd9Sstevel@tonic-gate case PROP_LEN_AND_VAL_BUF: 46977c478bd9Sstevel@tonic-gate 46987c478bd9Sstevel@tonic-gate if (len > (*lengthp)) { 46997c478bd9Sstevel@tonic-gate *lengthp = len; 47007c478bd9Sstevel@tonic-gate return (DDI_PROP_BUF_TOO_SMALL); 47017c478bd9Sstevel@tonic-gate } 47027c478bd9Sstevel@tonic-gate 47037c478bd9Sstevel@tonic-gate buffer = valuep; 47047c478bd9Sstevel@tonic-gate break; 47057c478bd9Sstevel@tonic-gate 47067c478bd9Sstevel@tonic-gate default: 47077c478bd9Sstevel@tonic-gate break; 47087c478bd9Sstevel@tonic-gate } 47097c478bd9Sstevel@tonic-gate 47107c478bd9Sstevel@tonic-gate /* 47117c478bd9Sstevel@tonic-gate * Call the PROM function to do the copy. 47127c478bd9Sstevel@tonic-gate */ 4713fa9e4066Sahrens (void) prom_getprop((pnode_t)DEVI(ch_dip)->devi_nodeid, 4714184cd04cScth name, buffer); 47157c478bd9Sstevel@tonic-gate 47167c478bd9Sstevel@tonic-gate *lengthp = len; /* return the actual length to the caller */ 47177c478bd9Sstevel@tonic-gate (void) impl_fix_props(dip, ch_dip, name, len, buffer); 47187c478bd9Sstevel@tonic-gate return (DDI_PROP_FOUND_1275); 47197c478bd9Sstevel@tonic-gate } 47207c478bd9Sstevel@tonic-gate 47217c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 47227c478bd9Sstevel@tonic-gate } 47237c478bd9Sstevel@tonic-gate 47247c478bd9Sstevel@tonic-gate /* 47257c478bd9Sstevel@tonic-gate * The ddi_bus_prop_op default bus nexus prop op function. 47267c478bd9Sstevel@tonic-gate * 47277c478bd9Sstevel@tonic-gate * Code to search hardware layer (PROM), if it exists, 47287c478bd9Sstevel@tonic-gate * on behalf of child, then, if appropriate, ascend and check 47297c478bd9Sstevel@tonic-gate * my own software defined properties... 47307c478bd9Sstevel@tonic-gate */ 47317c478bd9Sstevel@tonic-gate int 47327c478bd9Sstevel@tonic-gate ddi_bus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip, 47337c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op, int mod_flags, 47347c478bd9Sstevel@tonic-gate char *name, caddr_t valuep, int *lengthp) 47357c478bd9Sstevel@tonic-gate { 47367c478bd9Sstevel@tonic-gate int error; 47377c478bd9Sstevel@tonic-gate 47387c478bd9Sstevel@tonic-gate error = impl_ddi_bus_prop_op(dev, dip, ch_dip, prop_op, mod_flags, 4739184cd04cScth name, valuep, lengthp); 47407c478bd9Sstevel@tonic-gate 47417c478bd9Sstevel@tonic-gate if (error == DDI_PROP_SUCCESS || error == DDI_PROP_FOUND_1275 || 47427c478bd9Sstevel@tonic-gate error == DDI_PROP_BUF_TOO_SMALL) 47437c478bd9Sstevel@tonic-gate return (error); 47447c478bd9Sstevel@tonic-gate 47457c478bd9Sstevel@tonic-gate if (error == DDI_PROP_NO_MEMORY) { 47467c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, prop_no_mem_msg, name); 47477c478bd9Sstevel@tonic-gate return (DDI_PROP_NO_MEMORY); 47487c478bd9Sstevel@tonic-gate } 47497c478bd9Sstevel@tonic-gate 47507c478bd9Sstevel@tonic-gate /* 47517c478bd9Sstevel@tonic-gate * Check the 'options' node as a last resort 47527c478bd9Sstevel@tonic-gate */ 47537c478bd9Sstevel@tonic-gate if ((mod_flags & DDI_PROP_DONTPASS) != 0) 47547c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 47557c478bd9Sstevel@tonic-gate 47567c478bd9Sstevel@tonic-gate if (ch_dip == ddi_root_node()) { 47577c478bd9Sstevel@tonic-gate /* 47587c478bd9Sstevel@tonic-gate * As a last resort, when we've reached 47597c478bd9Sstevel@tonic-gate * the top and still haven't found the 47607c478bd9Sstevel@tonic-gate * property, see if the desired property 47617c478bd9Sstevel@tonic-gate * is attached to the options node. 47627c478bd9Sstevel@tonic-gate * 47637c478bd9Sstevel@tonic-gate * The options dip is attached right after boot. 47647c478bd9Sstevel@tonic-gate */ 47657c478bd9Sstevel@tonic-gate ASSERT(options_dip != NULL); 47667c478bd9Sstevel@tonic-gate /* 47677c478bd9Sstevel@tonic-gate * Force the "don't pass" flag to *just* see 47687c478bd9Sstevel@tonic-gate * what the options node has to offer. 47697c478bd9Sstevel@tonic-gate */ 47707c478bd9Sstevel@tonic-gate return (ddi_prop_search_common(dev, options_dip, prop_op, 47717c478bd9Sstevel@tonic-gate mod_flags|DDI_PROP_DONTPASS, name, valuep, 47727c478bd9Sstevel@tonic-gate (uint_t *)lengthp)); 47737c478bd9Sstevel@tonic-gate } 47747c478bd9Sstevel@tonic-gate 47757c478bd9Sstevel@tonic-gate /* 47767c478bd9Sstevel@tonic-gate * Otherwise, continue search with parent's s/w defined properties... 47777c478bd9Sstevel@tonic-gate * NOTE: Using `dip' in following call increments the level. 47787c478bd9Sstevel@tonic-gate */ 47797c478bd9Sstevel@tonic-gate 47807c478bd9Sstevel@tonic-gate return (ddi_prop_search_common(dev, dip, prop_op, mod_flags, 47817c478bd9Sstevel@tonic-gate name, valuep, (uint_t *)lengthp)); 47827c478bd9Sstevel@tonic-gate } 47837c478bd9Sstevel@tonic-gate 47847c478bd9Sstevel@tonic-gate /* 47857c478bd9Sstevel@tonic-gate * External property functions used by other parts of the kernel... 47867c478bd9Sstevel@tonic-gate */ 47877c478bd9Sstevel@tonic-gate 47887c478bd9Sstevel@tonic-gate /* 47897c478bd9Sstevel@tonic-gate * e_ddi_getlongprop: See comments for ddi_get_longprop. 47907c478bd9Sstevel@tonic-gate */ 47917c478bd9Sstevel@tonic-gate 47927c478bd9Sstevel@tonic-gate int 47937c478bd9Sstevel@tonic-gate e_ddi_getlongprop(dev_t dev, vtype_t type, char *name, int flags, 47947c478bd9Sstevel@tonic-gate caddr_t valuep, int *lengthp) 47957c478bd9Sstevel@tonic-gate { 47967c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(type)) 47977c478bd9Sstevel@tonic-gate dev_info_t *devi; 47987c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_ALLOC; 47997c478bd9Sstevel@tonic-gate int error; 48007c478bd9Sstevel@tonic-gate 48017c478bd9Sstevel@tonic-gate if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 48027c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 48037c478bd9Sstevel@tonic-gate 48047c478bd9Sstevel@tonic-gate error = cdev_prop_op(dev, devi, prop_op, flags, name, valuep, lengthp); 48057c478bd9Sstevel@tonic-gate ddi_release_devi(devi); 48067c478bd9Sstevel@tonic-gate return (error); 48077c478bd9Sstevel@tonic-gate } 48087c478bd9Sstevel@tonic-gate 48097c478bd9Sstevel@tonic-gate /* 48107c478bd9Sstevel@tonic-gate * e_ddi_getlongprop_buf: See comments for ddi_getlongprop_buf. 48117c478bd9Sstevel@tonic-gate */ 48127c478bd9Sstevel@tonic-gate 48137c478bd9Sstevel@tonic-gate int 48147c478bd9Sstevel@tonic-gate e_ddi_getlongprop_buf(dev_t dev, vtype_t type, char *name, int flags, 48157c478bd9Sstevel@tonic-gate caddr_t valuep, int *lengthp) 48167c478bd9Sstevel@tonic-gate { 48177c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(type)) 48187c478bd9Sstevel@tonic-gate dev_info_t *devi; 48197c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_BUF; 48207c478bd9Sstevel@tonic-gate int error; 48217c478bd9Sstevel@tonic-gate 48227c478bd9Sstevel@tonic-gate if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 48237c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 48247c478bd9Sstevel@tonic-gate 48257c478bd9Sstevel@tonic-gate error = cdev_prop_op(dev, devi, prop_op, flags, name, valuep, lengthp); 48267c478bd9Sstevel@tonic-gate ddi_release_devi(devi); 48277c478bd9Sstevel@tonic-gate return (error); 48287c478bd9Sstevel@tonic-gate } 48297c478bd9Sstevel@tonic-gate 48307c478bd9Sstevel@tonic-gate /* 48317c478bd9Sstevel@tonic-gate * e_ddi_getprop: See comments for ddi_getprop. 48327c478bd9Sstevel@tonic-gate */ 48337c478bd9Sstevel@tonic-gate int 48347c478bd9Sstevel@tonic-gate e_ddi_getprop(dev_t dev, vtype_t type, char *name, int flags, int defvalue) 48357c478bd9Sstevel@tonic-gate { 48367c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(type)) 48377c478bd9Sstevel@tonic-gate dev_info_t *devi; 48387c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_BUF; 48397c478bd9Sstevel@tonic-gate int propvalue = defvalue; 48407c478bd9Sstevel@tonic-gate int proplength = sizeof (int); 48417c478bd9Sstevel@tonic-gate int error; 48427c478bd9Sstevel@tonic-gate 48437c478bd9Sstevel@tonic-gate if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 48447c478bd9Sstevel@tonic-gate return (defvalue); 48457c478bd9Sstevel@tonic-gate 48467c478bd9Sstevel@tonic-gate error = cdev_prop_op(dev, devi, prop_op, 48477c478bd9Sstevel@tonic-gate flags, name, (caddr_t)&propvalue, &proplength); 48487c478bd9Sstevel@tonic-gate ddi_release_devi(devi); 48497c478bd9Sstevel@tonic-gate 48507c478bd9Sstevel@tonic-gate if ((error == DDI_PROP_SUCCESS) && (proplength == 0)) 48517c478bd9Sstevel@tonic-gate propvalue = 1; 48527c478bd9Sstevel@tonic-gate 48537c478bd9Sstevel@tonic-gate return (propvalue); 48547c478bd9Sstevel@tonic-gate } 48557c478bd9Sstevel@tonic-gate 48567c478bd9Sstevel@tonic-gate /* 48577c478bd9Sstevel@tonic-gate * e_ddi_getprop_int64: 48587c478bd9Sstevel@tonic-gate * 48597c478bd9Sstevel@tonic-gate * This is a typed interfaces, but predates typed properties. With the 48607c478bd9Sstevel@tonic-gate * introduction of typed properties the framework tries to ensure 48617c478bd9Sstevel@tonic-gate * consistent use of typed interfaces. This is why TYPE_INT64 is not 48627c478bd9Sstevel@tonic-gate * part of TYPE_ANY. E_ddi_getprop_int64 is a special case where a 48637c478bd9Sstevel@tonic-gate * typed interface invokes legacy (non-typed) interfaces: 48647c478bd9Sstevel@tonic-gate * cdev_prop_op(), prop_op(9E), ddi_prop_op(9F)). In this case the 48657c478bd9Sstevel@tonic-gate * fact that TYPE_INT64 is not part of TYPE_ANY matters. To support 48667c478bd9Sstevel@tonic-gate * this type of lookup as a single operation we invoke the legacy 48677c478bd9Sstevel@tonic-gate * non-typed interfaces with the special CONSUMER_TYPED bit set. The 48687c478bd9Sstevel@tonic-gate * framework ddi_prop_op(9F) implementation is expected to check for 48697c478bd9Sstevel@tonic-gate * CONSUMER_TYPED and, if set, expand type bits beyond TYPE_ANY 48707c478bd9Sstevel@tonic-gate * (currently TYPE_INT64). 48717c478bd9Sstevel@tonic-gate */ 48727c478bd9Sstevel@tonic-gate int64_t 48737c478bd9Sstevel@tonic-gate e_ddi_getprop_int64(dev_t dev, vtype_t type, char *name, 48747c478bd9Sstevel@tonic-gate int flags, int64_t defvalue) 48757c478bd9Sstevel@tonic-gate { 48767c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(type)) 48777c478bd9Sstevel@tonic-gate dev_info_t *devi; 48787c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_BUF; 48797c478bd9Sstevel@tonic-gate int64_t propvalue = defvalue; 48807c478bd9Sstevel@tonic-gate int proplength = sizeof (propvalue); 48817c478bd9Sstevel@tonic-gate int error; 48827c478bd9Sstevel@tonic-gate 48837c478bd9Sstevel@tonic-gate if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 48847c478bd9Sstevel@tonic-gate return (defvalue); 48857c478bd9Sstevel@tonic-gate 48867c478bd9Sstevel@tonic-gate error = cdev_prop_op(dev, devi, prop_op, flags | 48877c478bd9Sstevel@tonic-gate DDI_PROP_CONSUMER_TYPED, name, (caddr_t)&propvalue, &proplength); 48887c478bd9Sstevel@tonic-gate ddi_release_devi(devi); 48897c478bd9Sstevel@tonic-gate 48907c478bd9Sstevel@tonic-gate if ((error == DDI_PROP_SUCCESS) && (proplength == 0)) 48917c478bd9Sstevel@tonic-gate propvalue = 1; 48927c478bd9Sstevel@tonic-gate 48937c478bd9Sstevel@tonic-gate return (propvalue); 48947c478bd9Sstevel@tonic-gate } 48957c478bd9Sstevel@tonic-gate 48967c478bd9Sstevel@tonic-gate /* 48977c478bd9Sstevel@tonic-gate * e_ddi_getproplen: See comments for ddi_getproplen. 48987c478bd9Sstevel@tonic-gate */ 48997c478bd9Sstevel@tonic-gate int 49007c478bd9Sstevel@tonic-gate e_ddi_getproplen(dev_t dev, vtype_t type, char *name, int flags, int *lengthp) 49017c478bd9Sstevel@tonic-gate { 49027c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(type)) 49037c478bd9Sstevel@tonic-gate dev_info_t *devi; 49047c478bd9Sstevel@tonic-gate ddi_prop_op_t prop_op = PROP_LEN; 49057c478bd9Sstevel@tonic-gate int error; 49067c478bd9Sstevel@tonic-gate 49077c478bd9Sstevel@tonic-gate if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 49087c478bd9Sstevel@tonic-gate return (DDI_PROP_NOT_FOUND); 49097c478bd9Sstevel@tonic-gate 49107c478bd9Sstevel@tonic-gate error = cdev_prop_op(dev, devi, prop_op, flags, name, NULL, lengthp); 49117c478bd9Sstevel@tonic-gate ddi_release_devi(devi); 49127c478bd9Sstevel@tonic-gate return (error); 49137c478bd9Sstevel@tonic-gate } 49147c478bd9Sstevel@tonic-gate 49157c478bd9Sstevel@tonic-gate /* 49167c478bd9Sstevel@tonic-gate * Routines to get at elements of the dev_info structure 49177c478bd9Sstevel@tonic-gate */ 49187c478bd9Sstevel@tonic-gate 49197c478bd9Sstevel@tonic-gate /* 49207c478bd9Sstevel@tonic-gate * ddi_binding_name: Return the driver binding name of the devinfo node 49217c478bd9Sstevel@tonic-gate * This is the name the OS used to bind the node to a driver. 49227c478bd9Sstevel@tonic-gate */ 49237c478bd9Sstevel@tonic-gate char * 49247c478bd9Sstevel@tonic-gate ddi_binding_name(dev_info_t *dip) 49257c478bd9Sstevel@tonic-gate { 49267c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_binding_name); 49277c478bd9Sstevel@tonic-gate } 49287c478bd9Sstevel@tonic-gate 49297c478bd9Sstevel@tonic-gate /* 49307c478bd9Sstevel@tonic-gate * ddi_driver_major: Return the major number of the driver that 49315c066ec2SJerry Gilliam * the supplied devinfo is bound to. If not yet bound, 49325c066ec2SJerry Gilliam * DDI_MAJOR_T_NONE. 49335c066ec2SJerry Gilliam * 49345c066ec2SJerry Gilliam * When used by the driver bound to 'devi', this 49355c066ec2SJerry Gilliam * function will reliably return the driver major number. 49365c066ec2SJerry Gilliam * Other ways of determining the driver major number, such as 49375c066ec2SJerry Gilliam * major = ddi_name_to_major(ddi_get_name(devi)); 49385c066ec2SJerry Gilliam * major = ddi_name_to_major(ddi_binding_name(devi)); 49395c066ec2SJerry Gilliam * can return a different result as the driver/alias binding 49405c066ec2SJerry Gilliam * can change dynamically, and thus should be avoided. 49417c478bd9Sstevel@tonic-gate */ 49427c478bd9Sstevel@tonic-gate major_t 49437c478bd9Sstevel@tonic-gate ddi_driver_major(dev_info_t *devi) 49447c478bd9Sstevel@tonic-gate { 49457c478bd9Sstevel@tonic-gate return (DEVI(devi)->devi_major); 49467c478bd9Sstevel@tonic-gate } 49477c478bd9Sstevel@tonic-gate 49487c478bd9Sstevel@tonic-gate /* 49497c478bd9Sstevel@tonic-gate * ddi_driver_name: Return the normalized driver name. this is the 49507c478bd9Sstevel@tonic-gate * actual driver name 49517c478bd9Sstevel@tonic-gate */ 49527c478bd9Sstevel@tonic-gate const char * 49537c478bd9Sstevel@tonic-gate ddi_driver_name(dev_info_t *devi) 49547c478bd9Sstevel@tonic-gate { 49557c478bd9Sstevel@tonic-gate major_t major; 49567c478bd9Sstevel@tonic-gate 4957a204de77Scth if ((major = ddi_driver_major(devi)) != DDI_MAJOR_T_NONE) 49587c478bd9Sstevel@tonic-gate return (ddi_major_to_name(major)); 49597c478bd9Sstevel@tonic-gate 49607c478bd9Sstevel@tonic-gate return (ddi_node_name(devi)); 49617c478bd9Sstevel@tonic-gate } 49627c478bd9Sstevel@tonic-gate 49637c478bd9Sstevel@tonic-gate /* 49647c478bd9Sstevel@tonic-gate * i_ddi_set_binding_name: Set binding name. 49657c478bd9Sstevel@tonic-gate * 49667c478bd9Sstevel@tonic-gate * Set the binding name to the given name. 49677c478bd9Sstevel@tonic-gate * This routine is for use by the ddi implementation, not by drivers. 49687c478bd9Sstevel@tonic-gate */ 49697c478bd9Sstevel@tonic-gate void 49707c478bd9Sstevel@tonic-gate i_ddi_set_binding_name(dev_info_t *dip, char *name) 49717c478bd9Sstevel@tonic-gate { 49727c478bd9Sstevel@tonic-gate DEVI(dip)->devi_binding_name = name; 49737c478bd9Sstevel@tonic-gate 49747c478bd9Sstevel@tonic-gate } 49757c478bd9Sstevel@tonic-gate 49767c478bd9Sstevel@tonic-gate /* 49777c478bd9Sstevel@tonic-gate * ddi_get_name: A synonym of ddi_binding_name() ... returns a name 49787c478bd9Sstevel@tonic-gate * the implementation has used to bind the node to a driver. 49797c478bd9Sstevel@tonic-gate */ 49807c478bd9Sstevel@tonic-gate char * 49817c478bd9Sstevel@tonic-gate ddi_get_name(dev_info_t *dip) 49827c478bd9Sstevel@tonic-gate { 49837c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_binding_name); 49847c478bd9Sstevel@tonic-gate } 49857c478bd9Sstevel@tonic-gate 49867c478bd9Sstevel@tonic-gate /* 49877c478bd9Sstevel@tonic-gate * ddi_node_name: Return the name property of the devinfo node 49887c478bd9Sstevel@tonic-gate * This may differ from ddi_binding_name if the node name 49897c478bd9Sstevel@tonic-gate * does not define a binding to a driver (i.e. generic names). 49907c478bd9Sstevel@tonic-gate */ 49917c478bd9Sstevel@tonic-gate char * 49927c478bd9Sstevel@tonic-gate ddi_node_name(dev_info_t *dip) 49937c478bd9Sstevel@tonic-gate { 49947c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_node_name); 49957c478bd9Sstevel@tonic-gate } 49967c478bd9Sstevel@tonic-gate 49977c478bd9Sstevel@tonic-gate 49987c478bd9Sstevel@tonic-gate /* 49997c478bd9Sstevel@tonic-gate * ddi_get_nodeid: Get nodeid stored in dev_info structure. 50007c478bd9Sstevel@tonic-gate */ 50017c478bd9Sstevel@tonic-gate int 50027c478bd9Sstevel@tonic-gate ddi_get_nodeid(dev_info_t *dip) 50037c478bd9Sstevel@tonic-gate { 50047c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_nodeid); 50057c478bd9Sstevel@tonic-gate } 50067c478bd9Sstevel@tonic-gate 50077c478bd9Sstevel@tonic-gate int 50087c478bd9Sstevel@tonic-gate ddi_get_instance(dev_info_t *dip) 50097c478bd9Sstevel@tonic-gate { 50107c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_instance); 50117c478bd9Sstevel@tonic-gate } 50127c478bd9Sstevel@tonic-gate 50137c478bd9Sstevel@tonic-gate struct dev_ops * 50147c478bd9Sstevel@tonic-gate ddi_get_driver(dev_info_t *dip) 50157c478bd9Sstevel@tonic-gate { 50167c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_ops); 50177c478bd9Sstevel@tonic-gate } 50187c478bd9Sstevel@tonic-gate 50197c478bd9Sstevel@tonic-gate void 50207c478bd9Sstevel@tonic-gate ddi_set_driver(dev_info_t *dip, struct dev_ops *devo) 50217c478bd9Sstevel@tonic-gate { 50227c478bd9Sstevel@tonic-gate DEVI(dip)->devi_ops = devo; 50237c478bd9Sstevel@tonic-gate } 50247c478bd9Sstevel@tonic-gate 50257c478bd9Sstevel@tonic-gate /* 50267c478bd9Sstevel@tonic-gate * ddi_set_driver_private/ddi_get_driver_private: 50277c478bd9Sstevel@tonic-gate * Get/set device driver private data in devinfo. 50287c478bd9Sstevel@tonic-gate */ 50297c478bd9Sstevel@tonic-gate void 50307c478bd9Sstevel@tonic-gate ddi_set_driver_private(dev_info_t *dip, void *data) 50317c478bd9Sstevel@tonic-gate { 50327c478bd9Sstevel@tonic-gate DEVI(dip)->devi_driver_data = data; 50337c478bd9Sstevel@tonic-gate } 50347c478bd9Sstevel@tonic-gate 50357c478bd9Sstevel@tonic-gate void * 50367c478bd9Sstevel@tonic-gate ddi_get_driver_private(dev_info_t *dip) 50377c478bd9Sstevel@tonic-gate { 50387c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_driver_data); 50397c478bd9Sstevel@tonic-gate } 50407c478bd9Sstevel@tonic-gate 50417c478bd9Sstevel@tonic-gate /* 50427c478bd9Sstevel@tonic-gate * ddi_get_parent, ddi_get_child, ddi_get_next_sibling 50437c478bd9Sstevel@tonic-gate */ 50447c478bd9Sstevel@tonic-gate 50457c478bd9Sstevel@tonic-gate dev_info_t * 50467c478bd9Sstevel@tonic-gate ddi_get_parent(dev_info_t *dip) 50477c478bd9Sstevel@tonic-gate { 50487c478bd9Sstevel@tonic-gate return ((dev_info_t *)DEVI(dip)->devi_parent); 50497c478bd9Sstevel@tonic-gate } 50507c478bd9Sstevel@tonic-gate 50517c478bd9Sstevel@tonic-gate dev_info_t * 50527c478bd9Sstevel@tonic-gate ddi_get_child(dev_info_t *dip) 50537c478bd9Sstevel@tonic-gate { 50547c478bd9Sstevel@tonic-gate return ((dev_info_t *)DEVI(dip)->devi_child); 50557c478bd9Sstevel@tonic-gate } 50567c478bd9Sstevel@tonic-gate 50577c478bd9Sstevel@tonic-gate dev_info_t * 50587c478bd9Sstevel@tonic-gate ddi_get_next_sibling(dev_info_t *dip) 50597c478bd9Sstevel@tonic-gate { 50607c478bd9Sstevel@tonic-gate return ((dev_info_t *)DEVI(dip)->devi_sibling); 50617c478bd9Sstevel@tonic-gate } 50627c478bd9Sstevel@tonic-gate 50637c478bd9Sstevel@tonic-gate dev_info_t * 50647c478bd9Sstevel@tonic-gate ddi_get_next(dev_info_t *dip) 50657c478bd9Sstevel@tonic-gate { 50667c478bd9Sstevel@tonic-gate return ((dev_info_t *)DEVI(dip)->devi_next); 50677c478bd9Sstevel@tonic-gate } 50687c478bd9Sstevel@tonic-gate 50697c478bd9Sstevel@tonic-gate void 50707c478bd9Sstevel@tonic-gate ddi_set_next(dev_info_t *dip, dev_info_t *nextdip) 50717c478bd9Sstevel@tonic-gate { 50727c478bd9Sstevel@tonic-gate DEVI(dip)->devi_next = DEVI(nextdip); 50737c478bd9Sstevel@tonic-gate } 50747c478bd9Sstevel@tonic-gate 50757c478bd9Sstevel@tonic-gate /* 50767c478bd9Sstevel@tonic-gate * ddi_root_node: Return root node of devinfo tree 50777c478bd9Sstevel@tonic-gate */ 50787c478bd9Sstevel@tonic-gate 50797c478bd9Sstevel@tonic-gate dev_info_t * 50807c478bd9Sstevel@tonic-gate ddi_root_node(void) 50817c478bd9Sstevel@tonic-gate { 50827c478bd9Sstevel@tonic-gate extern dev_info_t *top_devinfo; 50837c478bd9Sstevel@tonic-gate 50847c478bd9Sstevel@tonic-gate return (top_devinfo); 50857c478bd9Sstevel@tonic-gate } 50867c478bd9Sstevel@tonic-gate 50877c478bd9Sstevel@tonic-gate /* 50887c478bd9Sstevel@tonic-gate * Miscellaneous functions: 50897c478bd9Sstevel@tonic-gate */ 50907c478bd9Sstevel@tonic-gate 50917c478bd9Sstevel@tonic-gate /* 50927c478bd9Sstevel@tonic-gate * Implementation specific hooks 50937c478bd9Sstevel@tonic-gate */ 50947c478bd9Sstevel@tonic-gate 50957c478bd9Sstevel@tonic-gate void 50967c478bd9Sstevel@tonic-gate ddi_report_dev(dev_info_t *d) 50977c478bd9Sstevel@tonic-gate { 50987c478bd9Sstevel@tonic-gate char *b; 50997c478bd9Sstevel@tonic-gate 51007c478bd9Sstevel@tonic-gate (void) ddi_ctlops(d, d, DDI_CTLOPS_REPORTDEV, (void *)0, (void *)0); 51017c478bd9Sstevel@tonic-gate 51027c478bd9Sstevel@tonic-gate /* 51037c478bd9Sstevel@tonic-gate * If this devinfo node has cb_ops, it's implicitly accessible from 51047c478bd9Sstevel@tonic-gate * userland, so we print its full name together with the instance 51057c478bd9Sstevel@tonic-gate * number 'abbreviation' that the driver may use internally. 51067c478bd9Sstevel@tonic-gate */ 51077c478bd9Sstevel@tonic-gate if (DEVI(d)->devi_ops->devo_cb_ops != (struct cb_ops *)0 && 51087c478bd9Sstevel@tonic-gate (b = kmem_zalloc(MAXPATHLEN, KM_NOSLEEP))) { 51097c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "?%s%d is %s\n", 51107c478bd9Sstevel@tonic-gate ddi_driver_name(d), ddi_get_instance(d), 51117c478bd9Sstevel@tonic-gate ddi_pathname(d, b)); 51127c478bd9Sstevel@tonic-gate kmem_free(b, MAXPATHLEN); 51137c478bd9Sstevel@tonic-gate } 51147c478bd9Sstevel@tonic-gate } 51157c478bd9Sstevel@tonic-gate 51167c478bd9Sstevel@tonic-gate /* 51177c478bd9Sstevel@tonic-gate * ddi_ctlops() is described in the assembler not to buy a new register 51187c478bd9Sstevel@tonic-gate * window when it's called and can reduce cost in climbing the device tree 51197c478bd9Sstevel@tonic-gate * without using the tail call optimization. 51207c478bd9Sstevel@tonic-gate */ 51217c478bd9Sstevel@tonic-gate int 51227c478bd9Sstevel@tonic-gate ddi_dev_regsize(dev_info_t *dev, uint_t rnumber, off_t *result) 51237c478bd9Sstevel@tonic-gate { 51247c478bd9Sstevel@tonic-gate int ret; 51257c478bd9Sstevel@tonic-gate 51267c478bd9Sstevel@tonic-gate ret = ddi_ctlops(dev, dev, DDI_CTLOPS_REGSIZE, 51277c478bd9Sstevel@tonic-gate (void *)&rnumber, (void *)result); 51287c478bd9Sstevel@tonic-gate 51297c478bd9Sstevel@tonic-gate return (ret == DDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE); 51307c478bd9Sstevel@tonic-gate } 51317c478bd9Sstevel@tonic-gate 51327c478bd9Sstevel@tonic-gate int 51337c478bd9Sstevel@tonic-gate ddi_dev_nregs(dev_info_t *dev, int *result) 51347c478bd9Sstevel@tonic-gate { 51357c478bd9Sstevel@tonic-gate return (ddi_ctlops(dev, dev, DDI_CTLOPS_NREGS, 0, (void *)result)); 51367c478bd9Sstevel@tonic-gate } 51377c478bd9Sstevel@tonic-gate 51387c478bd9Sstevel@tonic-gate int 51397c478bd9Sstevel@tonic-gate ddi_dev_is_sid(dev_info_t *d) 51407c478bd9Sstevel@tonic-gate { 51417c478bd9Sstevel@tonic-gate return (ddi_ctlops(d, d, DDI_CTLOPS_SIDDEV, (void *)0, (void *)0)); 51427c478bd9Sstevel@tonic-gate } 51437c478bd9Sstevel@tonic-gate 51447c478bd9Sstevel@tonic-gate int 51457c478bd9Sstevel@tonic-gate ddi_slaveonly(dev_info_t *d) 51467c478bd9Sstevel@tonic-gate { 51477c478bd9Sstevel@tonic-gate return (ddi_ctlops(d, d, DDI_CTLOPS_SLAVEONLY, (void *)0, (void *)0)); 51487c478bd9Sstevel@tonic-gate } 51497c478bd9Sstevel@tonic-gate 51507c478bd9Sstevel@tonic-gate int 51517c478bd9Sstevel@tonic-gate ddi_dev_affinity(dev_info_t *a, dev_info_t *b) 51527c478bd9Sstevel@tonic-gate { 51537c478bd9Sstevel@tonic-gate return (ddi_ctlops(a, a, DDI_CTLOPS_AFFINITY, (void *)b, (void *)0)); 51547c478bd9Sstevel@tonic-gate } 51557c478bd9Sstevel@tonic-gate 51567c478bd9Sstevel@tonic-gate int 51577c478bd9Sstevel@tonic-gate ddi_streams_driver(dev_info_t *dip) 51587c478bd9Sstevel@tonic-gate { 5159737d277aScth if (i_ddi_devi_attached(dip) && 51607c478bd9Sstevel@tonic-gate (DEVI(dip)->devi_ops->devo_cb_ops != NULL) && 51617c478bd9Sstevel@tonic-gate (DEVI(dip)->devi_ops->devo_cb_ops->cb_str != NULL)) 51627c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 51637c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 51647c478bd9Sstevel@tonic-gate } 51657c478bd9Sstevel@tonic-gate 51667c478bd9Sstevel@tonic-gate /* 51677c478bd9Sstevel@tonic-gate * callback free list 51687c478bd9Sstevel@tonic-gate */ 51697c478bd9Sstevel@tonic-gate 51707c478bd9Sstevel@tonic-gate static int ncallbacks; 51717c478bd9Sstevel@tonic-gate static int nc_low = 170; 51727c478bd9Sstevel@tonic-gate static int nc_med = 512; 51737c478bd9Sstevel@tonic-gate static int nc_high = 2048; 51747c478bd9Sstevel@tonic-gate static struct ddi_callback *callbackq; 51757c478bd9Sstevel@tonic-gate static struct ddi_callback *callbackqfree; 51767c478bd9Sstevel@tonic-gate 51777c478bd9Sstevel@tonic-gate /* 51787c478bd9Sstevel@tonic-gate * set/run callback lists 51797c478bd9Sstevel@tonic-gate */ 51807c478bd9Sstevel@tonic-gate struct cbstats { 51817c478bd9Sstevel@tonic-gate kstat_named_t cb_asked; 51827c478bd9Sstevel@tonic-gate kstat_named_t cb_new; 51837c478bd9Sstevel@tonic-gate kstat_named_t cb_run; 51847c478bd9Sstevel@tonic-gate kstat_named_t cb_delete; 51857c478bd9Sstevel@tonic-gate kstat_named_t cb_maxreq; 51867c478bd9Sstevel@tonic-gate kstat_named_t cb_maxlist; 51877c478bd9Sstevel@tonic-gate kstat_named_t cb_alloc; 51887c478bd9Sstevel@tonic-gate kstat_named_t cb_runouts; 51897c478bd9Sstevel@tonic-gate kstat_named_t cb_L2; 51907c478bd9Sstevel@tonic-gate kstat_named_t cb_grow; 51917c478bd9Sstevel@tonic-gate } cbstats = { 51927c478bd9Sstevel@tonic-gate {"asked", KSTAT_DATA_UINT32}, 51937c478bd9Sstevel@tonic-gate {"new", KSTAT_DATA_UINT32}, 51947c478bd9Sstevel@tonic-gate {"run", KSTAT_DATA_UINT32}, 51957c478bd9Sstevel@tonic-gate {"delete", KSTAT_DATA_UINT32}, 51967c478bd9Sstevel@tonic-gate {"maxreq", KSTAT_DATA_UINT32}, 51977c478bd9Sstevel@tonic-gate {"maxlist", KSTAT_DATA_UINT32}, 51987c478bd9Sstevel@tonic-gate {"alloc", KSTAT_DATA_UINT32}, 51997c478bd9Sstevel@tonic-gate {"runouts", KSTAT_DATA_UINT32}, 52007c478bd9Sstevel@tonic-gate {"L2", KSTAT_DATA_UINT32}, 52017c478bd9Sstevel@tonic-gate {"grow", KSTAT_DATA_UINT32}, 52027c478bd9Sstevel@tonic-gate }; 52037c478bd9Sstevel@tonic-gate 52047c478bd9Sstevel@tonic-gate #define nc_asked cb_asked.value.ui32 52057c478bd9Sstevel@tonic-gate #define nc_new cb_new.value.ui32 52067c478bd9Sstevel@tonic-gate #define nc_run cb_run.value.ui32 52077c478bd9Sstevel@tonic-gate #define nc_delete cb_delete.value.ui32 52087c478bd9Sstevel@tonic-gate #define nc_maxreq cb_maxreq.value.ui32 52097c478bd9Sstevel@tonic-gate #define nc_maxlist cb_maxlist.value.ui32 52107c478bd9Sstevel@tonic-gate #define nc_alloc cb_alloc.value.ui32 52117c478bd9Sstevel@tonic-gate #define nc_runouts cb_runouts.value.ui32 52127c478bd9Sstevel@tonic-gate #define nc_L2 cb_L2.value.ui32 52137c478bd9Sstevel@tonic-gate #define nc_grow cb_grow.value.ui32 52147c478bd9Sstevel@tonic-gate 52157c478bd9Sstevel@tonic-gate static kmutex_t ddi_callback_mutex; 52167c478bd9Sstevel@tonic-gate 52177c478bd9Sstevel@tonic-gate /* 52187c478bd9Sstevel@tonic-gate * callbacks are handled using a L1/L2 cache. The L1 cache 52197c478bd9Sstevel@tonic-gate * comes out of kmem_cache_alloc and can expand/shrink dynamically. If 52207c478bd9Sstevel@tonic-gate * we can't get callbacks from the L1 cache [because pageout is doing 52217c478bd9Sstevel@tonic-gate * I/O at the time freemem is 0], we allocate callbacks out of the 52227c478bd9Sstevel@tonic-gate * L2 cache. The L2 cache is static and depends on the memory size. 52237c478bd9Sstevel@tonic-gate * [We might also count the number of devices at probe time and 52247c478bd9Sstevel@tonic-gate * allocate one structure per device and adjust for deferred attach] 52257c478bd9Sstevel@tonic-gate */ 52267c478bd9Sstevel@tonic-gate void 52277c478bd9Sstevel@tonic-gate impl_ddi_callback_init(void) 52287c478bd9Sstevel@tonic-gate { 52297c478bd9Sstevel@tonic-gate int i; 52307c478bd9Sstevel@tonic-gate uint_t physmegs; 52317c478bd9Sstevel@tonic-gate kstat_t *ksp; 52327c478bd9Sstevel@tonic-gate 52337c478bd9Sstevel@tonic-gate physmegs = physmem >> (20 - PAGESHIFT); 52347c478bd9Sstevel@tonic-gate if (physmegs < 48) { 52357c478bd9Sstevel@tonic-gate ncallbacks = nc_low; 52367c478bd9Sstevel@tonic-gate } else if (physmegs < 128) { 52377c478bd9Sstevel@tonic-gate ncallbacks = nc_med; 52387c478bd9Sstevel@tonic-gate } else { 52397c478bd9Sstevel@tonic-gate ncallbacks = nc_high; 52407c478bd9Sstevel@tonic-gate } 52417c478bd9Sstevel@tonic-gate 52427c478bd9Sstevel@tonic-gate /* 52437c478bd9Sstevel@tonic-gate * init free list 52447c478bd9Sstevel@tonic-gate */ 52457c478bd9Sstevel@tonic-gate callbackq = kmem_zalloc( 52467c478bd9Sstevel@tonic-gate ncallbacks * sizeof (struct ddi_callback), KM_SLEEP); 52477c478bd9Sstevel@tonic-gate for (i = 0; i < ncallbacks-1; i++) 52487c478bd9Sstevel@tonic-gate callbackq[i].c_nfree = &callbackq[i+1]; 52497c478bd9Sstevel@tonic-gate callbackqfree = callbackq; 52507c478bd9Sstevel@tonic-gate 52517c478bd9Sstevel@tonic-gate /* init kstats */ 52527c478bd9Sstevel@tonic-gate if (ksp = kstat_create("unix", 0, "cbstats", "misc", KSTAT_TYPE_NAMED, 52537c478bd9Sstevel@tonic-gate sizeof (cbstats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL)) { 52547c478bd9Sstevel@tonic-gate ksp->ks_data = (void *) &cbstats; 52557c478bd9Sstevel@tonic-gate kstat_install(ksp); 52567c478bd9Sstevel@tonic-gate } 52577c478bd9Sstevel@tonic-gate 52587c478bd9Sstevel@tonic-gate } 52597c478bd9Sstevel@tonic-gate 52607c478bd9Sstevel@tonic-gate static void 52617c478bd9Sstevel@tonic-gate callback_insert(int (*funcp)(caddr_t), caddr_t arg, uintptr_t *listid, 52627c478bd9Sstevel@tonic-gate int count) 52637c478bd9Sstevel@tonic-gate { 52647c478bd9Sstevel@tonic-gate struct ddi_callback *list, *marker, *new; 52657c478bd9Sstevel@tonic-gate size_t size = sizeof (struct ddi_callback); 52667c478bd9Sstevel@tonic-gate 52677c478bd9Sstevel@tonic-gate list = marker = (struct ddi_callback *)*listid; 52687c478bd9Sstevel@tonic-gate while (list != NULL) { 52697c478bd9Sstevel@tonic-gate if (list->c_call == funcp && list->c_arg == arg) { 52707c478bd9Sstevel@tonic-gate list->c_count += count; 52717c478bd9Sstevel@tonic-gate return; 52727c478bd9Sstevel@tonic-gate } 52737c478bd9Sstevel@tonic-gate marker = list; 52747c478bd9Sstevel@tonic-gate list = list->c_nlist; 52757c478bd9Sstevel@tonic-gate } 52767c478bd9Sstevel@tonic-gate new = kmem_alloc(size, KM_NOSLEEP); 52777c478bd9Sstevel@tonic-gate if (new == NULL) { 52787c478bd9Sstevel@tonic-gate new = callbackqfree; 52797c478bd9Sstevel@tonic-gate if (new == NULL) { 52807c478bd9Sstevel@tonic-gate new = kmem_alloc_tryhard(sizeof (struct ddi_callback), 52817c478bd9Sstevel@tonic-gate &size, KM_NOSLEEP | KM_PANIC); 52827c478bd9Sstevel@tonic-gate cbstats.nc_grow++; 52837c478bd9Sstevel@tonic-gate } else { 52847c478bd9Sstevel@tonic-gate callbackqfree = new->c_nfree; 52857c478bd9Sstevel@tonic-gate cbstats.nc_L2++; 52867c478bd9Sstevel@tonic-gate } 52877c478bd9Sstevel@tonic-gate } 52887c478bd9Sstevel@tonic-gate if (marker != NULL) { 52897c478bd9Sstevel@tonic-gate marker->c_nlist = new; 52907c478bd9Sstevel@tonic-gate } else { 52917c478bd9Sstevel@tonic-gate *listid = (uintptr_t)new; 52927c478bd9Sstevel@tonic-gate } 52937c478bd9Sstevel@tonic-gate new->c_size = size; 52947c478bd9Sstevel@tonic-gate new->c_nlist = NULL; 52957c478bd9Sstevel@tonic-gate new->c_call = funcp; 52967c478bd9Sstevel@tonic-gate new->c_arg = arg; 52977c478bd9Sstevel@tonic-gate new->c_count = count; 52987c478bd9Sstevel@tonic-gate cbstats.nc_new++; 52997c478bd9Sstevel@tonic-gate cbstats.nc_alloc++; 53007c478bd9Sstevel@tonic-gate if (cbstats.nc_alloc > cbstats.nc_maxlist) 53017c478bd9Sstevel@tonic-gate cbstats.nc_maxlist = cbstats.nc_alloc; 53027c478bd9Sstevel@tonic-gate } 53037c478bd9Sstevel@tonic-gate 53047c478bd9Sstevel@tonic-gate void 53057c478bd9Sstevel@tonic-gate ddi_set_callback(int (*funcp)(caddr_t), caddr_t arg, uintptr_t *listid) 53067c478bd9Sstevel@tonic-gate { 53077c478bd9Sstevel@tonic-gate mutex_enter(&ddi_callback_mutex); 53087c478bd9Sstevel@tonic-gate cbstats.nc_asked++; 53097c478bd9Sstevel@tonic-gate if ((cbstats.nc_asked - cbstats.nc_run) > cbstats.nc_maxreq) 53107c478bd9Sstevel@tonic-gate cbstats.nc_maxreq = (cbstats.nc_asked - cbstats.nc_run); 53117c478bd9Sstevel@tonic-gate (void) callback_insert(funcp, arg, listid, 1); 53127c478bd9Sstevel@tonic-gate mutex_exit(&ddi_callback_mutex); 53137c478bd9Sstevel@tonic-gate } 53147c478bd9Sstevel@tonic-gate 53157c478bd9Sstevel@tonic-gate static void 53167c478bd9Sstevel@tonic-gate real_callback_run(void *Queue) 53177c478bd9Sstevel@tonic-gate { 53187c478bd9Sstevel@tonic-gate int (*funcp)(caddr_t); 53197c478bd9Sstevel@tonic-gate caddr_t arg; 53207c478bd9Sstevel@tonic-gate int count, rval; 53217c478bd9Sstevel@tonic-gate uintptr_t *listid; 53227c478bd9Sstevel@tonic-gate struct ddi_callback *list, *marker; 53237c478bd9Sstevel@tonic-gate int check_pending = 1; 53247c478bd9Sstevel@tonic-gate int pending = 0; 53257c478bd9Sstevel@tonic-gate 53267c478bd9Sstevel@tonic-gate do { 53277c478bd9Sstevel@tonic-gate mutex_enter(&ddi_callback_mutex); 53287c478bd9Sstevel@tonic-gate listid = Queue; 53297c478bd9Sstevel@tonic-gate list = (struct ddi_callback *)*listid; 53307c478bd9Sstevel@tonic-gate if (list == NULL) { 53317c478bd9Sstevel@tonic-gate mutex_exit(&ddi_callback_mutex); 53327c478bd9Sstevel@tonic-gate return; 53337c478bd9Sstevel@tonic-gate } 53347c478bd9Sstevel@tonic-gate if (check_pending) { 53357c478bd9Sstevel@tonic-gate marker = list; 53367c478bd9Sstevel@tonic-gate while (marker != NULL) { 53377c478bd9Sstevel@tonic-gate pending += marker->c_count; 53387c478bd9Sstevel@tonic-gate marker = marker->c_nlist; 53397c478bd9Sstevel@tonic-gate } 53407c478bd9Sstevel@tonic-gate check_pending = 0; 53417c478bd9Sstevel@tonic-gate } 53427c478bd9Sstevel@tonic-gate ASSERT(pending > 0); 53437c478bd9Sstevel@tonic-gate ASSERT(list->c_count > 0); 53447c478bd9Sstevel@tonic-gate funcp = list->c_call; 53457c478bd9Sstevel@tonic-gate arg = list->c_arg; 53467c478bd9Sstevel@tonic-gate count = list->c_count; 53477c478bd9Sstevel@tonic-gate *(uintptr_t *)Queue = (uintptr_t)list->c_nlist; 53487c478bd9Sstevel@tonic-gate if (list >= &callbackq[0] && 53497c478bd9Sstevel@tonic-gate list <= &callbackq[ncallbacks-1]) { 53507c478bd9Sstevel@tonic-gate list->c_nfree = callbackqfree; 53517c478bd9Sstevel@tonic-gate callbackqfree = list; 53527c478bd9Sstevel@tonic-gate } else 53537c478bd9Sstevel@tonic-gate kmem_free(list, list->c_size); 53547c478bd9Sstevel@tonic-gate 53557c478bd9Sstevel@tonic-gate cbstats.nc_delete++; 53567c478bd9Sstevel@tonic-gate cbstats.nc_alloc--; 53577c478bd9Sstevel@tonic-gate mutex_exit(&ddi_callback_mutex); 53587c478bd9Sstevel@tonic-gate 53597c478bd9Sstevel@tonic-gate do { 53607c478bd9Sstevel@tonic-gate if ((rval = (*funcp)(arg)) == 0) { 53617c478bd9Sstevel@tonic-gate pending -= count; 53627c478bd9Sstevel@tonic-gate mutex_enter(&ddi_callback_mutex); 53637c478bd9Sstevel@tonic-gate (void) callback_insert(funcp, arg, listid, 5364184cd04cScth count); 53657c478bd9Sstevel@tonic-gate cbstats.nc_runouts++; 53667c478bd9Sstevel@tonic-gate } else { 53677c478bd9Sstevel@tonic-gate pending--; 53687c478bd9Sstevel@tonic-gate mutex_enter(&ddi_callback_mutex); 53697c478bd9Sstevel@tonic-gate cbstats.nc_run++; 53707c478bd9Sstevel@tonic-gate } 53717c478bd9Sstevel@tonic-gate mutex_exit(&ddi_callback_mutex); 53727c478bd9Sstevel@tonic-gate } while (rval != 0 && (--count > 0)); 53737c478bd9Sstevel@tonic-gate } while (pending > 0); 53747c478bd9Sstevel@tonic-gate } 53757c478bd9Sstevel@tonic-gate 53767c478bd9Sstevel@tonic-gate void 53777c478bd9Sstevel@tonic-gate ddi_run_callback(uintptr_t *listid) 53787c478bd9Sstevel@tonic-gate { 53797c478bd9Sstevel@tonic-gate softcall(real_callback_run, listid); 53807c478bd9Sstevel@tonic-gate } 53817c478bd9Sstevel@tonic-gate 5382dd4eeefdSeota /* 5383dd4eeefdSeota * ddi_periodic_t 5384dd4eeefdSeota * ddi_periodic_add(void (*func)(void *), void *arg, hrtime_t interval, 5385dd4eeefdSeota * int level) 5386dd4eeefdSeota * 5387dd4eeefdSeota * INTERFACE LEVEL 5388dd4eeefdSeota * Solaris DDI specific (Solaris DDI) 5389dd4eeefdSeota * 5390dd4eeefdSeota * PARAMETERS 5391dd4eeefdSeota * func: the callback function 5392dd4eeefdSeota * 5393dd4eeefdSeota * The callback function will be invoked. The function is invoked 5394dd4eeefdSeota * in kernel context if the argument level passed is the zero. 5395dd4eeefdSeota * Otherwise it's invoked in interrupt context at the specified 5396dd4eeefdSeota * level. 5397dd4eeefdSeota * 5398dd4eeefdSeota * arg: the argument passed to the callback function 5399dd4eeefdSeota * 5400dd4eeefdSeota * interval: interval time 5401dd4eeefdSeota * 5402dd4eeefdSeota * level : callback interrupt level 5403dd4eeefdSeota * 5404dd4eeefdSeota * If the value is the zero, the callback function is invoked 5405dd4eeefdSeota * in kernel context. If the value is more than the zero, but 5406dd4eeefdSeota * less than or equal to ten, the callback function is invoked in 5407dd4eeefdSeota * interrupt context at the specified interrupt level, which may 5408dd4eeefdSeota * be used for real time applications. 5409dd4eeefdSeota * 5410dd4eeefdSeota * This value must be in range of 0-10, which can be a numeric 5411dd4eeefdSeota * number or a pre-defined macro (DDI_IPL_0, ... , DDI_IPL_10). 5412dd4eeefdSeota * 5413dd4eeefdSeota * DESCRIPTION 5414dd4eeefdSeota * ddi_periodic_add(9F) schedules the specified function to be 5415dd4eeefdSeota * periodically invoked in the interval time. 5416dd4eeefdSeota * 5417dd4eeefdSeota * As well as timeout(9F), the exact time interval over which the function 5418dd4eeefdSeota * takes effect cannot be guaranteed, but the value given is a close 5419dd4eeefdSeota * approximation. 5420dd4eeefdSeota * 5421dd4eeefdSeota * Drivers waiting on behalf of processes with real-time constraints must 5422dd4eeefdSeota * pass non-zero value with the level argument to ddi_periodic_add(9F). 5423dd4eeefdSeota * 5424dd4eeefdSeota * RETURN VALUES 5425dd4eeefdSeota * ddi_periodic_add(9F) returns a non-zero opaque value (ddi_periodic_t), 5426dd4eeefdSeota * which must be used for ddi_periodic_delete(9F) to specify the request. 5427dd4eeefdSeota * 5428dd4eeefdSeota * CONTEXT 5429dd4eeefdSeota * ddi_periodic_add(9F) can be called in user or kernel context, but 5430dd4eeefdSeota * it cannot be called in interrupt context, which is different from 5431dd4eeefdSeota * timeout(9F). 5432dd4eeefdSeota */ 5433dd4eeefdSeota ddi_periodic_t 5434dd4eeefdSeota ddi_periodic_add(void (*func)(void *), void *arg, hrtime_t interval, int level) 5435dd4eeefdSeota { 5436dd4eeefdSeota /* 5437dd4eeefdSeota * Sanity check of the argument level. 5438dd4eeefdSeota */ 5439dd4eeefdSeota if (level < DDI_IPL_0 || level > DDI_IPL_10) 5440dd4eeefdSeota cmn_err(CE_PANIC, 5441dd4eeefdSeota "ddi_periodic_add: invalid interrupt level (%d).", level); 5442dd4eeefdSeota 5443dd4eeefdSeota /* 5444dd4eeefdSeota * Sanity check of the context. ddi_periodic_add() cannot be 5445dd4eeefdSeota * called in either interrupt context or high interrupt context. 5446dd4eeefdSeota */ 5447dd4eeefdSeota if (servicing_interrupt()) 5448dd4eeefdSeota cmn_err(CE_PANIC, 5449dd4eeefdSeota "ddi_periodic_add: called in (high) interrupt context."); 5450dd4eeefdSeota 5451dd4eeefdSeota return ((ddi_periodic_t)i_timeout(func, arg, interval, level)); 5452dd4eeefdSeota } 5453dd4eeefdSeota 5454dd4eeefdSeota /* 5455dd4eeefdSeota * void 5456dd4eeefdSeota * ddi_periodic_delete(ddi_periodic_t req) 5457dd4eeefdSeota * 5458dd4eeefdSeota * INTERFACE LEVEL 5459dd4eeefdSeota * Solaris DDI specific (Solaris DDI) 5460dd4eeefdSeota * 5461dd4eeefdSeota * PARAMETERS 5462dd4eeefdSeota * req: ddi_periodic_t opaque value ddi_periodic_add(9F) returned 5463dd4eeefdSeota * previously. 5464dd4eeefdSeota * 5465dd4eeefdSeota * DESCRIPTION 5466dd4eeefdSeota * ddi_periodic_delete(9F) cancels the ddi_periodic_add(9F) request 5467dd4eeefdSeota * previously requested. 5468dd4eeefdSeota * 5469dd4eeefdSeota * ddi_periodic_delete(9F) will not return until the pending request 5470dd4eeefdSeota * is canceled or executed. 5471dd4eeefdSeota * 5472dd4eeefdSeota * As well as untimeout(9F), calling ddi_periodic_delete(9F) for a 5473dd4eeefdSeota * timeout which is either running on another CPU, or has already 5474dd4eeefdSeota * completed causes no problems. However, unlike untimeout(9F), there is 5475dd4eeefdSeota * no restrictions on the lock which might be held across the call to 5476dd4eeefdSeota * ddi_periodic_delete(9F). 5477dd4eeefdSeota * 5478dd4eeefdSeota * Drivers should be structured with the understanding that the arrival of 5479dd4eeefdSeota * both an interrupt and a timeout for that interrupt can occasionally 5480dd4eeefdSeota * occur, in either order. 5481dd4eeefdSeota * 5482dd4eeefdSeota * CONTEXT 5483dd4eeefdSeota * ddi_periodic_delete(9F) can be called in user or kernel context, but 5484dd4eeefdSeota * it cannot be called in interrupt context, which is different from 5485dd4eeefdSeota * untimeout(9F). 5486dd4eeefdSeota */ 5487dd4eeefdSeota void 5488dd4eeefdSeota ddi_periodic_delete(ddi_periodic_t req) 5489dd4eeefdSeota { 5490dd4eeefdSeota /* 5491dd4eeefdSeota * Sanity check of the context. ddi_periodic_delete() cannot be 5492dd4eeefdSeota * called in either interrupt context or high interrupt context. 5493dd4eeefdSeota */ 5494dd4eeefdSeota if (servicing_interrupt()) 5495dd4eeefdSeota cmn_err(CE_PANIC, 5496dd4eeefdSeota "ddi_periodic_delete: called in (high) interrupt context."); 5497dd4eeefdSeota 5498dd4eeefdSeota i_untimeout((timeout_t)req); 5499dd4eeefdSeota } 5500dd4eeefdSeota 55017c478bd9Sstevel@tonic-gate dev_info_t * 55027c478bd9Sstevel@tonic-gate nodevinfo(dev_t dev, int otyp) 55037c478bd9Sstevel@tonic-gate { 55047c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dev, otyp)) 55057c478bd9Sstevel@tonic-gate return ((dev_info_t *)0); 55067c478bd9Sstevel@tonic-gate } 55077c478bd9Sstevel@tonic-gate 55087c478bd9Sstevel@tonic-gate /* 55097c478bd9Sstevel@tonic-gate * A driver should support its own getinfo(9E) entry point. This function 55107c478bd9Sstevel@tonic-gate * is provided as a convenience for ON drivers that don't expect their 55117c478bd9Sstevel@tonic-gate * getinfo(9E) entry point to be called. A driver that uses this must not 55127c478bd9Sstevel@tonic-gate * call ddi_create_minor_node. 55137c478bd9Sstevel@tonic-gate */ 55147c478bd9Sstevel@tonic-gate int 55157c478bd9Sstevel@tonic-gate ddi_no_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 55167c478bd9Sstevel@tonic-gate { 55177c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, infocmd, arg, result)) 55187c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 55197c478bd9Sstevel@tonic-gate } 55207c478bd9Sstevel@tonic-gate 55217c478bd9Sstevel@tonic-gate /* 55227c478bd9Sstevel@tonic-gate * A driver should support its own getinfo(9E) entry point. This function 55237c478bd9Sstevel@tonic-gate * is provided as a convenience for ON drivers that where the minor number 55247c478bd9Sstevel@tonic-gate * is the instance. Drivers that do not have 1:1 mapping must implement 55257c478bd9Sstevel@tonic-gate * their own getinfo(9E) function. 55267c478bd9Sstevel@tonic-gate */ 55277c478bd9Sstevel@tonic-gate int 55287c478bd9Sstevel@tonic-gate ddi_getinfo_1to1(dev_info_t *dip, ddi_info_cmd_t infocmd, 55297c478bd9Sstevel@tonic-gate void *arg, void **result) 55307c478bd9Sstevel@tonic-gate { 55317c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip)) 55327c478bd9Sstevel@tonic-gate int instance; 55337c478bd9Sstevel@tonic-gate 55347c478bd9Sstevel@tonic-gate if (infocmd != DDI_INFO_DEVT2INSTANCE) 55357c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 55367c478bd9Sstevel@tonic-gate 55377c478bd9Sstevel@tonic-gate instance = getminor((dev_t)(uintptr_t)arg); 55387c478bd9Sstevel@tonic-gate *result = (void *)(uintptr_t)instance; 55397c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 55407c478bd9Sstevel@tonic-gate } 55417c478bd9Sstevel@tonic-gate 55427c478bd9Sstevel@tonic-gate int 55437c478bd9Sstevel@tonic-gate ddifail(dev_info_t *devi, ddi_attach_cmd_t cmd) 55447c478bd9Sstevel@tonic-gate { 55457c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(devi, cmd)) 55467c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 55477c478bd9Sstevel@tonic-gate } 55487c478bd9Sstevel@tonic-gate 55497c478bd9Sstevel@tonic-gate int 55507c478bd9Sstevel@tonic-gate ddi_no_dma_map(dev_info_t *dip, dev_info_t *rdip, 55517c478bd9Sstevel@tonic-gate struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep) 55527c478bd9Sstevel@tonic-gate { 55537c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, dmareqp, handlep)) 55547c478bd9Sstevel@tonic-gate return (DDI_DMA_NOMAPPING); 55557c478bd9Sstevel@tonic-gate } 55567c478bd9Sstevel@tonic-gate 55577c478bd9Sstevel@tonic-gate int 55587c478bd9Sstevel@tonic-gate ddi_no_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr, 55597c478bd9Sstevel@tonic-gate int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep) 55607c478bd9Sstevel@tonic-gate { 55617c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, attr, waitfp, arg, handlep)) 55627c478bd9Sstevel@tonic-gate return (DDI_DMA_BADATTR); 55637c478bd9Sstevel@tonic-gate } 55647c478bd9Sstevel@tonic-gate 55657c478bd9Sstevel@tonic-gate int 55667c478bd9Sstevel@tonic-gate ddi_no_dma_freehdl(dev_info_t *dip, dev_info_t *rdip, 55677c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle) 55687c478bd9Sstevel@tonic-gate { 55697c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, handle)) 55707c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 55717c478bd9Sstevel@tonic-gate } 55727c478bd9Sstevel@tonic-gate 55737c478bd9Sstevel@tonic-gate int 55747c478bd9Sstevel@tonic-gate ddi_no_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip, 55757c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, struct ddi_dma_req *dmareq, 55767c478bd9Sstevel@tonic-gate ddi_dma_cookie_t *cp, uint_t *ccountp) 55777c478bd9Sstevel@tonic-gate { 55787c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, handle, dmareq, cp, ccountp)) 55797c478bd9Sstevel@tonic-gate return (DDI_DMA_NOMAPPING); 55807c478bd9Sstevel@tonic-gate } 55817c478bd9Sstevel@tonic-gate 55827c478bd9Sstevel@tonic-gate int 55837c478bd9Sstevel@tonic-gate ddi_no_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip, 55847c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle) 55857c478bd9Sstevel@tonic-gate { 55867c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, handle)) 55877c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 55887c478bd9Sstevel@tonic-gate } 55897c478bd9Sstevel@tonic-gate 55907c478bd9Sstevel@tonic-gate int 55917c478bd9Sstevel@tonic-gate ddi_no_dma_flush(dev_info_t *dip, dev_info_t *rdip, 55927c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, off_t off, size_t len, 55937c478bd9Sstevel@tonic-gate uint_t cache_flags) 55947c478bd9Sstevel@tonic-gate { 55957c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, handle, off, len, cache_flags)) 55967c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 55977c478bd9Sstevel@tonic-gate } 55987c478bd9Sstevel@tonic-gate 55997c478bd9Sstevel@tonic-gate int 56007c478bd9Sstevel@tonic-gate ddi_no_dma_win(dev_info_t *dip, dev_info_t *rdip, 56017c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, uint_t win, off_t *offp, 56027c478bd9Sstevel@tonic-gate size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp) 56037c478bd9Sstevel@tonic-gate { 56047c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, handle, win, offp, lenp, cookiep, ccountp)) 56057c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 56067c478bd9Sstevel@tonic-gate } 56077c478bd9Sstevel@tonic-gate 56087c478bd9Sstevel@tonic-gate int 56097c478bd9Sstevel@tonic-gate ddi_no_dma_mctl(dev_info_t *dip, dev_info_t *rdip, 56107c478bd9Sstevel@tonic-gate ddi_dma_handle_t handle, enum ddi_dma_ctlops request, 56117c478bd9Sstevel@tonic-gate off_t *offp, size_t *lenp, caddr_t *objp, uint_t flags) 56127c478bd9Sstevel@tonic-gate { 56137c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dip, rdip, handle, request, offp, lenp, objp, flags)) 56147c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 56157c478bd9Sstevel@tonic-gate } 56167c478bd9Sstevel@tonic-gate 56177c478bd9Sstevel@tonic-gate void 56187c478bd9Sstevel@tonic-gate ddivoid(void) 56197c478bd9Sstevel@tonic-gate {} 56207c478bd9Sstevel@tonic-gate 56217c478bd9Sstevel@tonic-gate int 56227c478bd9Sstevel@tonic-gate nochpoll(dev_t dev, short events, int anyyet, short *reventsp, 56237c478bd9Sstevel@tonic-gate struct pollhead **pollhdrp) 56247c478bd9Sstevel@tonic-gate { 56257c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(dev, events, anyyet, reventsp, pollhdrp)) 56267c478bd9Sstevel@tonic-gate return (ENXIO); 56277c478bd9Sstevel@tonic-gate } 56287c478bd9Sstevel@tonic-gate 56297c478bd9Sstevel@tonic-gate cred_t * 56307c478bd9Sstevel@tonic-gate ddi_get_cred(void) 56317c478bd9Sstevel@tonic-gate { 56327c478bd9Sstevel@tonic-gate return (CRED()); 56337c478bd9Sstevel@tonic-gate } 56347c478bd9Sstevel@tonic-gate 56357c478bd9Sstevel@tonic-gate clock_t 56367c478bd9Sstevel@tonic-gate ddi_get_lbolt(void) 56377c478bd9Sstevel@tonic-gate { 5638d3d50737SRafael Vanoni return ((clock_t)lbolt_hybrid()); 5639d3d50737SRafael Vanoni } 5640d3d50737SRafael Vanoni 5641d3d50737SRafael Vanoni int64_t 5642d3d50737SRafael Vanoni ddi_get_lbolt64(void) 5643d3d50737SRafael Vanoni { 5644d3d50737SRafael Vanoni return (lbolt_hybrid()); 56457c478bd9Sstevel@tonic-gate } 56467c478bd9Sstevel@tonic-gate 56477c478bd9Sstevel@tonic-gate time_t 56487c478bd9Sstevel@tonic-gate ddi_get_time(void) 56497c478bd9Sstevel@tonic-gate { 56507c478bd9Sstevel@tonic-gate time_t now; 56517c478bd9Sstevel@tonic-gate 56527c478bd9Sstevel@tonic-gate if ((now = gethrestime_sec()) == 0) { 56537c478bd9Sstevel@tonic-gate timestruc_t ts; 56547c478bd9Sstevel@tonic-gate mutex_enter(&tod_lock); 56557c478bd9Sstevel@tonic-gate ts = tod_get(); 56567c478bd9Sstevel@tonic-gate mutex_exit(&tod_lock); 56577c478bd9Sstevel@tonic-gate return (ts.tv_sec); 56587c478bd9Sstevel@tonic-gate } else { 56597c478bd9Sstevel@tonic-gate return (now); 56607c478bd9Sstevel@tonic-gate } 56617c478bd9Sstevel@tonic-gate } 56627c478bd9Sstevel@tonic-gate 56637c478bd9Sstevel@tonic-gate pid_t 56647c478bd9Sstevel@tonic-gate ddi_get_pid(void) 56657c478bd9Sstevel@tonic-gate { 56667c478bd9Sstevel@tonic-gate return (ttoproc(curthread)->p_pid); 56677c478bd9Sstevel@tonic-gate } 56687c478bd9Sstevel@tonic-gate 56697c478bd9Sstevel@tonic-gate kt_did_t 56707c478bd9Sstevel@tonic-gate ddi_get_kt_did(void) 56717c478bd9Sstevel@tonic-gate { 56727c478bd9Sstevel@tonic-gate return (curthread->t_did); 56737c478bd9Sstevel@tonic-gate } 56747c478bd9Sstevel@tonic-gate 56757c478bd9Sstevel@tonic-gate /* 56767c478bd9Sstevel@tonic-gate * This function returns B_TRUE if the caller can reasonably expect that a call 56777c478bd9Sstevel@tonic-gate * to cv_wait_sig(9F), cv_timedwait_sig(9F), or qwait_sig(9F) could be awakened 56787c478bd9Sstevel@tonic-gate * by user-level signal. If it returns B_FALSE, then the caller should use 56797c478bd9Sstevel@tonic-gate * other means to make certain that the wait will not hang "forever." 56807c478bd9Sstevel@tonic-gate * 56817c478bd9Sstevel@tonic-gate * It does not check the signal mask, nor for reception of any particular 56827c478bd9Sstevel@tonic-gate * signal. 56837c478bd9Sstevel@tonic-gate * 56847c478bd9Sstevel@tonic-gate * Currently, a thread can receive a signal if it's not a kernel thread and it 56857c478bd9Sstevel@tonic-gate * is not in the middle of exit(2) tear-down. Threads that are in that 56867c478bd9Sstevel@tonic-gate * tear-down effectively convert cv_wait_sig to cv_wait, cv_timedwait_sig to 56877c478bd9Sstevel@tonic-gate * cv_timedwait, and qwait_sig to qwait. 56887c478bd9Sstevel@tonic-gate */ 56897c478bd9Sstevel@tonic-gate boolean_t 56907c478bd9Sstevel@tonic-gate ddi_can_receive_sig(void) 56917c478bd9Sstevel@tonic-gate { 56927c478bd9Sstevel@tonic-gate proc_t *pp; 56937c478bd9Sstevel@tonic-gate 56947c478bd9Sstevel@tonic-gate if (curthread->t_proc_flag & TP_LWPEXIT) 56957c478bd9Sstevel@tonic-gate return (B_FALSE); 56967c478bd9Sstevel@tonic-gate if ((pp = ttoproc(curthread)) == NULL) 56977c478bd9Sstevel@tonic-gate return (B_FALSE); 56987c478bd9Sstevel@tonic-gate return (pp->p_as != &kas); 56997c478bd9Sstevel@tonic-gate } 57007c478bd9Sstevel@tonic-gate 57017c478bd9Sstevel@tonic-gate /* 57027c478bd9Sstevel@tonic-gate * Swap bytes in 16-bit [half-]words 57037c478bd9Sstevel@tonic-gate */ 57047c478bd9Sstevel@tonic-gate void 57057c478bd9Sstevel@tonic-gate swab(void *src, void *dst, size_t nbytes) 57067c478bd9Sstevel@tonic-gate { 57077c478bd9Sstevel@tonic-gate uchar_t *pf = (uchar_t *)src; 57087c478bd9Sstevel@tonic-gate uchar_t *pt = (uchar_t *)dst; 57097c478bd9Sstevel@tonic-gate uchar_t tmp; 57107c478bd9Sstevel@tonic-gate int nshorts; 57117c478bd9Sstevel@tonic-gate 57127c478bd9Sstevel@tonic-gate nshorts = nbytes >> 1; 57137c478bd9Sstevel@tonic-gate 57147c478bd9Sstevel@tonic-gate while (--nshorts >= 0) { 57157c478bd9Sstevel@tonic-gate tmp = *pf++; 57167c478bd9Sstevel@tonic-gate *pt++ = *pf++; 57177c478bd9Sstevel@tonic-gate *pt++ = tmp; 57187c478bd9Sstevel@tonic-gate } 57197c478bd9Sstevel@tonic-gate } 57207c478bd9Sstevel@tonic-gate 57217c478bd9Sstevel@tonic-gate static void 57227c478bd9Sstevel@tonic-gate ddi_append_minor_node(dev_info_t *ddip, struct ddi_minor_data *dmdp) 57237c478bd9Sstevel@tonic-gate { 5724b9ccdc5aScth int circ; 5725b9ccdc5aScth struct ddi_minor_data *dp; 57267c478bd9Sstevel@tonic-gate 5727b9ccdc5aScth ndi_devi_enter(ddip, &circ); 57287c478bd9Sstevel@tonic-gate if ((dp = DEVI(ddip)->devi_minor) == (struct ddi_minor_data *)NULL) { 57297c478bd9Sstevel@tonic-gate DEVI(ddip)->devi_minor = dmdp; 57307c478bd9Sstevel@tonic-gate } else { 57317c478bd9Sstevel@tonic-gate while (dp->next != (struct ddi_minor_data *)NULL) 57327c478bd9Sstevel@tonic-gate dp = dp->next; 57337c478bd9Sstevel@tonic-gate dp->next = dmdp; 57347c478bd9Sstevel@tonic-gate } 5735b9ccdc5aScth ndi_devi_exit(ddip, circ); 57367c478bd9Sstevel@tonic-gate } 57377c478bd9Sstevel@tonic-gate 57387c478bd9Sstevel@tonic-gate /* 57397c478bd9Sstevel@tonic-gate * Part of the obsolete SunCluster DDI Hooks. 57407c478bd9Sstevel@tonic-gate * Keep for binary compatibility 57417c478bd9Sstevel@tonic-gate */ 57427c478bd9Sstevel@tonic-gate minor_t 57437c478bd9Sstevel@tonic-gate ddi_getiminor(dev_t dev) 57447c478bd9Sstevel@tonic-gate { 57457c478bd9Sstevel@tonic-gate return (getminor(dev)); 57467c478bd9Sstevel@tonic-gate } 57477c478bd9Sstevel@tonic-gate 57487c478bd9Sstevel@tonic-gate static int 57497c478bd9Sstevel@tonic-gate i_log_devfs_minor_create(dev_info_t *dip, char *minor_name) 57507c478bd9Sstevel@tonic-gate { 57517c478bd9Sstevel@tonic-gate int se_flag; 57527c478bd9Sstevel@tonic-gate int kmem_flag; 57537c478bd9Sstevel@tonic-gate int se_err; 575430294554Sphitran char *pathname, *class_name; 57557c478bd9Sstevel@tonic-gate sysevent_t *ev = NULL; 57567c478bd9Sstevel@tonic-gate sysevent_id_t eid; 57577c478bd9Sstevel@tonic-gate sysevent_value_t se_val; 57587c478bd9Sstevel@tonic-gate sysevent_attr_list_t *ev_attr_list = NULL; 57597c478bd9Sstevel@tonic-gate 57607c478bd9Sstevel@tonic-gate /* determine interrupt context */ 57617c478bd9Sstevel@tonic-gate se_flag = (servicing_interrupt()) ? SE_NOSLEEP : SE_SLEEP; 57627c478bd9Sstevel@tonic-gate kmem_flag = (se_flag == SE_SLEEP) ? KM_SLEEP : KM_NOSLEEP; 57637c478bd9Sstevel@tonic-gate 57644c06356bSdh i_ddi_di_cache_invalidate(); 57657c478bd9Sstevel@tonic-gate 57667c478bd9Sstevel@tonic-gate #ifdef DEBUG 57677c478bd9Sstevel@tonic-gate if ((se_flag == SE_NOSLEEP) && sunddi_debug) { 57687c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "ddi_create_minor_node: called from " 57697c478bd9Sstevel@tonic-gate "interrupt level by driver %s", 57707c478bd9Sstevel@tonic-gate ddi_driver_name(dip)); 57717c478bd9Sstevel@tonic-gate } 57727c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 57737c478bd9Sstevel@tonic-gate 57747c478bd9Sstevel@tonic-gate ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_MINOR_CREATE, EP_DDI, se_flag); 57757c478bd9Sstevel@tonic-gate if (ev == NULL) { 57767c478bd9Sstevel@tonic-gate goto fail; 57777c478bd9Sstevel@tonic-gate } 57787c478bd9Sstevel@tonic-gate 57797c478bd9Sstevel@tonic-gate pathname = kmem_alloc(MAXPATHLEN, kmem_flag); 57807c478bd9Sstevel@tonic-gate if (pathname == NULL) { 57817c478bd9Sstevel@tonic-gate sysevent_free(ev); 57827c478bd9Sstevel@tonic-gate goto fail; 57837c478bd9Sstevel@tonic-gate } 57847c478bd9Sstevel@tonic-gate 57857c478bd9Sstevel@tonic-gate (void) ddi_pathname(dip, pathname); 57867c478bd9Sstevel@tonic-gate ASSERT(strlen(pathname)); 57877c478bd9Sstevel@tonic-gate se_val.value_type = SE_DATA_TYPE_STRING; 57887c478bd9Sstevel@tonic-gate se_val.value.sv_string = pathname; 57897c478bd9Sstevel@tonic-gate if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME, 57907c478bd9Sstevel@tonic-gate &se_val, se_flag) != 0) { 57917c478bd9Sstevel@tonic-gate kmem_free(pathname, MAXPATHLEN); 57927c478bd9Sstevel@tonic-gate sysevent_free(ev); 57937c478bd9Sstevel@tonic-gate goto fail; 57947c478bd9Sstevel@tonic-gate } 57957c478bd9Sstevel@tonic-gate kmem_free(pathname, MAXPATHLEN); 57967c478bd9Sstevel@tonic-gate 579730294554Sphitran /* add the device class attribute */ 579830294554Sphitran if ((class_name = i_ddi_devi_class(dip)) != NULL) { 579930294554Sphitran se_val.value_type = SE_DATA_TYPE_STRING; 580030294554Sphitran se_val.value.sv_string = class_name; 580130294554Sphitran if (sysevent_add_attr(&ev_attr_list, 580230294554Sphitran DEVFS_DEVI_CLASS, &se_val, SE_SLEEP) != 0) { 580330294554Sphitran sysevent_free_attr(ev_attr_list); 580430294554Sphitran goto fail; 580530294554Sphitran } 580630294554Sphitran } 580730294554Sphitran 58087c478bd9Sstevel@tonic-gate /* 58097c478bd9Sstevel@tonic-gate * allow for NULL minor names 58107c478bd9Sstevel@tonic-gate */ 58117c478bd9Sstevel@tonic-gate if (minor_name != NULL) { 58127c478bd9Sstevel@tonic-gate se_val.value.sv_string = minor_name; 58137c478bd9Sstevel@tonic-gate if (sysevent_add_attr(&ev_attr_list, DEVFS_MINOR_NAME, 58147c478bd9Sstevel@tonic-gate &se_val, se_flag) != 0) { 58157c478bd9Sstevel@tonic-gate sysevent_free_attr(ev_attr_list); 58167c478bd9Sstevel@tonic-gate sysevent_free(ev); 58177c478bd9Sstevel@tonic-gate goto fail; 58187c478bd9Sstevel@tonic-gate } 58197c478bd9Sstevel@tonic-gate } 58207c478bd9Sstevel@tonic-gate 58217c478bd9Sstevel@tonic-gate if (sysevent_attach_attributes(ev, ev_attr_list) != 0) { 58227c478bd9Sstevel@tonic-gate sysevent_free_attr(ev_attr_list); 58237c478bd9Sstevel@tonic-gate sysevent_free(ev); 58247c478bd9Sstevel@tonic-gate goto fail; 58257c478bd9Sstevel@tonic-gate } 58267c478bd9Sstevel@tonic-gate 58277c478bd9Sstevel@tonic-gate if ((se_err = log_sysevent(ev, se_flag, &eid)) != 0) { 58287c478bd9Sstevel@tonic-gate if (se_err == SE_NO_TRANSPORT) { 58297c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "/devices or /dev may not be current " 58307c478bd9Sstevel@tonic-gate "for driver %s (%s). Run devfsadm -i %s", 58317c478bd9Sstevel@tonic-gate ddi_driver_name(dip), "syseventd not responding", 58327c478bd9Sstevel@tonic-gate ddi_driver_name(dip)); 58337c478bd9Sstevel@tonic-gate } else { 58347c478bd9Sstevel@tonic-gate sysevent_free(ev); 58357c478bd9Sstevel@tonic-gate goto fail; 58367c478bd9Sstevel@tonic-gate } 58377c478bd9Sstevel@tonic-gate } 58387c478bd9Sstevel@tonic-gate 58397c478bd9Sstevel@tonic-gate sysevent_free(ev); 58407c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 58417c478bd9Sstevel@tonic-gate fail: 58427c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "/devices or /dev may not be current " 58437c478bd9Sstevel@tonic-gate "for driver %s. Run devfsadm -i %s", 58447c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_driver_name(dip)); 58457c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 58467c478bd9Sstevel@tonic-gate } 58477c478bd9Sstevel@tonic-gate 58487c478bd9Sstevel@tonic-gate /* 58497c478bd9Sstevel@tonic-gate * failing to remove a minor node is not of interest 58507c478bd9Sstevel@tonic-gate * therefore we do not generate an error message 58517c478bd9Sstevel@tonic-gate */ 58527c478bd9Sstevel@tonic-gate static int 58537c478bd9Sstevel@tonic-gate i_log_devfs_minor_remove(dev_info_t *dip, char *minor_name) 58547c478bd9Sstevel@tonic-gate { 585530294554Sphitran char *pathname, *class_name; 58567c478bd9Sstevel@tonic-gate sysevent_t *ev; 58577c478bd9Sstevel@tonic-gate sysevent_id_t eid; 58587c478bd9Sstevel@tonic-gate sysevent_value_t se_val; 58597c478bd9Sstevel@tonic-gate sysevent_attr_list_t *ev_attr_list = NULL; 58607c478bd9Sstevel@tonic-gate 58617c478bd9Sstevel@tonic-gate /* 58627c478bd9Sstevel@tonic-gate * only log ddi_remove_minor_node() calls outside the scope 58637c478bd9Sstevel@tonic-gate * of attach/detach reconfigurations and when the dip is 58647c478bd9Sstevel@tonic-gate * still initialized. 58657c478bd9Sstevel@tonic-gate */ 58667c478bd9Sstevel@tonic-gate if (DEVI_IS_ATTACHING(dip) || DEVI_IS_DETACHING(dip) || 58677c478bd9Sstevel@tonic-gate (i_ddi_node_state(dip) < DS_INITIALIZED)) { 58687c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 58697c478bd9Sstevel@tonic-gate } 58707c478bd9Sstevel@tonic-gate 58714c06356bSdh i_ddi_di_cache_invalidate(); 58727c478bd9Sstevel@tonic-gate 58737c478bd9Sstevel@tonic-gate ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_MINOR_REMOVE, EP_DDI, SE_SLEEP); 58747c478bd9Sstevel@tonic-gate if (ev == NULL) { 58757c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 58767c478bd9Sstevel@tonic-gate } 58777c478bd9Sstevel@tonic-gate 58787c478bd9Sstevel@tonic-gate pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 58797c478bd9Sstevel@tonic-gate if (pathname == NULL) { 58807c478bd9Sstevel@tonic-gate sysevent_free(ev); 58817c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 58827c478bd9Sstevel@tonic-gate } 58837c478bd9Sstevel@tonic-gate 58847c478bd9Sstevel@tonic-gate (void) ddi_pathname(dip, pathname); 58857c478bd9Sstevel@tonic-gate ASSERT(strlen(pathname)); 58867c478bd9Sstevel@tonic-gate se_val.value_type = SE_DATA_TYPE_STRING; 58877c478bd9Sstevel@tonic-gate se_val.value.sv_string = pathname; 58887c478bd9Sstevel@tonic-gate if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME, 58897c478bd9Sstevel@tonic-gate &se_val, SE_SLEEP) != 0) { 58907c478bd9Sstevel@tonic-gate kmem_free(pathname, MAXPATHLEN); 58917c478bd9Sstevel@tonic-gate sysevent_free(ev); 58927c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 58937c478bd9Sstevel@tonic-gate } 58947c478bd9Sstevel@tonic-gate 58957c478bd9Sstevel@tonic-gate kmem_free(pathname, MAXPATHLEN); 58967c478bd9Sstevel@tonic-gate 58977c478bd9Sstevel@tonic-gate /* 58987c478bd9Sstevel@tonic-gate * allow for NULL minor names 58997c478bd9Sstevel@tonic-gate */ 59007c478bd9Sstevel@tonic-gate if (minor_name != NULL) { 59017c478bd9Sstevel@tonic-gate se_val.value.sv_string = minor_name; 59027c478bd9Sstevel@tonic-gate if (sysevent_add_attr(&ev_attr_list, DEVFS_MINOR_NAME, 59037c478bd9Sstevel@tonic-gate &se_val, SE_SLEEP) != 0) { 59047c478bd9Sstevel@tonic-gate sysevent_free_attr(ev_attr_list); 59057c478bd9Sstevel@tonic-gate goto fail; 59067c478bd9Sstevel@tonic-gate } 59077c478bd9Sstevel@tonic-gate } 59087c478bd9Sstevel@tonic-gate 590930294554Sphitran if ((class_name = i_ddi_devi_class(dip)) != NULL) { 591030294554Sphitran /* add the device class, driver name and instance attributes */ 591130294554Sphitran 591230294554Sphitran se_val.value_type = SE_DATA_TYPE_STRING; 591330294554Sphitran se_val.value.sv_string = class_name; 591430294554Sphitran if (sysevent_add_attr(&ev_attr_list, 591530294554Sphitran DEVFS_DEVI_CLASS, &se_val, SE_SLEEP) != 0) { 591630294554Sphitran sysevent_free_attr(ev_attr_list); 591730294554Sphitran goto fail; 591830294554Sphitran } 591930294554Sphitran 592030294554Sphitran se_val.value_type = SE_DATA_TYPE_STRING; 592130294554Sphitran se_val.value.sv_string = (char *)ddi_driver_name(dip); 592230294554Sphitran if (sysevent_add_attr(&ev_attr_list, 592330294554Sphitran DEVFS_DRIVER_NAME, &se_val, SE_SLEEP) != 0) { 592430294554Sphitran sysevent_free_attr(ev_attr_list); 592530294554Sphitran goto fail; 592630294554Sphitran } 592730294554Sphitran 592830294554Sphitran se_val.value_type = SE_DATA_TYPE_INT32; 592930294554Sphitran se_val.value.sv_int32 = ddi_get_instance(dip); 593030294554Sphitran if (sysevent_add_attr(&ev_attr_list, 593130294554Sphitran DEVFS_INSTANCE, &se_val, SE_SLEEP) != 0) { 593230294554Sphitran sysevent_free_attr(ev_attr_list); 593330294554Sphitran goto fail; 593430294554Sphitran } 593530294554Sphitran 593630294554Sphitran } 593730294554Sphitran 59387c478bd9Sstevel@tonic-gate if (sysevent_attach_attributes(ev, ev_attr_list) != 0) { 59397c478bd9Sstevel@tonic-gate sysevent_free_attr(ev_attr_list); 59407c478bd9Sstevel@tonic-gate } else { 59417c478bd9Sstevel@tonic-gate (void) log_sysevent(ev, SE_SLEEP, &eid); 59427c478bd9Sstevel@tonic-gate } 59437c478bd9Sstevel@tonic-gate fail: 59447c478bd9Sstevel@tonic-gate sysevent_free(ev); 59457c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 59467c478bd9Sstevel@tonic-gate } 59477c478bd9Sstevel@tonic-gate 59487c478bd9Sstevel@tonic-gate /* 59497c478bd9Sstevel@tonic-gate * Derive the device class of the node. 59507c478bd9Sstevel@tonic-gate * Device class names aren't defined yet. Until this is done we use 59517c478bd9Sstevel@tonic-gate * devfs event subclass names as device class names. 59527c478bd9Sstevel@tonic-gate */ 59537c478bd9Sstevel@tonic-gate static int 59547c478bd9Sstevel@tonic-gate derive_devi_class(dev_info_t *dip, char *node_type, int flag) 59557c478bd9Sstevel@tonic-gate { 59567c478bd9Sstevel@tonic-gate int rv = DDI_SUCCESS; 59577c478bd9Sstevel@tonic-gate 59587c478bd9Sstevel@tonic-gate if (i_ddi_devi_class(dip) == NULL) { 59597c478bd9Sstevel@tonic-gate if (strncmp(node_type, DDI_NT_BLOCK, 59607c478bd9Sstevel@tonic-gate sizeof (DDI_NT_BLOCK) - 1) == 0 && 59617c478bd9Sstevel@tonic-gate (node_type[sizeof (DDI_NT_BLOCK) - 1] == '\0' || 59627c478bd9Sstevel@tonic-gate node_type[sizeof (DDI_NT_BLOCK) - 1] == ':') && 59637c478bd9Sstevel@tonic-gate strcmp(node_type, DDI_NT_FD) != 0) { 59647c478bd9Sstevel@tonic-gate 59657c478bd9Sstevel@tonic-gate rv = i_ddi_set_devi_class(dip, ESC_DISK, flag); 59667c478bd9Sstevel@tonic-gate 59677c478bd9Sstevel@tonic-gate } else if (strncmp(node_type, DDI_NT_NET, 59687c478bd9Sstevel@tonic-gate sizeof (DDI_NT_NET) - 1) == 0 && 59697c478bd9Sstevel@tonic-gate (node_type[sizeof (DDI_NT_NET) - 1] == '\0' || 59707c478bd9Sstevel@tonic-gate node_type[sizeof (DDI_NT_NET) - 1] == ':')) { 59717c478bd9Sstevel@tonic-gate 59727c478bd9Sstevel@tonic-gate rv = i_ddi_set_devi_class(dip, ESC_NETWORK, flag); 5973db11e6feSjacobs 5974db11e6feSjacobs } else if (strncmp(node_type, DDI_NT_PRINTER, 5975db11e6feSjacobs sizeof (DDI_NT_PRINTER) - 1) == 0 && 5976db11e6feSjacobs (node_type[sizeof (DDI_NT_PRINTER) - 1] == '\0' || 5977db11e6feSjacobs node_type[sizeof (DDI_NT_PRINTER) - 1] == ':')) { 5978db11e6feSjacobs 5979db11e6feSjacobs rv = i_ddi_set_devi_class(dip, ESC_PRINTER, flag); 598030294554Sphitran 598130294554Sphitran } else if (strncmp(node_type, DDI_PSEUDO, 598230294554Sphitran sizeof (DDI_PSEUDO) -1) == 0 && 598330294554Sphitran (strncmp(ESC_LOFI, ddi_node_name(dip), 598430294554Sphitran sizeof (ESC_LOFI) -1) == 0)) { 598530294554Sphitran rv = i_ddi_set_devi_class(dip, ESC_LOFI, flag); 59867c478bd9Sstevel@tonic-gate } 59877c478bd9Sstevel@tonic-gate } 59887c478bd9Sstevel@tonic-gate 59897c478bd9Sstevel@tonic-gate return (rv); 59907c478bd9Sstevel@tonic-gate } 59917c478bd9Sstevel@tonic-gate 59927c478bd9Sstevel@tonic-gate /* 59937c478bd9Sstevel@tonic-gate * Check compliance with PSARC 2003/375: 59947c478bd9Sstevel@tonic-gate * 59957c478bd9Sstevel@tonic-gate * The name must contain only characters a-z, A-Z, 0-9 or _ and it must not 59967c478bd9Sstevel@tonic-gate * exceed IFNAMSIZ (16) characters in length. 59977c478bd9Sstevel@tonic-gate */ 59987c478bd9Sstevel@tonic-gate static boolean_t 59997c478bd9Sstevel@tonic-gate verify_name(char *name) 60007c478bd9Sstevel@tonic-gate { 60017c478bd9Sstevel@tonic-gate size_t len = strlen(name); 60027c478bd9Sstevel@tonic-gate char *cp; 60037c478bd9Sstevel@tonic-gate 60047c478bd9Sstevel@tonic-gate if (len == 0 || len > IFNAMSIZ) 60057c478bd9Sstevel@tonic-gate return (B_FALSE); 60067c478bd9Sstevel@tonic-gate 60077c478bd9Sstevel@tonic-gate for (cp = name; *cp != '\0'; cp++) { 60087c478bd9Sstevel@tonic-gate if (!isalnum(*cp) && *cp != '_') 60097c478bd9Sstevel@tonic-gate return (B_FALSE); 60107c478bd9Sstevel@tonic-gate } 60117c478bd9Sstevel@tonic-gate 60127c478bd9Sstevel@tonic-gate return (B_TRUE); 60137c478bd9Sstevel@tonic-gate } 60147c478bd9Sstevel@tonic-gate 60157c478bd9Sstevel@tonic-gate /* 60167c478bd9Sstevel@tonic-gate * ddi_create_minor_common: Create a ddi_minor_data structure and 60177c478bd9Sstevel@tonic-gate * attach it to the given devinfo node. 60187c478bd9Sstevel@tonic-gate */ 60197c478bd9Sstevel@tonic-gate 60207c478bd9Sstevel@tonic-gate int 60217c478bd9Sstevel@tonic-gate ddi_create_minor_common(dev_info_t *dip, char *name, int spec_type, 60227c478bd9Sstevel@tonic-gate minor_t minor_num, char *node_type, int flag, ddi_minor_type mtype, 60237c478bd9Sstevel@tonic-gate const char *read_priv, const char *write_priv, mode_t priv_mode) 60247c478bd9Sstevel@tonic-gate { 60257c478bd9Sstevel@tonic-gate struct ddi_minor_data *dmdp; 60267c478bd9Sstevel@tonic-gate major_t major; 60277c478bd9Sstevel@tonic-gate 60287c478bd9Sstevel@tonic-gate if (spec_type != S_IFCHR && spec_type != S_IFBLK) 60297c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 60307c478bd9Sstevel@tonic-gate 60317c478bd9Sstevel@tonic-gate if (name == NULL) 60327c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 60337c478bd9Sstevel@tonic-gate 60347c478bd9Sstevel@tonic-gate /* 60357c478bd9Sstevel@tonic-gate * Log a message if the minor number the driver is creating 60367c478bd9Sstevel@tonic-gate * is not expressible on the on-disk filesystem (currently 60377c478bd9Sstevel@tonic-gate * this is limited to 18 bits both by UFS). The device can 60387c478bd9Sstevel@tonic-gate * be opened via devfs, but not by device special files created 60397c478bd9Sstevel@tonic-gate * via mknod(). 60407c478bd9Sstevel@tonic-gate */ 60417c478bd9Sstevel@tonic-gate if (minor_num > L_MAXMIN32) { 60427c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 60437c478bd9Sstevel@tonic-gate "%s%d:%s minor 0x%x too big for 32-bit applications", 60447c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), 60457c478bd9Sstevel@tonic-gate name, minor_num); 60467c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 60477c478bd9Sstevel@tonic-gate } 60487c478bd9Sstevel@tonic-gate 60497c478bd9Sstevel@tonic-gate /* dip must be bound and attached */ 60507c478bd9Sstevel@tonic-gate major = ddi_driver_major(dip); 6051a204de77Scth ASSERT(major != DDI_MAJOR_T_NONE); 60527c478bd9Sstevel@tonic-gate 60537c478bd9Sstevel@tonic-gate /* 60547c478bd9Sstevel@tonic-gate * Default node_type to DDI_PSEUDO and issue notice in debug mode 60557c478bd9Sstevel@tonic-gate */ 60567c478bd9Sstevel@tonic-gate if (node_type == NULL) { 60577c478bd9Sstevel@tonic-gate node_type = DDI_PSEUDO; 60587c478bd9Sstevel@tonic-gate NDI_CONFIG_DEBUG((CE_NOTE, "!illegal node_type NULL for %s%d " 60597c478bd9Sstevel@tonic-gate " minor node %s; default to DDI_PSEUDO", 60607c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), name)); 60617c478bd9Sstevel@tonic-gate } 60627c478bd9Sstevel@tonic-gate 60637c478bd9Sstevel@tonic-gate /* 60647c478bd9Sstevel@tonic-gate * If the driver is a network driver, ensure that the name falls within 60657c478bd9Sstevel@tonic-gate * the interface naming constraints specified by PSARC/2003/375. 60667c478bd9Sstevel@tonic-gate */ 60677c478bd9Sstevel@tonic-gate if (strcmp(node_type, DDI_NT_NET) == 0) { 60687c478bd9Sstevel@tonic-gate if (!verify_name(name)) 60697c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 60707c478bd9Sstevel@tonic-gate 60717c478bd9Sstevel@tonic-gate if (mtype == DDM_MINOR) { 60727c478bd9Sstevel@tonic-gate struct devnames *dnp = &devnamesp[major]; 60737c478bd9Sstevel@tonic-gate 60747c478bd9Sstevel@tonic-gate /* Mark driver as a network driver */ 60757c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 60767c478bd9Sstevel@tonic-gate dnp->dn_flags |= DN_NETWORK_DRIVER; 6077095be824SCathy Zhou 6078095be824SCathy Zhou /* 6079095be824SCathy Zhou * If this minor node is created during the device 6080095be824SCathy Zhou * attachment, this is a physical network device. 6081095be824SCathy Zhou * Mark the driver as a physical network driver. 6082095be824SCathy Zhou */ 6083095be824SCathy Zhou if (DEVI_IS_ATTACHING(dip)) 6084095be824SCathy Zhou dnp->dn_flags |= DN_NETWORK_PHYSDRIVER; 60857c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 60867c478bd9Sstevel@tonic-gate } 60877c478bd9Sstevel@tonic-gate } 60887c478bd9Sstevel@tonic-gate 60897c478bd9Sstevel@tonic-gate if (mtype == DDM_MINOR) { 60907c478bd9Sstevel@tonic-gate if (derive_devi_class(dip, node_type, KM_NOSLEEP) != 60917c478bd9Sstevel@tonic-gate DDI_SUCCESS) 60927c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 60937c478bd9Sstevel@tonic-gate } 60947c478bd9Sstevel@tonic-gate 60957c478bd9Sstevel@tonic-gate /* 60967c478bd9Sstevel@tonic-gate * Take care of minor number information for the node. 60977c478bd9Sstevel@tonic-gate */ 60987c478bd9Sstevel@tonic-gate 60997c478bd9Sstevel@tonic-gate if ((dmdp = kmem_zalloc(sizeof (struct ddi_minor_data), 61007c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 61017c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 61027c478bd9Sstevel@tonic-gate } 61037c478bd9Sstevel@tonic-gate if ((dmdp->ddm_name = i_ddi_strdup(name, KM_NOSLEEP)) == NULL) { 61047c478bd9Sstevel@tonic-gate kmem_free(dmdp, sizeof (struct ddi_minor_data)); 61057c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 61067c478bd9Sstevel@tonic-gate } 61077c478bd9Sstevel@tonic-gate dmdp->dip = dip; 61087c478bd9Sstevel@tonic-gate dmdp->ddm_dev = makedevice(major, minor_num); 61097c478bd9Sstevel@tonic-gate dmdp->ddm_spec_type = spec_type; 61107c478bd9Sstevel@tonic-gate dmdp->ddm_node_type = node_type; 61117c478bd9Sstevel@tonic-gate dmdp->type = mtype; 61127c478bd9Sstevel@tonic-gate if (flag & CLONE_DEV) { 61137c478bd9Sstevel@tonic-gate dmdp->type = DDM_ALIAS; 61147c478bd9Sstevel@tonic-gate dmdp->ddm_dev = makedevice(ddi_driver_major(clone_dip), major); 61157c478bd9Sstevel@tonic-gate } 61167c478bd9Sstevel@tonic-gate if (flag & PRIVONLY_DEV) { 61177c478bd9Sstevel@tonic-gate dmdp->ddm_flags |= DM_NO_FSPERM; 61187c478bd9Sstevel@tonic-gate } 61197c478bd9Sstevel@tonic-gate if (read_priv || write_priv) { 61207c478bd9Sstevel@tonic-gate dmdp->ddm_node_priv = 61217c478bd9Sstevel@tonic-gate devpolicy_priv_by_name(read_priv, write_priv); 61227c478bd9Sstevel@tonic-gate } 61237c478bd9Sstevel@tonic-gate dmdp->ddm_priv_mode = priv_mode; 61247c478bd9Sstevel@tonic-gate 61257c478bd9Sstevel@tonic-gate ddi_append_minor_node(dip, dmdp); 61267c478bd9Sstevel@tonic-gate 61277c478bd9Sstevel@tonic-gate /* 61287c478bd9Sstevel@tonic-gate * only log ddi_create_minor_node() calls which occur 61297c478bd9Sstevel@tonic-gate * outside the scope of attach(9e)/detach(9e) reconfigurations 61307c478bd9Sstevel@tonic-gate */ 61317b3700d1Sszhou if (!(DEVI_IS_ATTACHING(dip) || DEVI_IS_DETACHING(dip)) && 61327b3700d1Sszhou mtype != DDM_INTERNAL_PATH) { 61337c478bd9Sstevel@tonic-gate (void) i_log_devfs_minor_create(dip, name); 61347c478bd9Sstevel@tonic-gate } 61357c478bd9Sstevel@tonic-gate 61367c478bd9Sstevel@tonic-gate /* 61377c478bd9Sstevel@tonic-gate * Check if any dacf rules match the creation of this minor node 61387c478bd9Sstevel@tonic-gate */ 61397c478bd9Sstevel@tonic-gate dacfc_match_create_minor(name, node_type, dip, dmdp, flag); 61407c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 61417c478bd9Sstevel@tonic-gate } 61427c478bd9Sstevel@tonic-gate 61437c478bd9Sstevel@tonic-gate int 61447c478bd9Sstevel@tonic-gate ddi_create_minor_node(dev_info_t *dip, char *name, int spec_type, 61457c478bd9Sstevel@tonic-gate minor_t minor_num, char *node_type, int flag) 61467c478bd9Sstevel@tonic-gate { 61477c478bd9Sstevel@tonic-gate return (ddi_create_minor_common(dip, name, spec_type, minor_num, 61487c478bd9Sstevel@tonic-gate node_type, flag, DDM_MINOR, NULL, NULL, 0)); 61497c478bd9Sstevel@tonic-gate } 61507c478bd9Sstevel@tonic-gate 61517c478bd9Sstevel@tonic-gate int 61527c478bd9Sstevel@tonic-gate ddi_create_priv_minor_node(dev_info_t *dip, char *name, int spec_type, 61537c478bd9Sstevel@tonic-gate minor_t minor_num, char *node_type, int flag, 61547c478bd9Sstevel@tonic-gate const char *rdpriv, const char *wrpriv, mode_t priv_mode) 61557c478bd9Sstevel@tonic-gate { 61567c478bd9Sstevel@tonic-gate return (ddi_create_minor_common(dip, name, spec_type, minor_num, 61577c478bd9Sstevel@tonic-gate node_type, flag, DDM_MINOR, rdpriv, wrpriv, priv_mode)); 61587c478bd9Sstevel@tonic-gate } 61597c478bd9Sstevel@tonic-gate 61607c478bd9Sstevel@tonic-gate int 61617c478bd9Sstevel@tonic-gate ddi_create_default_minor_node(dev_info_t *dip, char *name, int spec_type, 61627c478bd9Sstevel@tonic-gate minor_t minor_num, char *node_type, int flag) 61637c478bd9Sstevel@tonic-gate { 61647c478bd9Sstevel@tonic-gate return (ddi_create_minor_common(dip, name, spec_type, minor_num, 61657c478bd9Sstevel@tonic-gate node_type, flag, DDM_DEFAULT, NULL, NULL, 0)); 61667c478bd9Sstevel@tonic-gate } 61677c478bd9Sstevel@tonic-gate 61687c478bd9Sstevel@tonic-gate /* 61697c478bd9Sstevel@tonic-gate * Internal (non-ddi) routine for drivers to export names known 61707c478bd9Sstevel@tonic-gate * to the kernel (especially ddi_pathname_to_dev_t and friends) 61717c478bd9Sstevel@tonic-gate * but not exported externally to /dev 61727c478bd9Sstevel@tonic-gate */ 61737c478bd9Sstevel@tonic-gate int 61747c478bd9Sstevel@tonic-gate ddi_create_internal_pathname(dev_info_t *dip, char *name, int spec_type, 61757c478bd9Sstevel@tonic-gate minor_t minor_num) 61767c478bd9Sstevel@tonic-gate { 61777c478bd9Sstevel@tonic-gate return (ddi_create_minor_common(dip, name, spec_type, minor_num, 61787c478bd9Sstevel@tonic-gate "internal", 0, DDM_INTERNAL_PATH, NULL, NULL, 0)); 61797c478bd9Sstevel@tonic-gate } 61807c478bd9Sstevel@tonic-gate 61817c478bd9Sstevel@tonic-gate void 61827c478bd9Sstevel@tonic-gate ddi_remove_minor_node(dev_info_t *dip, char *name) 61837c478bd9Sstevel@tonic-gate { 6184b9ccdc5aScth int circ; 6185b9ccdc5aScth struct ddi_minor_data *dmdp, *dmdp1; 6186b9ccdc5aScth struct ddi_minor_data **dmdp_prev; 61877c478bd9Sstevel@tonic-gate 6188b9ccdc5aScth ndi_devi_enter(dip, &circ); 61897c478bd9Sstevel@tonic-gate dmdp_prev = &DEVI(dip)->devi_minor; 61907c478bd9Sstevel@tonic-gate dmdp = DEVI(dip)->devi_minor; 61917c478bd9Sstevel@tonic-gate while (dmdp != NULL) { 61927c478bd9Sstevel@tonic-gate dmdp1 = dmdp->next; 61937c478bd9Sstevel@tonic-gate if ((name == NULL || (dmdp->ddm_name != NULL && 61947c478bd9Sstevel@tonic-gate strcmp(name, dmdp->ddm_name) == 0))) { 61957c478bd9Sstevel@tonic-gate if (dmdp->ddm_name != NULL) { 61967b3700d1Sszhou if (dmdp->type != DDM_INTERNAL_PATH) 61977b3700d1Sszhou (void) i_log_devfs_minor_remove(dip, 61987b3700d1Sszhou dmdp->ddm_name); 61997c478bd9Sstevel@tonic-gate kmem_free(dmdp->ddm_name, 62007c478bd9Sstevel@tonic-gate strlen(dmdp->ddm_name) + 1); 62017c478bd9Sstevel@tonic-gate } 62027c478bd9Sstevel@tonic-gate /* 62037c478bd9Sstevel@tonic-gate * Release device privilege, if any. 62047c478bd9Sstevel@tonic-gate * Release dacf client data associated with this minor 62057c478bd9Sstevel@tonic-gate * node by storing NULL. 62067c478bd9Sstevel@tonic-gate */ 62077c478bd9Sstevel@tonic-gate if (dmdp->ddm_node_priv) 62087c478bd9Sstevel@tonic-gate dpfree(dmdp->ddm_node_priv); 62097c478bd9Sstevel@tonic-gate dacf_store_info((dacf_infohdl_t)dmdp, NULL); 62107c478bd9Sstevel@tonic-gate kmem_free(dmdp, sizeof (struct ddi_minor_data)); 62117c478bd9Sstevel@tonic-gate *dmdp_prev = dmdp1; 62127c478bd9Sstevel@tonic-gate /* 62137c478bd9Sstevel@tonic-gate * OK, we found it, so get out now -- if we drive on, 62147c478bd9Sstevel@tonic-gate * we will strcmp against garbage. See 1139209. 62157c478bd9Sstevel@tonic-gate */ 62167c478bd9Sstevel@tonic-gate if (name != NULL) 62177c478bd9Sstevel@tonic-gate break; 62187c478bd9Sstevel@tonic-gate } else { 62197c478bd9Sstevel@tonic-gate dmdp_prev = &dmdp->next; 62207c478bd9Sstevel@tonic-gate } 62217c478bd9Sstevel@tonic-gate dmdp = dmdp1; 62227c478bd9Sstevel@tonic-gate } 6223b9ccdc5aScth ndi_devi_exit(dip, circ); 62247c478bd9Sstevel@tonic-gate } 62257c478bd9Sstevel@tonic-gate 62267c478bd9Sstevel@tonic-gate 62277c478bd9Sstevel@tonic-gate int 62287c478bd9Sstevel@tonic-gate ddi_in_panic() 62297c478bd9Sstevel@tonic-gate { 62307c478bd9Sstevel@tonic-gate return (panicstr != NULL); 62317c478bd9Sstevel@tonic-gate } 62327c478bd9Sstevel@tonic-gate 62337c478bd9Sstevel@tonic-gate 62347c478bd9Sstevel@tonic-gate /* 62357c478bd9Sstevel@tonic-gate * Find first bit set in a mask (returned counting from 1 up) 62367c478bd9Sstevel@tonic-gate */ 62377c478bd9Sstevel@tonic-gate 62387c478bd9Sstevel@tonic-gate int 62397c478bd9Sstevel@tonic-gate ddi_ffs(long mask) 62407c478bd9Sstevel@tonic-gate { 62417c478bd9Sstevel@tonic-gate return (ffs(mask)); 62427c478bd9Sstevel@tonic-gate } 62437c478bd9Sstevel@tonic-gate 62447c478bd9Sstevel@tonic-gate /* 62457c478bd9Sstevel@tonic-gate * Find last bit set. Take mask and clear 62467c478bd9Sstevel@tonic-gate * all but the most significant bit, and 62477c478bd9Sstevel@tonic-gate * then let ffs do the rest of the work. 62487c478bd9Sstevel@tonic-gate * 62497c478bd9Sstevel@tonic-gate * Algorithm courtesy of Steve Chessin. 62507c478bd9Sstevel@tonic-gate */ 62517c478bd9Sstevel@tonic-gate 62527c478bd9Sstevel@tonic-gate int 62537c478bd9Sstevel@tonic-gate ddi_fls(long mask) 62547c478bd9Sstevel@tonic-gate { 62557c478bd9Sstevel@tonic-gate while (mask) { 62567c478bd9Sstevel@tonic-gate long nx; 62577c478bd9Sstevel@tonic-gate 62587c478bd9Sstevel@tonic-gate if ((nx = (mask & (mask - 1))) == 0) 62597c478bd9Sstevel@tonic-gate break; 62607c478bd9Sstevel@tonic-gate mask = nx; 62617c478bd9Sstevel@tonic-gate } 62627c478bd9Sstevel@tonic-gate return (ffs(mask)); 62637c478bd9Sstevel@tonic-gate } 62647c478bd9Sstevel@tonic-gate 62657c478bd9Sstevel@tonic-gate /* 62664c06356bSdh * The ddi_soft_state_* routines comprise generic storage management utilities 62674c06356bSdh * for driver soft state structures (in "the old days," this was done with 62684c06356bSdh * statically sized array - big systems and dynamic loading and unloading 62694c06356bSdh * make heap allocation more attractive). 62707c478bd9Sstevel@tonic-gate */ 62717c478bd9Sstevel@tonic-gate 62727c478bd9Sstevel@tonic-gate /* 62737c478bd9Sstevel@tonic-gate * Allocate a set of pointers to 'n_items' objects of size 'size' 62747c478bd9Sstevel@tonic-gate * bytes. Each pointer is initialized to nil. 62757c478bd9Sstevel@tonic-gate * 62767c478bd9Sstevel@tonic-gate * The 'size' and 'n_items' values are stashed in the opaque 62777c478bd9Sstevel@tonic-gate * handle returned to the caller. 62787c478bd9Sstevel@tonic-gate * 62797c478bd9Sstevel@tonic-gate * This implementation interprets 'set of pointers' to mean 'array 62807c478bd9Sstevel@tonic-gate * of pointers' but note that nothing in the interface definition 62817c478bd9Sstevel@tonic-gate * precludes an implementation that uses, for example, a linked list. 62827c478bd9Sstevel@tonic-gate * However there should be a small efficiency gain from using an array 62837c478bd9Sstevel@tonic-gate * at lookup time. 62847c478bd9Sstevel@tonic-gate * 62857c478bd9Sstevel@tonic-gate * NOTE As an optimization, we make our growable array allocations in 62867c478bd9Sstevel@tonic-gate * powers of two (bytes), since that's how much kmem_alloc (currently) 62877c478bd9Sstevel@tonic-gate * gives us anyway. It should save us some free/realloc's .. 62887c478bd9Sstevel@tonic-gate * 62897c478bd9Sstevel@tonic-gate * As a further optimization, we make the growable array start out 62907c478bd9Sstevel@tonic-gate * with MIN_N_ITEMS in it. 62917c478bd9Sstevel@tonic-gate */ 62927c478bd9Sstevel@tonic-gate 62937c478bd9Sstevel@tonic-gate #define MIN_N_ITEMS 8 /* 8 void *'s == 32 bytes */ 62947c478bd9Sstevel@tonic-gate 62957c478bd9Sstevel@tonic-gate int 62967c478bd9Sstevel@tonic-gate ddi_soft_state_init(void **state_p, size_t size, size_t n_items) 62977c478bd9Sstevel@tonic-gate { 62984c06356bSdh i_ddi_soft_state *ss; 62997c478bd9Sstevel@tonic-gate 63004c06356bSdh if (state_p == NULL || size == 0) 63017c478bd9Sstevel@tonic-gate return (EINVAL); 63027c478bd9Sstevel@tonic-gate 63037c478bd9Sstevel@tonic-gate ss = kmem_zalloc(sizeof (*ss), KM_SLEEP); 63047c478bd9Sstevel@tonic-gate mutex_init(&ss->lock, NULL, MUTEX_DRIVER, NULL); 63057c478bd9Sstevel@tonic-gate ss->size = size; 63067c478bd9Sstevel@tonic-gate 63077c478bd9Sstevel@tonic-gate if (n_items < MIN_N_ITEMS) 63087c478bd9Sstevel@tonic-gate ss->n_items = MIN_N_ITEMS; 63097c478bd9Sstevel@tonic-gate else { 63107c478bd9Sstevel@tonic-gate int bitlog; 63117c478bd9Sstevel@tonic-gate 63127c478bd9Sstevel@tonic-gate if ((bitlog = ddi_fls(n_items)) == ddi_ffs(n_items)) 63137c478bd9Sstevel@tonic-gate bitlog--; 63147c478bd9Sstevel@tonic-gate ss->n_items = 1 << bitlog; 63157c478bd9Sstevel@tonic-gate } 63167c478bd9Sstevel@tonic-gate 63177c478bd9Sstevel@tonic-gate ASSERT(ss->n_items >= n_items); 63187c478bd9Sstevel@tonic-gate 63197c478bd9Sstevel@tonic-gate ss->array = kmem_zalloc(ss->n_items * sizeof (void *), KM_SLEEP); 63207c478bd9Sstevel@tonic-gate 63217c478bd9Sstevel@tonic-gate *state_p = ss; 63227c478bd9Sstevel@tonic-gate return (0); 63237c478bd9Sstevel@tonic-gate } 63247c478bd9Sstevel@tonic-gate 63257c478bd9Sstevel@tonic-gate /* 63267c478bd9Sstevel@tonic-gate * Allocate a state structure of size 'size' to be associated 63277c478bd9Sstevel@tonic-gate * with item 'item'. 63287c478bd9Sstevel@tonic-gate * 63297c478bd9Sstevel@tonic-gate * In this implementation, the array is extended to 63307c478bd9Sstevel@tonic-gate * allow the requested offset, if needed. 63317c478bd9Sstevel@tonic-gate */ 63327c478bd9Sstevel@tonic-gate int 63337c478bd9Sstevel@tonic-gate ddi_soft_state_zalloc(void *state, int item) 63347c478bd9Sstevel@tonic-gate { 63354c06356bSdh i_ddi_soft_state *ss = (i_ddi_soft_state *)state; 63364c06356bSdh void **array; 63374c06356bSdh void *new_element; 63387c478bd9Sstevel@tonic-gate 63394c06356bSdh if ((state == NULL) || (item < 0)) 63407c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 63417c478bd9Sstevel@tonic-gate 63427c478bd9Sstevel@tonic-gate mutex_enter(&ss->lock); 63437c478bd9Sstevel@tonic-gate if (ss->size == 0) { 63447c478bd9Sstevel@tonic-gate mutex_exit(&ss->lock); 63457c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ddi_soft_state_zalloc: bad handle: %s", 63467c478bd9Sstevel@tonic-gate mod_containing_pc(caller())); 63477c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 63487c478bd9Sstevel@tonic-gate } 63497c478bd9Sstevel@tonic-gate 63507c478bd9Sstevel@tonic-gate array = ss->array; /* NULL if ss->n_items == 0 */ 63517c478bd9Sstevel@tonic-gate ASSERT(ss->n_items != 0 && array != NULL); 63527c478bd9Sstevel@tonic-gate 63537c478bd9Sstevel@tonic-gate /* 63547c478bd9Sstevel@tonic-gate * refuse to tread on an existing element 63557c478bd9Sstevel@tonic-gate */ 63567c478bd9Sstevel@tonic-gate if (item < ss->n_items && array[item] != NULL) { 63577c478bd9Sstevel@tonic-gate mutex_exit(&ss->lock); 63587c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 63597c478bd9Sstevel@tonic-gate } 63607c478bd9Sstevel@tonic-gate 63617c478bd9Sstevel@tonic-gate /* 63627c478bd9Sstevel@tonic-gate * Allocate a new element to plug in 63637c478bd9Sstevel@tonic-gate */ 63647c478bd9Sstevel@tonic-gate new_element = kmem_zalloc(ss->size, KM_SLEEP); 63657c478bd9Sstevel@tonic-gate 63667c478bd9Sstevel@tonic-gate /* 63677c478bd9Sstevel@tonic-gate * Check if the array is big enough, if not, grow it. 63687c478bd9Sstevel@tonic-gate */ 63697c478bd9Sstevel@tonic-gate if (item >= ss->n_items) { 63704c06356bSdh void **new_array; 63714c06356bSdh size_t new_n_items; 63724c06356bSdh struct i_ddi_soft_state *dirty; 63737c478bd9Sstevel@tonic-gate 63747c478bd9Sstevel@tonic-gate /* 63757c478bd9Sstevel@tonic-gate * Allocate a new array of the right length, copy 63767c478bd9Sstevel@tonic-gate * all the old pointers to the new array, then 63777c478bd9Sstevel@tonic-gate * if it exists at all, put the old array on the 63787c478bd9Sstevel@tonic-gate * dirty list. 63797c478bd9Sstevel@tonic-gate * 63807c478bd9Sstevel@tonic-gate * Note that we can't kmem_free() the old array. 63817c478bd9Sstevel@tonic-gate * 63827c478bd9Sstevel@tonic-gate * Why -- well the 'get' operation is 'mutex-free', so we 63837c478bd9Sstevel@tonic-gate * can't easily catch a suspended thread that is just about 63847c478bd9Sstevel@tonic-gate * to dereference the array we just grew out of. So we 63857c478bd9Sstevel@tonic-gate * cons up a header and put it on a list of 'dirty' 63867c478bd9Sstevel@tonic-gate * pointer arrays. (Dirty in the sense that there may 63877c478bd9Sstevel@tonic-gate * be suspended threads somewhere that are in the middle 63887c478bd9Sstevel@tonic-gate * of referencing them). Fortunately, we -can- garbage 63897c478bd9Sstevel@tonic-gate * collect it all at ddi_soft_state_fini time. 63907c478bd9Sstevel@tonic-gate */ 63917c478bd9Sstevel@tonic-gate new_n_items = ss->n_items; 63927c478bd9Sstevel@tonic-gate while (new_n_items < (1 + item)) 63937c478bd9Sstevel@tonic-gate new_n_items <<= 1; /* double array size .. */ 63947c478bd9Sstevel@tonic-gate 63957c478bd9Sstevel@tonic-gate ASSERT(new_n_items >= (1 + item)); /* sanity check! */ 63967c478bd9Sstevel@tonic-gate 63977c478bd9Sstevel@tonic-gate new_array = kmem_zalloc(new_n_items * sizeof (void *), 63987c478bd9Sstevel@tonic-gate KM_SLEEP); 63997c478bd9Sstevel@tonic-gate /* 64007c478bd9Sstevel@tonic-gate * Copy the pointers into the new array 64017c478bd9Sstevel@tonic-gate */ 64027c478bd9Sstevel@tonic-gate bcopy(array, new_array, ss->n_items * sizeof (void *)); 64037c478bd9Sstevel@tonic-gate 64047c478bd9Sstevel@tonic-gate /* 64057c478bd9Sstevel@tonic-gate * Save the old array on the dirty list 64067c478bd9Sstevel@tonic-gate */ 64077c478bd9Sstevel@tonic-gate dirty = kmem_zalloc(sizeof (*dirty), KM_SLEEP); 64087c478bd9Sstevel@tonic-gate dirty->array = ss->array; 64097c478bd9Sstevel@tonic-gate dirty->n_items = ss->n_items; 64107c478bd9Sstevel@tonic-gate dirty->next = ss->next; 64117c478bd9Sstevel@tonic-gate ss->next = dirty; 64127c478bd9Sstevel@tonic-gate 64137c478bd9Sstevel@tonic-gate ss->array = (array = new_array); 64147c478bd9Sstevel@tonic-gate ss->n_items = new_n_items; 64157c478bd9Sstevel@tonic-gate } 64167c478bd9Sstevel@tonic-gate 64177c478bd9Sstevel@tonic-gate ASSERT(array != NULL && item < ss->n_items && array[item] == NULL); 64187c478bd9Sstevel@tonic-gate 64197c478bd9Sstevel@tonic-gate array[item] = new_element; 64207c478bd9Sstevel@tonic-gate 64217c478bd9Sstevel@tonic-gate mutex_exit(&ss->lock); 64227c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 64237c478bd9Sstevel@tonic-gate } 64247c478bd9Sstevel@tonic-gate 64257c478bd9Sstevel@tonic-gate /* 64267c478bd9Sstevel@tonic-gate * Fetch a pointer to the allocated soft state structure. 64277c478bd9Sstevel@tonic-gate * 64287c478bd9Sstevel@tonic-gate * This is designed to be cheap. 64297c478bd9Sstevel@tonic-gate * 64307c478bd9Sstevel@tonic-gate * There's an argument that there should be more checking for 64317c478bd9Sstevel@tonic-gate * nil pointers and out of bounds on the array.. but we do a lot 64327c478bd9Sstevel@tonic-gate * of that in the alloc/free routines. 64337c478bd9Sstevel@tonic-gate * 64347c478bd9Sstevel@tonic-gate * An array has the convenience that we don't need to lock read-access 64357c478bd9Sstevel@tonic-gate * to it c.f. a linked list. However our "expanding array" strategy 64367c478bd9Sstevel@tonic-gate * means that we should hold a readers lock on the i_ddi_soft_state 64377c478bd9Sstevel@tonic-gate * structure. 64387c478bd9Sstevel@tonic-gate * 64397c478bd9Sstevel@tonic-gate * However, from a performance viewpoint, we need to do it without 64407c478bd9Sstevel@tonic-gate * any locks at all -- this also makes it a leaf routine. The algorithm 64417c478bd9Sstevel@tonic-gate * is 'lock-free' because we only discard the pointer arrays at 64427c478bd9Sstevel@tonic-gate * ddi_soft_state_fini() time. 64437c478bd9Sstevel@tonic-gate */ 64447c478bd9Sstevel@tonic-gate void * 64457c478bd9Sstevel@tonic-gate ddi_get_soft_state(void *state, int item) 64467c478bd9Sstevel@tonic-gate { 64474c06356bSdh i_ddi_soft_state *ss = (i_ddi_soft_state *)state; 64487c478bd9Sstevel@tonic-gate 64494c06356bSdh ASSERT((ss != NULL) && (item >= 0)); 64507c478bd9Sstevel@tonic-gate 64517c478bd9Sstevel@tonic-gate if (item < ss->n_items && ss->array != NULL) 64527c478bd9Sstevel@tonic-gate return (ss->array[item]); 64537c478bd9Sstevel@tonic-gate return (NULL); 64547c478bd9Sstevel@tonic-gate } 64557c478bd9Sstevel@tonic-gate 64567c478bd9Sstevel@tonic-gate /* 64577c478bd9Sstevel@tonic-gate * Free the state structure corresponding to 'item.' Freeing an 64587c478bd9Sstevel@tonic-gate * element that has either gone or was never allocated is not 64597c478bd9Sstevel@tonic-gate * considered an error. Note that we free the state structure, but 64607c478bd9Sstevel@tonic-gate * we don't shrink our pointer array, or discard 'dirty' arrays, 64617c478bd9Sstevel@tonic-gate * since even a few pointers don't really waste too much memory. 64627c478bd9Sstevel@tonic-gate * 64637c478bd9Sstevel@tonic-gate * Passing an item number that is out of bounds, or a null pointer will 64647c478bd9Sstevel@tonic-gate * provoke an error message. 64657c478bd9Sstevel@tonic-gate */ 64667c478bd9Sstevel@tonic-gate void 64677c478bd9Sstevel@tonic-gate ddi_soft_state_free(void *state, int item) 64687c478bd9Sstevel@tonic-gate { 64694c06356bSdh i_ddi_soft_state *ss = (i_ddi_soft_state *)state; 64704c06356bSdh void **array; 64714c06356bSdh void *element; 64724c06356bSdh static char msg[] = "ddi_soft_state_free:"; 64737c478bd9Sstevel@tonic-gate 64744c06356bSdh if (ss == NULL) { 64757c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s null handle: %s", 64767c478bd9Sstevel@tonic-gate msg, mod_containing_pc(caller())); 64777c478bd9Sstevel@tonic-gate return; 64787c478bd9Sstevel@tonic-gate } 64797c478bd9Sstevel@tonic-gate 64807c478bd9Sstevel@tonic-gate element = NULL; 64817c478bd9Sstevel@tonic-gate 64827c478bd9Sstevel@tonic-gate mutex_enter(&ss->lock); 64837c478bd9Sstevel@tonic-gate 64847c478bd9Sstevel@tonic-gate if ((array = ss->array) == NULL || ss->size == 0) { 64857c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s bad handle: %s", 64867c478bd9Sstevel@tonic-gate msg, mod_containing_pc(caller())); 64877c478bd9Sstevel@tonic-gate } else if (item < 0 || item >= ss->n_items) { 64887c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s item %d not in range [0..%lu]: %s", 64897c478bd9Sstevel@tonic-gate msg, item, ss->n_items - 1, mod_containing_pc(caller())); 64907c478bd9Sstevel@tonic-gate } else if (array[item] != NULL) { 64917c478bd9Sstevel@tonic-gate element = array[item]; 64927c478bd9Sstevel@tonic-gate array[item] = NULL; 64937c478bd9Sstevel@tonic-gate } 64947c478bd9Sstevel@tonic-gate 64957c478bd9Sstevel@tonic-gate mutex_exit(&ss->lock); 64967c478bd9Sstevel@tonic-gate 64977c478bd9Sstevel@tonic-gate if (element) 64987c478bd9Sstevel@tonic-gate kmem_free(element, ss->size); 64997c478bd9Sstevel@tonic-gate } 65007c478bd9Sstevel@tonic-gate 65017c478bd9Sstevel@tonic-gate /* 65027c478bd9Sstevel@tonic-gate * Free the entire set of pointers, and any 65037c478bd9Sstevel@tonic-gate * soft state structures contained therein. 65047c478bd9Sstevel@tonic-gate * 65057c478bd9Sstevel@tonic-gate * Note that we don't grab the ss->lock mutex, even though 65067c478bd9Sstevel@tonic-gate * we're inspecting the various fields of the data structure. 65077c478bd9Sstevel@tonic-gate * 65087c478bd9Sstevel@tonic-gate * There is an implicit assumption that this routine will 65097c478bd9Sstevel@tonic-gate * never run concurrently with any of the above on this 65107c478bd9Sstevel@tonic-gate * particular state structure i.e. by the time the driver 65117c478bd9Sstevel@tonic-gate * calls this routine, there should be no other threads 65127c478bd9Sstevel@tonic-gate * running in the driver. 65137c478bd9Sstevel@tonic-gate */ 65147c478bd9Sstevel@tonic-gate void 65157c478bd9Sstevel@tonic-gate ddi_soft_state_fini(void **state_p) 65167c478bd9Sstevel@tonic-gate { 65174c06356bSdh i_ddi_soft_state *ss, *dirty; 65184c06356bSdh int item; 65194c06356bSdh static char msg[] = "ddi_soft_state_fini:"; 65207c478bd9Sstevel@tonic-gate 65214c06356bSdh if (state_p == NULL || 65224c06356bSdh (ss = (i_ddi_soft_state *)(*state_p)) == NULL) { 65237c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s null handle: %s", 65247c478bd9Sstevel@tonic-gate msg, mod_containing_pc(caller())); 65257c478bd9Sstevel@tonic-gate return; 65267c478bd9Sstevel@tonic-gate } 65277c478bd9Sstevel@tonic-gate 65287c478bd9Sstevel@tonic-gate if (ss->size == 0) { 65297c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s bad handle: %s", 65307c478bd9Sstevel@tonic-gate msg, mod_containing_pc(caller())); 65317c478bd9Sstevel@tonic-gate return; 65327c478bd9Sstevel@tonic-gate } 65337c478bd9Sstevel@tonic-gate 65347c478bd9Sstevel@tonic-gate if (ss->n_items > 0) { 65357c478bd9Sstevel@tonic-gate for (item = 0; item < ss->n_items; item++) 65367c478bd9Sstevel@tonic-gate ddi_soft_state_free(ss, item); 65377c478bd9Sstevel@tonic-gate kmem_free(ss->array, ss->n_items * sizeof (void *)); 65387c478bd9Sstevel@tonic-gate } 65397c478bd9Sstevel@tonic-gate 65407c478bd9Sstevel@tonic-gate /* 65417c478bd9Sstevel@tonic-gate * Now delete any dirty arrays from previous 'grow' operations 65427c478bd9Sstevel@tonic-gate */ 65437c478bd9Sstevel@tonic-gate for (dirty = ss->next; dirty; dirty = ss->next) { 65447c478bd9Sstevel@tonic-gate ss->next = dirty->next; 65457c478bd9Sstevel@tonic-gate kmem_free(dirty->array, dirty->n_items * sizeof (void *)); 65467c478bd9Sstevel@tonic-gate kmem_free(dirty, sizeof (*dirty)); 65477c478bd9Sstevel@tonic-gate } 65487c478bd9Sstevel@tonic-gate 65497c478bd9Sstevel@tonic-gate mutex_destroy(&ss->lock); 65507c478bd9Sstevel@tonic-gate kmem_free(ss, sizeof (*ss)); 65517c478bd9Sstevel@tonic-gate 65527c478bd9Sstevel@tonic-gate *state_p = NULL; 65537c478bd9Sstevel@tonic-gate } 65547c478bd9Sstevel@tonic-gate 65554c06356bSdh #define SS_N_ITEMS_PER_HASH 16 65564c06356bSdh #define SS_MIN_HASH_SZ 16 65574c06356bSdh #define SS_MAX_HASH_SZ 4096 65584c06356bSdh 65594c06356bSdh int 65604c06356bSdh ddi_soft_state_bystr_init(ddi_soft_state_bystr **state_p, size_t size, 65614c06356bSdh int n_items) 65624c06356bSdh { 65634c06356bSdh i_ddi_soft_state_bystr *sss; 65644c06356bSdh int hash_sz; 65654c06356bSdh 65664c06356bSdh ASSERT(state_p && size && n_items); 65674c06356bSdh if ((state_p == NULL) || (size == 0) || (n_items == 0)) 65684c06356bSdh return (EINVAL); 65694c06356bSdh 65704c06356bSdh /* current implementation is based on hash, convert n_items to hash */ 65714c06356bSdh hash_sz = n_items / SS_N_ITEMS_PER_HASH; 65724c06356bSdh if (hash_sz < SS_MIN_HASH_SZ) 65734c06356bSdh hash_sz = SS_MIN_HASH_SZ; 65744c06356bSdh else if (hash_sz > SS_MAX_HASH_SZ) 65754c06356bSdh hash_sz = SS_MAX_HASH_SZ; 65764c06356bSdh 65774c06356bSdh /* allocate soft_state pool */ 65784c06356bSdh sss = kmem_zalloc(sizeof (*sss), KM_SLEEP); 65794c06356bSdh sss->ss_size = size; 65804c06356bSdh sss->ss_mod_hash = mod_hash_create_strhash("soft_state_bystr", 65814c06356bSdh hash_sz, mod_hash_null_valdtor); 65824c06356bSdh *state_p = (ddi_soft_state_bystr *)sss; 65834c06356bSdh return (0); 65844c06356bSdh } 65854c06356bSdh 65864c06356bSdh int 65874c06356bSdh ddi_soft_state_bystr_zalloc(ddi_soft_state_bystr *state, const char *str) 65884c06356bSdh { 65894c06356bSdh i_ddi_soft_state_bystr *sss = (i_ddi_soft_state_bystr *)state; 65904c06356bSdh void *sso; 65914c06356bSdh char *dup_str; 65924c06356bSdh 65934c06356bSdh ASSERT(sss && str && sss->ss_mod_hash); 65944c06356bSdh if ((sss == NULL) || (str == NULL) || (sss->ss_mod_hash == NULL)) 65954c06356bSdh return (DDI_FAILURE); 65964c06356bSdh sso = kmem_zalloc(sss->ss_size, KM_SLEEP); 65974c06356bSdh dup_str = i_ddi_strdup((char *)str, KM_SLEEP); 65984c06356bSdh if (mod_hash_insert(sss->ss_mod_hash, 65994c06356bSdh (mod_hash_key_t)dup_str, (mod_hash_val_t)sso) == 0) 66004c06356bSdh return (DDI_SUCCESS); 66014c06356bSdh 66024c06356bSdh /* 66034c06356bSdh * The only error from an strhash insert is caused by a duplicate key. 66044c06356bSdh * We refuse to tread on an existing elements, so free and fail. 66054c06356bSdh */ 66064c06356bSdh kmem_free(dup_str, strlen(dup_str) + 1); 66074c06356bSdh kmem_free(sso, sss->ss_size); 66084c06356bSdh return (DDI_FAILURE); 66094c06356bSdh } 66104c06356bSdh 66114c06356bSdh void * 66124c06356bSdh ddi_soft_state_bystr_get(ddi_soft_state_bystr *state, const char *str) 66134c06356bSdh { 66144c06356bSdh i_ddi_soft_state_bystr *sss = (i_ddi_soft_state_bystr *)state; 66154c06356bSdh void *sso; 66164c06356bSdh 66174c06356bSdh ASSERT(sss && str && sss->ss_mod_hash); 66184c06356bSdh if ((sss == NULL) || (str == NULL) || (sss->ss_mod_hash == NULL)) 66194c06356bSdh return (NULL); 66204c06356bSdh 66214c06356bSdh if (mod_hash_find(sss->ss_mod_hash, 66224c06356bSdh (mod_hash_key_t)str, (mod_hash_val_t *)&sso) == 0) 66234c06356bSdh return (sso); 66244c06356bSdh return (NULL); 66254c06356bSdh } 66264c06356bSdh 66274c06356bSdh void 66284c06356bSdh ddi_soft_state_bystr_free(ddi_soft_state_bystr *state, const char *str) 66294c06356bSdh { 66304c06356bSdh i_ddi_soft_state_bystr *sss = (i_ddi_soft_state_bystr *)state; 66314c06356bSdh void *sso; 66324c06356bSdh 66334c06356bSdh ASSERT(sss && str && sss->ss_mod_hash); 66344c06356bSdh if ((sss == NULL) || (str == NULL) || (sss->ss_mod_hash == NULL)) 66354c06356bSdh return; 66364c06356bSdh 66374c06356bSdh (void) mod_hash_remove(sss->ss_mod_hash, 66384c06356bSdh (mod_hash_key_t)str, (mod_hash_val_t *)&sso); 66394c06356bSdh kmem_free(sso, sss->ss_size); 66404c06356bSdh } 66414c06356bSdh 66424c06356bSdh void 66434c06356bSdh ddi_soft_state_bystr_fini(ddi_soft_state_bystr **state_p) 66444c06356bSdh { 66454c06356bSdh i_ddi_soft_state_bystr *sss; 66464c06356bSdh 66474c06356bSdh ASSERT(state_p); 66484c06356bSdh if (state_p == NULL) 66494c06356bSdh return; 66504c06356bSdh 66514c06356bSdh sss = (i_ddi_soft_state_bystr *)(*state_p); 66524c06356bSdh if (sss == NULL) 66534c06356bSdh return; 66544c06356bSdh 66554c06356bSdh ASSERT(sss->ss_mod_hash); 66564c06356bSdh if (sss->ss_mod_hash) { 66574c06356bSdh mod_hash_destroy_strhash(sss->ss_mod_hash); 66584c06356bSdh sss->ss_mod_hash = NULL; 66594c06356bSdh } 66604c06356bSdh 66614c06356bSdh kmem_free(sss, sizeof (*sss)); 66624c06356bSdh *state_p = NULL; 66634c06356bSdh } 66644c06356bSdh 66654c06356bSdh /* 66664c06356bSdh * The ddi_strid_* routines provide string-to-index management utilities. 66674c06356bSdh */ 66684c06356bSdh /* allocate and initialize an strid set */ 66694c06356bSdh int 66704c06356bSdh ddi_strid_init(ddi_strid **strid_p, int n_items) 66714c06356bSdh { 66724c06356bSdh i_ddi_strid *ss; 66734c06356bSdh int hash_sz; 66744c06356bSdh 66754c06356bSdh if (strid_p == NULL) 66764c06356bSdh return (DDI_FAILURE); 66774c06356bSdh 66784c06356bSdh /* current implementation is based on hash, convert n_items to hash */ 66794c06356bSdh hash_sz = n_items / SS_N_ITEMS_PER_HASH; 66804c06356bSdh if (hash_sz < SS_MIN_HASH_SZ) 66814c06356bSdh hash_sz = SS_MIN_HASH_SZ; 66824c06356bSdh else if (hash_sz > SS_MAX_HASH_SZ) 66834c06356bSdh hash_sz = SS_MAX_HASH_SZ; 66844c06356bSdh 66854c06356bSdh ss = kmem_alloc(sizeof (*ss), KM_SLEEP); 66861b115575SJohn Danielson ss->strid_chunksz = n_items; 66871b115575SJohn Danielson ss->strid_spacesz = n_items; 66884c06356bSdh ss->strid_space = id_space_create("strid", 1, n_items); 66894c06356bSdh ss->strid_bystr = mod_hash_create_strhash("strid_bystr", hash_sz, 66904c06356bSdh mod_hash_null_valdtor); 66914c06356bSdh ss->strid_byid = mod_hash_create_idhash("strid_byid", hash_sz, 66924c06356bSdh mod_hash_null_valdtor); 66934c06356bSdh *strid_p = (ddi_strid *)ss; 66944c06356bSdh return (DDI_SUCCESS); 66954c06356bSdh } 66964c06356bSdh 66974c06356bSdh /* allocate an id mapping within the specified set for str, return id */ 66984c06356bSdh static id_t 66991b115575SJohn Danielson i_ddi_strid_alloc(ddi_strid *strid, char *str) 67004c06356bSdh { 67014c06356bSdh i_ddi_strid *ss = (i_ddi_strid *)strid; 67024c06356bSdh id_t id; 67034c06356bSdh char *s; 67044c06356bSdh 67054c06356bSdh ASSERT(ss && str); 67064c06356bSdh if ((ss == NULL) || (str == NULL)) 67074c06356bSdh return (0); 67084c06356bSdh 67094c06356bSdh /* 67104c06356bSdh * Allocate an id using VM_FIRSTFIT in order to keep allocated id 67114c06356bSdh * range as compressed as possible. This is important to minimize 67124c06356bSdh * the amount of space used when the id is used as a ddi_soft_state 67134c06356bSdh * index by the caller. 67144c06356bSdh * 67151b115575SJohn Danielson * If the id list is exhausted, increase the size of the list 67161b115575SJohn Danielson * by the chuck size specified in ddi_strid_init and reattempt 67171b115575SJohn Danielson * the allocation 67184c06356bSdh */ 67191b115575SJohn Danielson if ((id = id_allocff_nosleep(ss->strid_space)) == (id_t)-1) { 67201b115575SJohn Danielson id_space_extend(ss->strid_space, ss->strid_spacesz, 67211b115575SJohn Danielson ss->strid_spacesz + ss->strid_chunksz); 67221b115575SJohn Danielson ss->strid_spacesz += ss->strid_chunksz; 67231b115575SJohn Danielson if ((id = id_allocff_nosleep(ss->strid_space)) == (id_t)-1) 67244c06356bSdh return (0); 67254c06356bSdh } 67264c06356bSdh 67274c06356bSdh /* 67284c06356bSdh * NOTE: since we create and destroy in unison we can save space by 67294c06356bSdh * using bystr key as the byid value. This means destroy must occur 67304c06356bSdh * in (byid, bystr) order. 67314c06356bSdh */ 67324c06356bSdh s = i_ddi_strdup(str, KM_SLEEP); 67334c06356bSdh if (mod_hash_insert(ss->strid_bystr, (mod_hash_key_t)s, 67344c06356bSdh (mod_hash_val_t)(intptr_t)id) != 0) { 67354c06356bSdh ddi_strid_free(strid, id); 67364c06356bSdh return (0); 67374c06356bSdh } 67384c06356bSdh if (mod_hash_insert(ss->strid_byid, (mod_hash_key_t)(intptr_t)id, 67394c06356bSdh (mod_hash_val_t)s) != 0) { 67404c06356bSdh ddi_strid_free(strid, id); 67414c06356bSdh return (0); 67424c06356bSdh } 67434c06356bSdh 67444c06356bSdh /* NOTE: s if freed on mod_hash_destroy by mod_hash_strval_dtor */ 67454c06356bSdh return (id); 67464c06356bSdh } 67474c06356bSdh 67484c06356bSdh /* allocate an id mapping within the specified set for str, return id */ 67494c06356bSdh id_t 67504c06356bSdh ddi_strid_alloc(ddi_strid *strid, char *str) 67514c06356bSdh { 67521b115575SJohn Danielson return (i_ddi_strid_alloc(strid, str)); 67534c06356bSdh } 67544c06356bSdh 67554c06356bSdh /* return the id within the specified strid given the str */ 67564c06356bSdh id_t 67574c06356bSdh ddi_strid_str2id(ddi_strid *strid, char *str) 67584c06356bSdh { 67594c06356bSdh i_ddi_strid *ss = (i_ddi_strid *)strid; 67604c06356bSdh id_t id = 0; 67614c06356bSdh mod_hash_val_t hv; 67624c06356bSdh 67634c06356bSdh ASSERT(ss && str); 67644c06356bSdh if (ss && str && (mod_hash_find(ss->strid_bystr, 67654c06356bSdh (mod_hash_key_t)str, &hv) == 0)) 67664c06356bSdh id = (int)(intptr_t)hv; 67674c06356bSdh return (id); 67684c06356bSdh } 67694c06356bSdh 67704c06356bSdh /* return str within the specified strid given the id */ 67714c06356bSdh char * 67724c06356bSdh ddi_strid_id2str(ddi_strid *strid, id_t id) 67734c06356bSdh { 67744c06356bSdh i_ddi_strid *ss = (i_ddi_strid *)strid; 67754c06356bSdh char *str = NULL; 67764c06356bSdh mod_hash_val_t hv; 67774c06356bSdh 67784c06356bSdh ASSERT(ss && id > 0); 67794c06356bSdh if (ss && (id > 0) && (mod_hash_find(ss->strid_byid, 67804c06356bSdh (mod_hash_key_t)(uintptr_t)id, &hv) == 0)) 67814c06356bSdh str = (char *)hv; 67824c06356bSdh return (str); 67834c06356bSdh } 67844c06356bSdh 67854c06356bSdh /* free the id mapping within the specified strid */ 67864c06356bSdh void 67874c06356bSdh ddi_strid_free(ddi_strid *strid, id_t id) 67884c06356bSdh { 67894c06356bSdh i_ddi_strid *ss = (i_ddi_strid *)strid; 67904c06356bSdh char *str; 67914c06356bSdh 67924c06356bSdh ASSERT(ss && id > 0); 67934c06356bSdh if ((ss == NULL) || (id <= 0)) 67944c06356bSdh return; 67954c06356bSdh 67964c06356bSdh /* bystr key is byid value: destroy order must be (byid, bystr) */ 67974c06356bSdh str = ddi_strid_id2str(strid, id); 67984c06356bSdh (void) mod_hash_destroy(ss->strid_byid, (mod_hash_key_t)(uintptr_t)id); 67994c06356bSdh id_free(ss->strid_space, id); 68004c06356bSdh 68014c06356bSdh if (str) 68024c06356bSdh (void) mod_hash_destroy(ss->strid_bystr, (mod_hash_key_t)str); 68034c06356bSdh } 68044c06356bSdh 68054c06356bSdh /* destroy the strid set */ 68064c06356bSdh void 68074c06356bSdh ddi_strid_fini(ddi_strid **strid_p) 68084c06356bSdh { 68094c06356bSdh i_ddi_strid *ss; 68104c06356bSdh 68114c06356bSdh ASSERT(strid_p); 68124c06356bSdh if (strid_p == NULL) 68134c06356bSdh return; 68144c06356bSdh 68154c06356bSdh ss = (i_ddi_strid *)(*strid_p); 68164c06356bSdh if (ss == NULL) 68174c06356bSdh return; 68184c06356bSdh 68194c06356bSdh /* bystr key is byid value: destroy order must be (byid, bystr) */ 68204c06356bSdh if (ss->strid_byid) 68214c06356bSdh mod_hash_destroy_hash(ss->strid_byid); 68224c06356bSdh if (ss->strid_byid) 68234c06356bSdh mod_hash_destroy_hash(ss->strid_bystr); 68244c06356bSdh if (ss->strid_space) 68254c06356bSdh id_space_destroy(ss->strid_space); 68264c06356bSdh kmem_free(ss, sizeof (*ss)); 68274c06356bSdh *strid_p = NULL; 68284c06356bSdh } 68294c06356bSdh 68307c478bd9Sstevel@tonic-gate /* 6831fe9fe9fbScth * This sets the devi_addr entry in the dev_info structure 'dip' to 'name'. 6832fe9fe9fbScth * Storage is double buffered to prevent updates during devi_addr use - 6833fe9fe9fbScth * double buffering is adaquate for reliable ddi_deviname() consumption. 6834fe9fe9fbScth * The double buffer is not freed until dev_info structure destruction 6835fe9fe9fbScth * (by i_ddi_free_node). 68367c478bd9Sstevel@tonic-gate */ 68377c478bd9Sstevel@tonic-gate void 68387c478bd9Sstevel@tonic-gate ddi_set_name_addr(dev_info_t *dip, char *name) 68397c478bd9Sstevel@tonic-gate { 6840fe9fe9fbScth char *buf = DEVI(dip)->devi_addr_buf; 6841fe9fe9fbScth char *newaddr; 68427c478bd9Sstevel@tonic-gate 6843fe9fe9fbScth if (buf == NULL) { 6844fe9fe9fbScth buf = kmem_zalloc(2 * MAXNAMELEN, KM_SLEEP); 6845fe9fe9fbScth DEVI(dip)->devi_addr_buf = buf; 68467c478bd9Sstevel@tonic-gate } 6847fe9fe9fbScth 6848fe9fe9fbScth if (name) { 6849fe9fe9fbScth ASSERT(strlen(name) < MAXNAMELEN); 6850fe9fe9fbScth newaddr = (DEVI(dip)->devi_addr == buf) ? 6851fe9fe9fbScth (buf + MAXNAMELEN) : buf; 6852fe9fe9fbScth (void) strlcpy(newaddr, name, MAXNAMELEN); 6853fe9fe9fbScth } else 6854fe9fe9fbScth newaddr = NULL; 6855fe9fe9fbScth 6856fe9fe9fbScth DEVI(dip)->devi_addr = newaddr; 68577c478bd9Sstevel@tonic-gate } 68587c478bd9Sstevel@tonic-gate 68597c478bd9Sstevel@tonic-gate char * 68607c478bd9Sstevel@tonic-gate ddi_get_name_addr(dev_info_t *dip) 68617c478bd9Sstevel@tonic-gate { 68627c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_addr); 68637c478bd9Sstevel@tonic-gate } 68647c478bd9Sstevel@tonic-gate 68657c478bd9Sstevel@tonic-gate void 68667c478bd9Sstevel@tonic-gate ddi_set_parent_data(dev_info_t *dip, void *pd) 68677c478bd9Sstevel@tonic-gate { 68687c478bd9Sstevel@tonic-gate DEVI(dip)->devi_parent_data = pd; 68697c478bd9Sstevel@tonic-gate } 68707c478bd9Sstevel@tonic-gate 68717c478bd9Sstevel@tonic-gate void * 68727c478bd9Sstevel@tonic-gate ddi_get_parent_data(dev_info_t *dip) 68737c478bd9Sstevel@tonic-gate { 68747c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_parent_data); 68757c478bd9Sstevel@tonic-gate } 68767c478bd9Sstevel@tonic-gate 68777c478bd9Sstevel@tonic-gate /* 68785c066ec2SJerry Gilliam * ddi_name_to_major: returns the major number of a named module, 68795c066ec2SJerry Gilliam * derived from the current driver alias binding. 68805c066ec2SJerry Gilliam * 68815c066ec2SJerry Gilliam * Caveat: drivers should avoid the use of this function, in particular 68825c066ec2SJerry Gilliam * together with ddi_get_name/ddi_binding name, as per 68835c066ec2SJerry Gilliam * major = ddi_name_to_major(ddi_get_name(devi)); 68845c066ec2SJerry Gilliam * ddi_name_to_major() relies on the state of the device/alias binding, 68855c066ec2SJerry Gilliam * which can and does change dynamically as aliases are administered 68865c066ec2SJerry Gilliam * over time. An attached device instance cannot rely on the major 68875c066ec2SJerry Gilliam * number returned by ddi_name_to_major() to match its own major number. 68885c066ec2SJerry Gilliam * 68895c066ec2SJerry Gilliam * For driver use, ddi_driver_major() reliably returns the major number 68905c066ec2SJerry Gilliam * for the module to which the device was bound at attach time over 68915c066ec2SJerry Gilliam * the life of the instance. 68925c066ec2SJerry Gilliam * major = ddi_driver_major(dev_info_t *) 68937c478bd9Sstevel@tonic-gate */ 68947c478bd9Sstevel@tonic-gate major_t 68957c478bd9Sstevel@tonic-gate ddi_name_to_major(char *name) 68967c478bd9Sstevel@tonic-gate { 68977c478bd9Sstevel@tonic-gate return (mod_name_to_major(name)); 68987c478bd9Sstevel@tonic-gate } 68997c478bd9Sstevel@tonic-gate 69007c478bd9Sstevel@tonic-gate /* 69017c478bd9Sstevel@tonic-gate * ddi_major_to_name: Returns the module name bound to a major number. 69027c478bd9Sstevel@tonic-gate */ 69037c478bd9Sstevel@tonic-gate char * 69047c478bd9Sstevel@tonic-gate ddi_major_to_name(major_t major) 69057c478bd9Sstevel@tonic-gate { 69067c478bd9Sstevel@tonic-gate return (mod_major_to_name(major)); 69077c478bd9Sstevel@tonic-gate } 69087c478bd9Sstevel@tonic-gate 69097c478bd9Sstevel@tonic-gate /* 69107c478bd9Sstevel@tonic-gate * Return the name of the devinfo node pointed at by 'dip' in the buffer 69117c478bd9Sstevel@tonic-gate * pointed at by 'name.' A devinfo node is named as a result of calling 69127c478bd9Sstevel@tonic-gate * ddi_initchild(). 69137c478bd9Sstevel@tonic-gate * 69147c478bd9Sstevel@tonic-gate * Note: the driver must be held before calling this function! 69157c478bd9Sstevel@tonic-gate */ 69167c478bd9Sstevel@tonic-gate char * 69177c478bd9Sstevel@tonic-gate ddi_deviname(dev_info_t *dip, char *name) 69187c478bd9Sstevel@tonic-gate { 69197c478bd9Sstevel@tonic-gate char *addrname; 69207c478bd9Sstevel@tonic-gate char none = '\0'; 69217c478bd9Sstevel@tonic-gate 69227c478bd9Sstevel@tonic-gate if (dip == ddi_root_node()) { 69237c478bd9Sstevel@tonic-gate *name = '\0'; 69247c478bd9Sstevel@tonic-gate return (name); 69257c478bd9Sstevel@tonic-gate } 69267c478bd9Sstevel@tonic-gate 6927f4da9be0Scth if (i_ddi_node_state(dip) < DS_BOUND) { 69287c478bd9Sstevel@tonic-gate addrname = &none; 69297c478bd9Sstevel@tonic-gate } else { 6930f4da9be0Scth /* 6931f4da9be0Scth * Use ddi_get_name_addr() without checking state so we get 6932f4da9be0Scth * a unit-address if we are called after ddi_set_name_addr() 6933f4da9be0Scth * by nexus DDI_CTL_INITCHILD code, but before completing 6934f4da9be0Scth * node promotion to DS_INITIALIZED. We currently have 6935f4da9be0Scth * two situations where we are called in this state: 6936f4da9be0Scth * o For framework processing of a path-oriented alias. 6937f4da9be0Scth * o If a SCSA nexus driver calls ddi_devid_register() 6938f4da9be0Scth * from it's tran_tgt_init(9E) implementation. 6939f4da9be0Scth */ 69407c478bd9Sstevel@tonic-gate addrname = ddi_get_name_addr(dip); 6941f4da9be0Scth if (addrname == NULL) 6942f4da9be0Scth addrname = &none; 69437c478bd9Sstevel@tonic-gate } 69447c478bd9Sstevel@tonic-gate 69457c478bd9Sstevel@tonic-gate if (*addrname == '\0') { 69467c478bd9Sstevel@tonic-gate (void) sprintf(name, "/%s", ddi_node_name(dip)); 69477c478bd9Sstevel@tonic-gate } else { 69487c478bd9Sstevel@tonic-gate (void) sprintf(name, "/%s@%s", ddi_node_name(dip), addrname); 69497c478bd9Sstevel@tonic-gate } 69507c478bd9Sstevel@tonic-gate 69517c478bd9Sstevel@tonic-gate return (name); 69527c478bd9Sstevel@tonic-gate } 69537c478bd9Sstevel@tonic-gate 69547c478bd9Sstevel@tonic-gate /* 69557c478bd9Sstevel@tonic-gate * Spits out the name of device node, typically name@addr, for a given node, 69567c478bd9Sstevel@tonic-gate * using the driver name, not the nodename. 69577c478bd9Sstevel@tonic-gate * 69587c478bd9Sstevel@tonic-gate * Used by match_parent. Not to be used elsewhere. 69597c478bd9Sstevel@tonic-gate */ 69607c478bd9Sstevel@tonic-gate char * 69617c478bd9Sstevel@tonic-gate i_ddi_parname(dev_info_t *dip, char *name) 69627c478bd9Sstevel@tonic-gate { 69637c478bd9Sstevel@tonic-gate char *addrname; 69647c478bd9Sstevel@tonic-gate 69657c478bd9Sstevel@tonic-gate if (dip == ddi_root_node()) { 69667c478bd9Sstevel@tonic-gate *name = '\0'; 69677c478bd9Sstevel@tonic-gate return (name); 69687c478bd9Sstevel@tonic-gate } 69697c478bd9Sstevel@tonic-gate 69707c478bd9Sstevel@tonic-gate ASSERT(i_ddi_node_state(dip) >= DS_INITIALIZED); 69717c478bd9Sstevel@tonic-gate 69727c478bd9Sstevel@tonic-gate if (*(addrname = ddi_get_name_addr(dip)) == '\0') 69737c478bd9Sstevel@tonic-gate (void) sprintf(name, "%s", ddi_binding_name(dip)); 69747c478bd9Sstevel@tonic-gate else 69757c478bd9Sstevel@tonic-gate (void) sprintf(name, "%s@%s", ddi_binding_name(dip), addrname); 69767c478bd9Sstevel@tonic-gate return (name); 69777c478bd9Sstevel@tonic-gate } 69787c478bd9Sstevel@tonic-gate 69797c478bd9Sstevel@tonic-gate static char * 69807c478bd9Sstevel@tonic-gate pathname_work(dev_info_t *dip, char *path) 69817c478bd9Sstevel@tonic-gate { 69827c478bd9Sstevel@tonic-gate char *bp; 69837c478bd9Sstevel@tonic-gate 69847c478bd9Sstevel@tonic-gate if (dip == ddi_root_node()) { 69857c478bd9Sstevel@tonic-gate *path = '\0'; 69867c478bd9Sstevel@tonic-gate return (path); 69877c478bd9Sstevel@tonic-gate } 69887c478bd9Sstevel@tonic-gate (void) pathname_work(ddi_get_parent(dip), path); 69897c478bd9Sstevel@tonic-gate bp = path + strlen(path); 69907c478bd9Sstevel@tonic-gate (void) ddi_deviname(dip, bp); 69917c478bd9Sstevel@tonic-gate return (path); 69927c478bd9Sstevel@tonic-gate } 69937c478bd9Sstevel@tonic-gate 69947c478bd9Sstevel@tonic-gate char * 69957c478bd9Sstevel@tonic-gate ddi_pathname(dev_info_t *dip, char *path) 69967c478bd9Sstevel@tonic-gate { 69977c478bd9Sstevel@tonic-gate return (pathname_work(dip, path)); 69987c478bd9Sstevel@tonic-gate } 69997c478bd9Sstevel@tonic-gate 7000f9722deaSChris Horne char * 7001f9722deaSChris Horne ddi_pathname_minor(struct ddi_minor_data *dmdp, char *path) 7002f9722deaSChris Horne { 7003f9722deaSChris Horne if (dmdp->dip == NULL) 7004f9722deaSChris Horne *path = '\0'; 7005f9722deaSChris Horne else { 7006f9722deaSChris Horne (void) ddi_pathname(dmdp->dip, path); 7007f9722deaSChris Horne if (dmdp->ddm_name) { 7008f9722deaSChris Horne (void) strcat(path, ":"); 7009f9722deaSChris Horne (void) strcat(path, dmdp->ddm_name); 7010f9722deaSChris Horne } 7011f9722deaSChris Horne } 7012f9722deaSChris Horne return (path); 7013f9722deaSChris Horne } 7014f9722deaSChris Horne 701538c67cbdSjiang wu - Sun Microsystems - Beijing China static char * 701638c67cbdSjiang wu - Sun Microsystems - Beijing China pathname_work_obp(dev_info_t *dip, char *path) 701738c67cbdSjiang wu - Sun Microsystems - Beijing China { 701838c67cbdSjiang wu - Sun Microsystems - Beijing China char *bp; 701938c67cbdSjiang wu - Sun Microsystems - Beijing China char *obp_path; 702038c67cbdSjiang wu - Sun Microsystems - Beijing China 702138c67cbdSjiang wu - Sun Microsystems - Beijing China /* 702238c67cbdSjiang wu - Sun Microsystems - Beijing China * look up the "obp-path" property, return the path if it exists 702338c67cbdSjiang wu - Sun Microsystems - Beijing China */ 702438c67cbdSjiang wu - Sun Microsystems - Beijing China if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 702538c67cbdSjiang wu - Sun Microsystems - Beijing China "obp-path", &obp_path) == DDI_PROP_SUCCESS) { 702638c67cbdSjiang wu - Sun Microsystems - Beijing China (void) strcpy(path, obp_path); 702738c67cbdSjiang wu - Sun Microsystems - Beijing China ddi_prop_free(obp_path); 702838c67cbdSjiang wu - Sun Microsystems - Beijing China return (path); 702938c67cbdSjiang wu - Sun Microsystems - Beijing China } 703038c67cbdSjiang wu - Sun Microsystems - Beijing China 703138c67cbdSjiang wu - Sun Microsystems - Beijing China /* 703238c67cbdSjiang wu - Sun Microsystems - Beijing China * stop at root, no obp path 703338c67cbdSjiang wu - Sun Microsystems - Beijing China */ 703438c67cbdSjiang wu - Sun Microsystems - Beijing China if (dip == ddi_root_node()) { 703538c67cbdSjiang wu - Sun Microsystems - Beijing China return (NULL); 703638c67cbdSjiang wu - Sun Microsystems - Beijing China } 703738c67cbdSjiang wu - Sun Microsystems - Beijing China 703838c67cbdSjiang wu - Sun Microsystems - Beijing China obp_path = pathname_work_obp(ddi_get_parent(dip), path); 703938c67cbdSjiang wu - Sun Microsystems - Beijing China if (obp_path == NULL) 704038c67cbdSjiang wu - Sun Microsystems - Beijing China return (NULL); 704138c67cbdSjiang wu - Sun Microsystems - Beijing China 704238c67cbdSjiang wu - Sun Microsystems - Beijing China /* 704338c67cbdSjiang wu - Sun Microsystems - Beijing China * append our component to parent's obp path 704438c67cbdSjiang wu - Sun Microsystems - Beijing China */ 704538c67cbdSjiang wu - Sun Microsystems - Beijing China bp = path + strlen(path); 704638c67cbdSjiang wu - Sun Microsystems - Beijing China if (*(bp - 1) != '/') 704738c67cbdSjiang wu - Sun Microsystems - Beijing China (void) strcat(bp++, "/"); 704838c67cbdSjiang wu - Sun Microsystems - Beijing China (void) ddi_deviname(dip, bp); 704938c67cbdSjiang wu - Sun Microsystems - Beijing China return (path); 705038c67cbdSjiang wu - Sun Microsystems - Beijing China } 705138c67cbdSjiang wu - Sun Microsystems - Beijing China 705238c67cbdSjiang wu - Sun Microsystems - Beijing China /* 705338c67cbdSjiang wu - Sun Microsystems - Beijing China * return the 'obp-path' based path for the given node, or NULL if the node 705438c67cbdSjiang wu - Sun Microsystems - Beijing China * does not have a different obp path. NOTE: Unlike ddi_pathname, this 705538c67cbdSjiang wu - Sun Microsystems - Beijing China * function can't be called from interrupt context (since we need to 705638c67cbdSjiang wu - Sun Microsystems - Beijing China * lookup a string property). 705738c67cbdSjiang wu - Sun Microsystems - Beijing China */ 705838c67cbdSjiang wu - Sun Microsystems - Beijing China char * 705938c67cbdSjiang wu - Sun Microsystems - Beijing China ddi_pathname_obp(dev_info_t *dip, char *path) 706038c67cbdSjiang wu - Sun Microsystems - Beijing China { 706138c67cbdSjiang wu - Sun Microsystems - Beijing China ASSERT(!servicing_interrupt()); 706238c67cbdSjiang wu - Sun Microsystems - Beijing China if (dip == NULL || path == NULL) 706338c67cbdSjiang wu - Sun Microsystems - Beijing China return (NULL); 706438c67cbdSjiang wu - Sun Microsystems - Beijing China 706538c67cbdSjiang wu - Sun Microsystems - Beijing China /* split work into a separate function to aid debugging */ 706638c67cbdSjiang wu - Sun Microsystems - Beijing China return (pathname_work_obp(dip, path)); 706738c67cbdSjiang wu - Sun Microsystems - Beijing China } 706838c67cbdSjiang wu - Sun Microsystems - Beijing China 706938c67cbdSjiang wu - Sun Microsystems - Beijing China int 707038c67cbdSjiang wu - Sun Microsystems - Beijing China ddi_pathname_obp_set(dev_info_t *dip, char *component) 707138c67cbdSjiang wu - Sun Microsystems - Beijing China { 707238c67cbdSjiang wu - Sun Microsystems - Beijing China dev_info_t *pdip; 7073caa9369fSjiang wu - Sun Microsystems - Beijing China char *obp_path = NULL; 7074caa9369fSjiang wu - Sun Microsystems - Beijing China int rc = DDI_FAILURE; 707538c67cbdSjiang wu - Sun Microsystems - Beijing China 707638c67cbdSjiang wu - Sun Microsystems - Beijing China if (dip == NULL) 707738c67cbdSjiang wu - Sun Microsystems - Beijing China return (DDI_FAILURE); 7078caa9369fSjiang wu - Sun Microsystems - Beijing China 7079caa9369fSjiang wu - Sun Microsystems - Beijing China obp_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 7080caa9369fSjiang wu - Sun Microsystems - Beijing China 708138c67cbdSjiang wu - Sun Microsystems - Beijing China pdip = ddi_get_parent(dip); 708238c67cbdSjiang wu - Sun Microsystems - Beijing China 708338c67cbdSjiang wu - Sun Microsystems - Beijing China if (ddi_pathname_obp(pdip, obp_path) == NULL) { 708438c67cbdSjiang wu - Sun Microsystems - Beijing China (void) ddi_pathname(pdip, obp_path); 708538c67cbdSjiang wu - Sun Microsystems - Beijing China } 708638c67cbdSjiang wu - Sun Microsystems - Beijing China 708738c67cbdSjiang wu - Sun Microsystems - Beijing China if (component) { 7088caa9369fSjiang wu - Sun Microsystems - Beijing China (void) strncat(obp_path, "/", MAXPATHLEN); 7089caa9369fSjiang wu - Sun Microsystems - Beijing China (void) strncat(obp_path, component, MAXPATHLEN); 709038c67cbdSjiang wu - Sun Microsystems - Beijing China } 7091caa9369fSjiang wu - Sun Microsystems - Beijing China rc = ndi_prop_update_string(DDI_DEV_T_NONE, dip, "obp-path", 7092caa9369fSjiang wu - Sun Microsystems - Beijing China obp_path); 7093caa9369fSjiang wu - Sun Microsystems - Beijing China 7094caa9369fSjiang wu - Sun Microsystems - Beijing China if (obp_path) 7095caa9369fSjiang wu - Sun Microsystems - Beijing China kmem_free(obp_path, MAXPATHLEN); 7096caa9369fSjiang wu - Sun Microsystems - Beijing China 7097caa9369fSjiang wu - Sun Microsystems - Beijing China return (rc); 709838c67cbdSjiang wu - Sun Microsystems - Beijing China } 709938c67cbdSjiang wu - Sun Microsystems - Beijing China 71007c478bd9Sstevel@tonic-gate /* 71017c478bd9Sstevel@tonic-gate * Given a dev_t, return the pathname of the corresponding device in the 71027c478bd9Sstevel@tonic-gate * buffer pointed at by "path." The buffer is assumed to be large enough 71037c478bd9Sstevel@tonic-gate * to hold the pathname of the device (MAXPATHLEN). 71047c478bd9Sstevel@tonic-gate * 71057c478bd9Sstevel@tonic-gate * The pathname of a device is the pathname of the devinfo node to which 71067c478bd9Sstevel@tonic-gate * the device "belongs," concatenated with the character ':' and the name 71077c478bd9Sstevel@tonic-gate * of the minor node corresponding to the dev_t. If spec_type is 0 then 71087c478bd9Sstevel@tonic-gate * just the pathname of the devinfo node is returned without driving attach 71097c478bd9Sstevel@tonic-gate * of that node. For a non-zero spec_type, an attach is performed and a 71107c478bd9Sstevel@tonic-gate * search of the minor list occurs. 71117c478bd9Sstevel@tonic-gate * 71127c478bd9Sstevel@tonic-gate * It is possible that the path associated with the dev_t is not 71137c478bd9Sstevel@tonic-gate * currently available in the devinfo tree. In order to have a 71147c478bd9Sstevel@tonic-gate * dev_t, a device must have been discovered before, which means 71157c478bd9Sstevel@tonic-gate * that the path is always in the instance tree. The one exception 71167c478bd9Sstevel@tonic-gate * to this is if the dev_t is associated with a pseudo driver, in 71177c478bd9Sstevel@tonic-gate * which case the device must exist on the pseudo branch of the 71187c478bd9Sstevel@tonic-gate * devinfo tree as a result of parsing .conf files. 71197c478bd9Sstevel@tonic-gate */ 71207c478bd9Sstevel@tonic-gate int 71217c478bd9Sstevel@tonic-gate ddi_dev_pathname(dev_t devt, int spec_type, char *path) 71227c478bd9Sstevel@tonic-gate { 7123b9ccdc5aScth int circ; 71247c478bd9Sstevel@tonic-gate major_t major = getmajor(devt); 71257c478bd9Sstevel@tonic-gate int instance; 71267c478bd9Sstevel@tonic-gate dev_info_t *dip; 71277c478bd9Sstevel@tonic-gate char *minorname; 71287c478bd9Sstevel@tonic-gate char *drvname; 71297c478bd9Sstevel@tonic-gate 71307c478bd9Sstevel@tonic-gate if (major >= devcnt) 71317c478bd9Sstevel@tonic-gate goto fail; 71327c478bd9Sstevel@tonic-gate if (major == clone_major) { 71337c478bd9Sstevel@tonic-gate /* clone has no minor nodes, manufacture the path here */ 71347c478bd9Sstevel@tonic-gate if ((drvname = ddi_major_to_name(getminor(devt))) == NULL) 71357c478bd9Sstevel@tonic-gate goto fail; 71367c478bd9Sstevel@tonic-gate 71377c478bd9Sstevel@tonic-gate (void) snprintf(path, MAXPATHLEN, "%s:%s", CLONE_PATH, drvname); 71387c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 71397c478bd9Sstevel@tonic-gate } 71407c478bd9Sstevel@tonic-gate 71417c478bd9Sstevel@tonic-gate /* extract instance from devt (getinfo(9E) DDI_INFO_DEVT2INSTANCE). */ 71427c478bd9Sstevel@tonic-gate if ((instance = dev_to_instance(devt)) == -1) 71437c478bd9Sstevel@tonic-gate goto fail; 71447c478bd9Sstevel@tonic-gate 71457c478bd9Sstevel@tonic-gate /* reconstruct the path given the major/instance */ 71467c478bd9Sstevel@tonic-gate if (e_ddi_majorinstance_to_path(major, instance, path) != DDI_SUCCESS) 71477c478bd9Sstevel@tonic-gate goto fail; 71487c478bd9Sstevel@tonic-gate 71497c478bd9Sstevel@tonic-gate /* if spec_type given we must drive attach and search minor nodes */ 71507c478bd9Sstevel@tonic-gate if ((spec_type == S_IFCHR) || (spec_type == S_IFBLK)) { 71517c478bd9Sstevel@tonic-gate /* attach the path so we can search minors */ 71527c478bd9Sstevel@tonic-gate if ((dip = e_ddi_hold_devi_by_path(path, 0)) == NULL) 71537c478bd9Sstevel@tonic-gate goto fail; 71547c478bd9Sstevel@tonic-gate 71557c478bd9Sstevel@tonic-gate /* Add minorname to path. */ 7156b9ccdc5aScth ndi_devi_enter(dip, &circ); 71577c478bd9Sstevel@tonic-gate minorname = i_ddi_devtspectype_to_minorname(dip, 71587c478bd9Sstevel@tonic-gate devt, spec_type); 71597c478bd9Sstevel@tonic-gate if (minorname) { 71607c478bd9Sstevel@tonic-gate (void) strcat(path, ":"); 71617c478bd9Sstevel@tonic-gate (void) strcat(path, minorname); 71627c478bd9Sstevel@tonic-gate } 7163b9ccdc5aScth ndi_devi_exit(dip, circ); 71647c478bd9Sstevel@tonic-gate ddi_release_devi(dip); 71657c478bd9Sstevel@tonic-gate if (minorname == NULL) 71667c478bd9Sstevel@tonic-gate goto fail; 71677c478bd9Sstevel@tonic-gate } 71687c478bd9Sstevel@tonic-gate ASSERT(strlen(path) < MAXPATHLEN); 71697c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 71707c478bd9Sstevel@tonic-gate 71717c478bd9Sstevel@tonic-gate fail: *path = 0; 71727c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 71737c478bd9Sstevel@tonic-gate } 71747c478bd9Sstevel@tonic-gate 71757c478bd9Sstevel@tonic-gate /* 71767c478bd9Sstevel@tonic-gate * Given a major number and an instance, return the path. 71777c478bd9Sstevel@tonic-gate * This interface does NOT drive attach. 71787c478bd9Sstevel@tonic-gate */ 71797c478bd9Sstevel@tonic-gate int 71807c478bd9Sstevel@tonic-gate e_ddi_majorinstance_to_path(major_t major, int instance, char *path) 71817c478bd9Sstevel@tonic-gate { 718205a69601Scth struct devnames *dnp; 71837c478bd9Sstevel@tonic-gate dev_info_t *dip; 71847c478bd9Sstevel@tonic-gate 718505a69601Scth if ((major >= devcnt) || (instance == -1)) { 718605a69601Scth *path = 0; 718705a69601Scth return (DDI_FAILURE); 718805a69601Scth } 718905a69601Scth 71907c478bd9Sstevel@tonic-gate /* look for the major/instance in the instance tree */ 71917c478bd9Sstevel@tonic-gate if (e_ddi_instance_majorinstance_to_path(major, instance, 719205a69601Scth path) == DDI_SUCCESS) { 719305a69601Scth ASSERT(strlen(path) < MAXPATHLEN); 719405a69601Scth return (DDI_SUCCESS); 719505a69601Scth } 719605a69601Scth 719705a69601Scth /* 719805a69601Scth * Not in instance tree, find the instance on the per driver list and 719905a69601Scth * construct path to instance via ddi_pathname(). This is how paths 720005a69601Scth * down the 'pseudo' branch are constructed. 720105a69601Scth */ 720205a69601Scth dnp = &(devnamesp[major]); 720305a69601Scth LOCK_DEV_OPS(&(dnp->dn_lock)); 720405a69601Scth for (dip = dnp->dn_head; dip; 720505a69601Scth dip = (dev_info_t *)DEVI(dip)->devi_next) { 720605a69601Scth /* Skip if instance does not match. */ 720705a69601Scth if (DEVI(dip)->devi_instance != instance) 720805a69601Scth continue; 720905a69601Scth 721005a69601Scth /* 721105a69601Scth * An ndi_hold_devi() does not prevent DS_INITIALIZED->DS_BOUND 721205a69601Scth * node demotion, so it is not an effective way of ensuring 721305a69601Scth * that the ddi_pathname result has a unit-address. Instead, 721405a69601Scth * we reverify the node state after calling ddi_pathname(). 721505a69601Scth */ 721605a69601Scth if (i_ddi_node_state(dip) >= DS_INITIALIZED) { 721705a69601Scth (void) ddi_pathname(dip, path); 721805a69601Scth if (i_ddi_node_state(dip) < DS_INITIALIZED) 721905a69601Scth continue; 722005a69601Scth UNLOCK_DEV_OPS(&(dnp->dn_lock)); 722105a69601Scth ASSERT(strlen(path) < MAXPATHLEN); 722205a69601Scth return (DDI_SUCCESS); 72237c478bd9Sstevel@tonic-gate } 72247c478bd9Sstevel@tonic-gate } 722505a69601Scth UNLOCK_DEV_OPS(&(dnp->dn_lock)); 72267c478bd9Sstevel@tonic-gate 722705a69601Scth /* can't reconstruct the path */ 722805a69601Scth *path = 0; 722905a69601Scth return (DDI_FAILURE); 723005a69601Scth } 72317c478bd9Sstevel@tonic-gate 72327c478bd9Sstevel@tonic-gate #define GLD_DRIVER_PPA "SUNW,gld_v0_ppa" 72337c478bd9Sstevel@tonic-gate 72347c478bd9Sstevel@tonic-gate /* 72357c478bd9Sstevel@tonic-gate * Given the dip for a network interface return the ppa for that interface. 72367c478bd9Sstevel@tonic-gate * 72377c478bd9Sstevel@tonic-gate * In all cases except GLD v0 drivers, the ppa == instance. 72387c478bd9Sstevel@tonic-gate * In the case of GLD v0 drivers, the ppa is equal to the attach order. 72397c478bd9Sstevel@tonic-gate * So for these drivers when the attach routine calls gld_register(), 72407c478bd9Sstevel@tonic-gate * the GLD framework creates an integer property called "gld_driver_ppa" 72417c478bd9Sstevel@tonic-gate * that can be queried here. 72427c478bd9Sstevel@tonic-gate * 72437c478bd9Sstevel@tonic-gate * The only time this function is used is when a system is booting over nfs. 72447c478bd9Sstevel@tonic-gate * In this case the system has to resolve the pathname of the boot device 72457c478bd9Sstevel@tonic-gate * to it's ppa. 72467c478bd9Sstevel@tonic-gate */ 72477c478bd9Sstevel@tonic-gate int 72487c478bd9Sstevel@tonic-gate i_ddi_devi_get_ppa(dev_info_t *dip) 72497c478bd9Sstevel@tonic-gate { 72507c478bd9Sstevel@tonic-gate return (ddi_prop_get_int(DDI_DEV_T_ANY, dip, 7251184cd04cScth DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 7252184cd04cScth GLD_DRIVER_PPA, ddi_get_instance(dip))); 72537c478bd9Sstevel@tonic-gate } 72547c478bd9Sstevel@tonic-gate 72557c478bd9Sstevel@tonic-gate /* 72567c478bd9Sstevel@tonic-gate * i_ddi_devi_set_ppa() should only be called from gld_register() 72577c478bd9Sstevel@tonic-gate * and only for GLD v0 drivers 72587c478bd9Sstevel@tonic-gate */ 72597c478bd9Sstevel@tonic-gate void 72607c478bd9Sstevel@tonic-gate i_ddi_devi_set_ppa(dev_info_t *dip, int ppa) 72617c478bd9Sstevel@tonic-gate { 72627c478bd9Sstevel@tonic-gate (void) e_ddi_prop_update_int(DDI_DEV_T_NONE, dip, GLD_DRIVER_PPA, ppa); 72637c478bd9Sstevel@tonic-gate } 72647c478bd9Sstevel@tonic-gate 72657c478bd9Sstevel@tonic-gate 72667c478bd9Sstevel@tonic-gate /* 72677c478bd9Sstevel@tonic-gate * Private DDI Console bell functions. 72687c478bd9Sstevel@tonic-gate */ 72697c478bd9Sstevel@tonic-gate void 72707c478bd9Sstevel@tonic-gate ddi_ring_console_bell(clock_t duration) 72717c478bd9Sstevel@tonic-gate { 72727c478bd9Sstevel@tonic-gate if (ddi_console_bell_func != NULL) 72737c478bd9Sstevel@tonic-gate (*ddi_console_bell_func)(duration); 72747c478bd9Sstevel@tonic-gate } 72757c478bd9Sstevel@tonic-gate 72767c478bd9Sstevel@tonic-gate void 72777c478bd9Sstevel@tonic-gate ddi_set_console_bell(void (*bellfunc)(clock_t duration)) 72787c478bd9Sstevel@tonic-gate { 72797c478bd9Sstevel@tonic-gate ddi_console_bell_func = bellfunc; 72807c478bd9Sstevel@tonic-gate } 72817c478bd9Sstevel@tonic-gate 72827c478bd9Sstevel@tonic-gate int 72837c478bd9Sstevel@tonic-gate ddi_dma_alloc_handle(dev_info_t *dip, ddi_dma_attr_t *attr, 72847c478bd9Sstevel@tonic-gate int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep) 72857c478bd9Sstevel@tonic-gate { 72867c478bd9Sstevel@tonic-gate int (*funcp)() = ddi_dma_allochdl; 72877c478bd9Sstevel@tonic-gate ddi_dma_attr_t dma_attr; 72887c478bd9Sstevel@tonic-gate struct bus_ops *bop; 72897c478bd9Sstevel@tonic-gate 72907c478bd9Sstevel@tonic-gate if (attr == (ddi_dma_attr_t *)0) 72917c478bd9Sstevel@tonic-gate return (DDI_DMA_BADATTR); 72927c478bd9Sstevel@tonic-gate 72937c478bd9Sstevel@tonic-gate dma_attr = *attr; 72947c478bd9Sstevel@tonic-gate 72957c478bd9Sstevel@tonic-gate bop = DEVI(dip)->devi_ops->devo_bus_ops; 72967c478bd9Sstevel@tonic-gate if (bop && bop->bus_dma_allochdl) 72977c478bd9Sstevel@tonic-gate funcp = bop->bus_dma_allochdl; 72987c478bd9Sstevel@tonic-gate 72997c478bd9Sstevel@tonic-gate return ((*funcp)(dip, dip, &dma_attr, waitfp, arg, handlep)); 73007c478bd9Sstevel@tonic-gate } 73017c478bd9Sstevel@tonic-gate 73027c478bd9Sstevel@tonic-gate void 73037c478bd9Sstevel@tonic-gate ddi_dma_free_handle(ddi_dma_handle_t *handlep) 73047c478bd9Sstevel@tonic-gate { 73057c478bd9Sstevel@tonic-gate ddi_dma_handle_t h = *handlep; 73067c478bd9Sstevel@tonic-gate (void) ddi_dma_freehdl(HD, HD, h); 73077c478bd9Sstevel@tonic-gate } 73087c478bd9Sstevel@tonic-gate 73097c478bd9Sstevel@tonic-gate static uintptr_t dma_mem_list_id = 0; 73107c478bd9Sstevel@tonic-gate 73117c478bd9Sstevel@tonic-gate 73127c478bd9Sstevel@tonic-gate int 73137c478bd9Sstevel@tonic-gate ddi_dma_mem_alloc(ddi_dma_handle_t handle, size_t length, 73147b93957cSeota ddi_device_acc_attr_t *accattrp, uint_t flags, 73157c478bd9Sstevel@tonic-gate int (*waitfp)(caddr_t), caddr_t arg, caddr_t *kaddrp, 73167c478bd9Sstevel@tonic-gate size_t *real_length, ddi_acc_handle_t *handlep) 73177c478bd9Sstevel@tonic-gate { 73187c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 73197c478bd9Sstevel@tonic-gate dev_info_t *dip = hp->dmai_rdip; 73207c478bd9Sstevel@tonic-gate ddi_acc_hdl_t *ap; 73217c478bd9Sstevel@tonic-gate ddi_dma_attr_t *attrp = &hp->dmai_attr; 73227b93957cSeota uint_t sleepflag, xfermodes; 73237c478bd9Sstevel@tonic-gate int (*fp)(caddr_t); 73247c478bd9Sstevel@tonic-gate int rval; 73257c478bd9Sstevel@tonic-gate 73267c478bd9Sstevel@tonic-gate if (waitfp == DDI_DMA_SLEEP) 73277c478bd9Sstevel@tonic-gate fp = (int (*)())KM_SLEEP; 73287c478bd9Sstevel@tonic-gate else if (waitfp == DDI_DMA_DONTWAIT) 73297c478bd9Sstevel@tonic-gate fp = (int (*)())KM_NOSLEEP; 73307c478bd9Sstevel@tonic-gate else 73317c478bd9Sstevel@tonic-gate fp = waitfp; 73327c478bd9Sstevel@tonic-gate *handlep = impl_acc_hdl_alloc(fp, arg); 73337c478bd9Sstevel@tonic-gate if (*handlep == NULL) 73347c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 73357c478bd9Sstevel@tonic-gate 733683220025Seota /* check if the cache attributes are supported */ 733783220025Seota if (i_ddi_check_cache_attr(flags) == B_FALSE) 73387b93957cSeota return (DDI_FAILURE); 73397b93957cSeota 73407b93957cSeota /* 73417b93957cSeota * Transfer the meaningful bits to xfermodes. 73427b93957cSeota * Double-check if the 3rd party driver correctly sets the bits. 73437b93957cSeota * If not, set DDI_DMA_STREAMING to keep compatibility. 73447b93957cSeota */ 73457b93957cSeota xfermodes = flags & (DDI_DMA_CONSISTENT | DDI_DMA_STREAMING); 73467b93957cSeota if (xfermodes == 0) { 73477b93957cSeota xfermodes = DDI_DMA_STREAMING; 73487b93957cSeota } 73497b93957cSeota 73507c478bd9Sstevel@tonic-gate /* 73517c478bd9Sstevel@tonic-gate * initialize the common elements of data access handle 73527c478bd9Sstevel@tonic-gate */ 73537c478bd9Sstevel@tonic-gate ap = impl_acc_hdl_get(*handlep); 73547c478bd9Sstevel@tonic-gate ap->ah_vers = VERS_ACCHDL; 73557c478bd9Sstevel@tonic-gate ap->ah_dip = dip; 73567c478bd9Sstevel@tonic-gate ap->ah_offset = 0; 73577c478bd9Sstevel@tonic-gate ap->ah_len = 0; 73587b93957cSeota ap->ah_xfermodes = flags; 73597c478bd9Sstevel@tonic-gate ap->ah_acc = *accattrp; 73607c478bd9Sstevel@tonic-gate 73617c478bd9Sstevel@tonic-gate sleepflag = ((waitfp == DDI_DMA_SLEEP) ? 1 : 0); 73627c478bd9Sstevel@tonic-gate if (xfermodes == DDI_DMA_CONSISTENT) { 73637b93957cSeota rval = i_ddi_mem_alloc(dip, attrp, length, sleepflag, 73647b93957cSeota flags, accattrp, kaddrp, NULL, ap); 73657c478bd9Sstevel@tonic-gate *real_length = length; 73667c478bd9Sstevel@tonic-gate } else { 73677b93957cSeota rval = i_ddi_mem_alloc(dip, attrp, length, sleepflag, 73687b93957cSeota flags, accattrp, kaddrp, real_length, ap); 73697c478bd9Sstevel@tonic-gate } 73707c478bd9Sstevel@tonic-gate if (rval == DDI_SUCCESS) { 73717c478bd9Sstevel@tonic-gate ap->ah_len = (off_t)(*real_length); 73727c478bd9Sstevel@tonic-gate ap->ah_addr = *kaddrp; 73737c478bd9Sstevel@tonic-gate } else { 73747c478bd9Sstevel@tonic-gate impl_acc_hdl_free(*handlep); 73757c478bd9Sstevel@tonic-gate *handlep = (ddi_acc_handle_t)NULL; 73767c478bd9Sstevel@tonic-gate if (waitfp != DDI_DMA_SLEEP && waitfp != DDI_DMA_DONTWAIT) { 73777c478bd9Sstevel@tonic-gate ddi_set_callback(waitfp, arg, &dma_mem_list_id); 73787c478bd9Sstevel@tonic-gate } 73797c478bd9Sstevel@tonic-gate rval = DDI_FAILURE; 73807c478bd9Sstevel@tonic-gate } 73817c478bd9Sstevel@tonic-gate return (rval); 73827c478bd9Sstevel@tonic-gate } 73837c478bd9Sstevel@tonic-gate 73847c478bd9Sstevel@tonic-gate void 73857c478bd9Sstevel@tonic-gate ddi_dma_mem_free(ddi_acc_handle_t *handlep) 73867c478bd9Sstevel@tonic-gate { 73877c478bd9Sstevel@tonic-gate ddi_acc_hdl_t *ap; 73887c478bd9Sstevel@tonic-gate 73897c478bd9Sstevel@tonic-gate ap = impl_acc_hdl_get(*handlep); 73907c478bd9Sstevel@tonic-gate ASSERT(ap); 73917c478bd9Sstevel@tonic-gate 73927b93957cSeota i_ddi_mem_free((caddr_t)ap->ah_addr, ap); 73937c478bd9Sstevel@tonic-gate 73947c478bd9Sstevel@tonic-gate /* 73957c478bd9Sstevel@tonic-gate * free the handle 73967c478bd9Sstevel@tonic-gate */ 73977c478bd9Sstevel@tonic-gate impl_acc_hdl_free(*handlep); 73987c478bd9Sstevel@tonic-gate *handlep = (ddi_acc_handle_t)NULL; 73997c478bd9Sstevel@tonic-gate 74007c478bd9Sstevel@tonic-gate if (dma_mem_list_id != 0) { 74017c478bd9Sstevel@tonic-gate ddi_run_callback(&dma_mem_list_id); 74027c478bd9Sstevel@tonic-gate } 74037c478bd9Sstevel@tonic-gate } 74047c478bd9Sstevel@tonic-gate 74057c478bd9Sstevel@tonic-gate int 74067c478bd9Sstevel@tonic-gate ddi_dma_buf_bind_handle(ddi_dma_handle_t handle, struct buf *bp, 74077c478bd9Sstevel@tonic-gate uint_t flags, int (*waitfp)(caddr_t), caddr_t arg, 74087c478bd9Sstevel@tonic-gate ddi_dma_cookie_t *cookiep, uint_t *ccountp) 74097c478bd9Sstevel@tonic-gate { 74107c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 7411b51bbbf5SVikram Hegde dev_info_t *dip, *rdip; 74127c478bd9Sstevel@tonic-gate struct ddi_dma_req dmareq; 74137c478bd9Sstevel@tonic-gate int (*funcp)(); 74147c478bd9Sstevel@tonic-gate 74157c478bd9Sstevel@tonic-gate dmareq.dmar_flags = flags; 74167c478bd9Sstevel@tonic-gate dmareq.dmar_fp = waitfp; 74177c478bd9Sstevel@tonic-gate dmareq.dmar_arg = arg; 74187c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_size = (uint_t)bp->b_bcount; 74197c478bd9Sstevel@tonic-gate 74202d3bf78eScth if (bp->b_flags & B_PAGEIO) { 74217c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = DMA_OTYP_PAGES; 74227c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.pp_obj.pp_pp = bp->b_pages; 74237c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.pp_obj.pp_offset = 74247c478bd9Sstevel@tonic-gate (uint_t)(((uintptr_t)bp->b_un.b_addr) & MMU_PAGEOFFSET); 74257c478bd9Sstevel@tonic-gate } else { 74267c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_addr = bp->b_un.b_addr; 74272d3bf78eScth if (bp->b_flags & B_SHADOW) { 74287c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_priv = 7429184cd04cScth bp->b_shadow; 74307c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = DMA_OTYP_BUFVADDR; 74317c478bd9Sstevel@tonic-gate } else { 74327c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = 7433184cd04cScth (bp->b_flags & (B_PHYS | B_REMAPPED)) ? 7434184cd04cScth DMA_OTYP_BUFVADDR : DMA_OTYP_VADDR; 74357c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_priv = NULL; 74367c478bd9Sstevel@tonic-gate } 74377c478bd9Sstevel@tonic-gate 74387c478bd9Sstevel@tonic-gate /* 74397c478bd9Sstevel@tonic-gate * If the buffer has no proc pointer, or the proc 74407c478bd9Sstevel@tonic-gate * struct has the kernel address space, or the buffer has 74417c478bd9Sstevel@tonic-gate * been marked B_REMAPPED (meaning that it is now 74427c478bd9Sstevel@tonic-gate * mapped into the kernel's address space), then 74437c478bd9Sstevel@tonic-gate * the address space is kas (kernel address space). 74447c478bd9Sstevel@tonic-gate */ 74452d3bf78eScth if ((bp->b_proc == NULL) || (bp->b_proc->p_as == &kas) || 74462d3bf78eScth (bp->b_flags & B_REMAPPED)) { 74477c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_as = 0; 74487c478bd9Sstevel@tonic-gate } else { 74497c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_as = 74507c478bd9Sstevel@tonic-gate bp->b_proc->p_as; 74517c478bd9Sstevel@tonic-gate } 74527c478bd9Sstevel@tonic-gate } 74537c478bd9Sstevel@tonic-gate 7454b51bbbf5SVikram Hegde dip = rdip = hp->dmai_rdip; 7455b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 7456b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl; 7457b51bbbf5SVikram Hegde funcp = DEVI(rdip)->devi_bus_dma_bindfunc; 7458b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handle, &dmareq, cookiep, ccountp)); 74597c478bd9Sstevel@tonic-gate } 74607c478bd9Sstevel@tonic-gate 74617c478bd9Sstevel@tonic-gate int 74627c478bd9Sstevel@tonic-gate ddi_dma_addr_bind_handle(ddi_dma_handle_t handle, struct as *as, 74637c478bd9Sstevel@tonic-gate caddr_t addr, size_t len, uint_t flags, int (*waitfp)(caddr_t), 74647c478bd9Sstevel@tonic-gate caddr_t arg, ddi_dma_cookie_t *cookiep, uint_t *ccountp) 74657c478bd9Sstevel@tonic-gate { 74667c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 7467b51bbbf5SVikram Hegde dev_info_t *dip, *rdip; 74687c478bd9Sstevel@tonic-gate struct ddi_dma_req dmareq; 74697c478bd9Sstevel@tonic-gate int (*funcp)(); 74707c478bd9Sstevel@tonic-gate 74717c478bd9Sstevel@tonic-gate if (len == (uint_t)0) { 74727c478bd9Sstevel@tonic-gate return (DDI_DMA_NOMAPPING); 74737c478bd9Sstevel@tonic-gate } 74747c478bd9Sstevel@tonic-gate dmareq.dmar_flags = flags; 74757c478bd9Sstevel@tonic-gate dmareq.dmar_fp = waitfp; 74767c478bd9Sstevel@tonic-gate dmareq.dmar_arg = arg; 74777c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_size = len; 74787c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_type = DMA_OTYP_VADDR; 74797c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_as = as; 74807c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_addr = addr; 74817c478bd9Sstevel@tonic-gate dmareq.dmar_object.dmao_obj.virt_obj.v_priv = NULL; 74827c478bd9Sstevel@tonic-gate 7483b51bbbf5SVikram Hegde dip = rdip = hp->dmai_rdip; 7484b51bbbf5SVikram Hegde if (dip != ddi_root_node()) 7485b51bbbf5SVikram Hegde dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl; 7486b51bbbf5SVikram Hegde funcp = DEVI(rdip)->devi_bus_dma_bindfunc; 7487b51bbbf5SVikram Hegde return ((*funcp)(dip, rdip, handle, &dmareq, cookiep, ccountp)); 74887c478bd9Sstevel@tonic-gate } 74897c478bd9Sstevel@tonic-gate 74907c478bd9Sstevel@tonic-gate void 74917c478bd9Sstevel@tonic-gate ddi_dma_nextcookie(ddi_dma_handle_t handle, ddi_dma_cookie_t *cookiep) 74927c478bd9Sstevel@tonic-gate { 74937c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 74947c478bd9Sstevel@tonic-gate ddi_dma_cookie_t *cp; 74957c478bd9Sstevel@tonic-gate 74967c478bd9Sstevel@tonic-gate cp = hp->dmai_cookie; 74977c478bd9Sstevel@tonic-gate ASSERT(cp); 74987c478bd9Sstevel@tonic-gate 74997c478bd9Sstevel@tonic-gate cookiep->dmac_notused = cp->dmac_notused; 75007c478bd9Sstevel@tonic-gate cookiep->dmac_type = cp->dmac_type; 75017c478bd9Sstevel@tonic-gate cookiep->dmac_address = cp->dmac_address; 75027c478bd9Sstevel@tonic-gate cookiep->dmac_size = cp->dmac_size; 75037c478bd9Sstevel@tonic-gate hp->dmai_cookie++; 75047c478bd9Sstevel@tonic-gate } 75057c478bd9Sstevel@tonic-gate 75067c478bd9Sstevel@tonic-gate int 75077c478bd9Sstevel@tonic-gate ddi_dma_numwin(ddi_dma_handle_t handle, uint_t *nwinp) 75087c478bd9Sstevel@tonic-gate { 75097c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 75107c478bd9Sstevel@tonic-gate if ((hp->dmai_rflags & DDI_DMA_PARTIAL) == 0) { 75117c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 75127c478bd9Sstevel@tonic-gate } else { 75137c478bd9Sstevel@tonic-gate *nwinp = hp->dmai_nwin; 75147c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 75157c478bd9Sstevel@tonic-gate } 75167c478bd9Sstevel@tonic-gate } 75177c478bd9Sstevel@tonic-gate 75187c478bd9Sstevel@tonic-gate int 75197c478bd9Sstevel@tonic-gate ddi_dma_getwin(ddi_dma_handle_t h, uint_t win, off_t *offp, 75207c478bd9Sstevel@tonic-gate size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp) 75217c478bd9Sstevel@tonic-gate { 75227c478bd9Sstevel@tonic-gate int (*funcp)() = ddi_dma_win; 75237c478bd9Sstevel@tonic-gate struct bus_ops *bop; 75247c478bd9Sstevel@tonic-gate 75257c478bd9Sstevel@tonic-gate bop = DEVI(HD)->devi_ops->devo_bus_ops; 75267c478bd9Sstevel@tonic-gate if (bop && bop->bus_dma_win) 75277c478bd9Sstevel@tonic-gate funcp = bop->bus_dma_win; 75287c478bd9Sstevel@tonic-gate 75297c478bd9Sstevel@tonic-gate return ((*funcp)(HD, HD, h, win, offp, lenp, cookiep, ccountp)); 75307c478bd9Sstevel@tonic-gate } 75317c478bd9Sstevel@tonic-gate 75327c478bd9Sstevel@tonic-gate int 75337c478bd9Sstevel@tonic-gate ddi_dma_set_sbus64(ddi_dma_handle_t h, ulong_t burstsizes) 75347c478bd9Sstevel@tonic-gate { 75357c478bd9Sstevel@tonic-gate return (ddi_dma_mctl(HD, HD, h, DDI_DMA_SET_SBUS64, 0, 7536184cd04cScth &burstsizes, 0, 0)); 75377c478bd9Sstevel@tonic-gate } 75387c478bd9Sstevel@tonic-gate 75397c478bd9Sstevel@tonic-gate int 75407c478bd9Sstevel@tonic-gate i_ddi_dma_fault_check(ddi_dma_impl_t *hp) 75417c478bd9Sstevel@tonic-gate { 75427c478bd9Sstevel@tonic-gate return (hp->dmai_fault); 75437c478bd9Sstevel@tonic-gate } 75447c478bd9Sstevel@tonic-gate 75457c478bd9Sstevel@tonic-gate int 75467c478bd9Sstevel@tonic-gate ddi_check_dma_handle(ddi_dma_handle_t handle) 75477c478bd9Sstevel@tonic-gate { 75487c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 75497c478bd9Sstevel@tonic-gate int (*check)(ddi_dma_impl_t *); 75507c478bd9Sstevel@tonic-gate 75517c478bd9Sstevel@tonic-gate if ((check = hp->dmai_fault_check) == NULL) 75527c478bd9Sstevel@tonic-gate check = i_ddi_dma_fault_check; 75537c478bd9Sstevel@tonic-gate 75547c478bd9Sstevel@tonic-gate return (((*check)(hp) == DDI_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 75557c478bd9Sstevel@tonic-gate } 75567c478bd9Sstevel@tonic-gate 75577c478bd9Sstevel@tonic-gate void 75587c478bd9Sstevel@tonic-gate i_ddi_dma_set_fault(ddi_dma_handle_t handle) 75597c478bd9Sstevel@tonic-gate { 75607c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 75617c478bd9Sstevel@tonic-gate void (*notify)(ddi_dma_impl_t *); 75627c478bd9Sstevel@tonic-gate 75637c478bd9Sstevel@tonic-gate if (!hp->dmai_fault) { 75647c478bd9Sstevel@tonic-gate hp->dmai_fault = 1; 75657c478bd9Sstevel@tonic-gate if ((notify = hp->dmai_fault_notify) != NULL) 75667c478bd9Sstevel@tonic-gate (*notify)(hp); 75677c478bd9Sstevel@tonic-gate } 75687c478bd9Sstevel@tonic-gate } 75697c478bd9Sstevel@tonic-gate 75707c478bd9Sstevel@tonic-gate void 75717c478bd9Sstevel@tonic-gate i_ddi_dma_clr_fault(ddi_dma_handle_t handle) 75727c478bd9Sstevel@tonic-gate { 75737c478bd9Sstevel@tonic-gate ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle; 75747c478bd9Sstevel@tonic-gate void (*notify)(ddi_dma_impl_t *); 75757c478bd9Sstevel@tonic-gate 75767c478bd9Sstevel@tonic-gate if (hp->dmai_fault) { 75777c478bd9Sstevel@tonic-gate hp->dmai_fault = 0; 75787c478bd9Sstevel@tonic-gate if ((notify = hp->dmai_fault_notify) != NULL) 75797c478bd9Sstevel@tonic-gate (*notify)(hp); 75807c478bd9Sstevel@tonic-gate } 75817c478bd9Sstevel@tonic-gate } 75827c478bd9Sstevel@tonic-gate 75837c478bd9Sstevel@tonic-gate /* 75847c478bd9Sstevel@tonic-gate * register mapping routines. 75857c478bd9Sstevel@tonic-gate */ 75867c478bd9Sstevel@tonic-gate int 75877c478bd9Sstevel@tonic-gate ddi_regs_map_setup(dev_info_t *dip, uint_t rnumber, caddr_t *addrp, 75887c478bd9Sstevel@tonic-gate offset_t offset, offset_t len, ddi_device_acc_attr_t *accattrp, 75897c478bd9Sstevel@tonic-gate ddi_acc_handle_t *handle) 75907c478bd9Sstevel@tonic-gate { 75917c478bd9Sstevel@tonic-gate ddi_map_req_t mr; 75927c478bd9Sstevel@tonic-gate ddi_acc_hdl_t *hp; 75937c478bd9Sstevel@tonic-gate int result; 75947c478bd9Sstevel@tonic-gate 75957c478bd9Sstevel@tonic-gate /* 75967c478bd9Sstevel@tonic-gate * Allocate and initialize the common elements of data access handle. 75977c478bd9Sstevel@tonic-gate */ 75987c478bd9Sstevel@tonic-gate *handle = impl_acc_hdl_alloc(KM_SLEEP, NULL); 75997c478bd9Sstevel@tonic-gate hp = impl_acc_hdl_get(*handle); 76007c478bd9Sstevel@tonic-gate hp->ah_vers = VERS_ACCHDL; 76017c478bd9Sstevel@tonic-gate hp->ah_dip = dip; 76027c478bd9Sstevel@tonic-gate hp->ah_rnumber = rnumber; 76037c478bd9Sstevel@tonic-gate hp->ah_offset = offset; 76047c478bd9Sstevel@tonic-gate hp->ah_len = len; 76057c478bd9Sstevel@tonic-gate hp->ah_acc = *accattrp; 76067c478bd9Sstevel@tonic-gate 76077c478bd9Sstevel@tonic-gate /* 76087c478bd9Sstevel@tonic-gate * Set up the mapping request and call to parent. 76097c478bd9Sstevel@tonic-gate */ 76107c478bd9Sstevel@tonic-gate mr.map_op = DDI_MO_MAP_LOCKED; 76117c478bd9Sstevel@tonic-gate mr.map_type = DDI_MT_RNUMBER; 76127c478bd9Sstevel@tonic-gate mr.map_obj.rnumber = rnumber; 76137c478bd9Sstevel@tonic-gate mr.map_prot = PROT_READ | PROT_WRITE; 76147c478bd9Sstevel@tonic-gate mr.map_flags = DDI_MF_KERNEL_MAPPING; 76157c478bd9Sstevel@tonic-gate mr.map_handlep = hp; 76167c478bd9Sstevel@tonic-gate mr.map_vers = DDI_MAP_VERSION; 76177c478bd9Sstevel@tonic-gate result = ddi_map(dip, &mr, offset, len, addrp); 76187c478bd9Sstevel@tonic-gate 76197c478bd9Sstevel@tonic-gate /* 76207c478bd9Sstevel@tonic-gate * check for end result 76217c478bd9Sstevel@tonic-gate */ 76227c478bd9Sstevel@tonic-gate if (result != DDI_SUCCESS) { 76237c478bd9Sstevel@tonic-gate impl_acc_hdl_free(*handle); 76247c478bd9Sstevel@tonic-gate *handle = (ddi_acc_handle_t)NULL; 76257c478bd9Sstevel@tonic-gate } else { 76267c478bd9Sstevel@tonic-gate hp->ah_addr = *addrp; 76277c478bd9Sstevel@tonic-gate } 76287c478bd9Sstevel@tonic-gate 76297c478bd9Sstevel@tonic-gate return (result); 76307c478bd9Sstevel@tonic-gate } 76317c478bd9Sstevel@tonic-gate 76327c478bd9Sstevel@tonic-gate void 76337c478bd9Sstevel@tonic-gate ddi_regs_map_free(ddi_acc_handle_t *handlep) 76347c478bd9Sstevel@tonic-gate { 76357c478bd9Sstevel@tonic-gate ddi_map_req_t mr; 76367c478bd9Sstevel@tonic-gate ddi_acc_hdl_t *hp; 76377c478bd9Sstevel@tonic-gate 76387c478bd9Sstevel@tonic-gate hp = impl_acc_hdl_get(*handlep); 76397c478bd9Sstevel@tonic-gate ASSERT(hp); 76407c478bd9Sstevel@tonic-gate 76417c478bd9Sstevel@tonic-gate mr.map_op = DDI_MO_UNMAP; 76427c478bd9Sstevel@tonic-gate mr.map_type = DDI_MT_RNUMBER; 76437c478bd9Sstevel@tonic-gate mr.map_obj.rnumber = hp->ah_rnumber; 76447c478bd9Sstevel@tonic-gate mr.map_prot = PROT_READ | PROT_WRITE; 76457c478bd9Sstevel@tonic-gate mr.map_flags = DDI_MF_KERNEL_MAPPING; 76467c478bd9Sstevel@tonic-gate mr.map_handlep = hp; 76477c478bd9Sstevel@tonic-gate mr.map_vers = DDI_MAP_VERSION; 76487c478bd9Sstevel@tonic-gate 76497c478bd9Sstevel@tonic-gate /* 76507c478bd9Sstevel@tonic-gate * Call my parent to unmap my regs. 76517c478bd9Sstevel@tonic-gate */ 76527c478bd9Sstevel@tonic-gate (void) ddi_map(hp->ah_dip, &mr, hp->ah_offset, 7653184cd04cScth hp->ah_len, &hp->ah_addr); 76547c478bd9Sstevel@tonic-gate /* 76557c478bd9Sstevel@tonic-gate * free the handle 76567c478bd9Sstevel@tonic-gate */ 76577c478bd9Sstevel@tonic-gate impl_acc_hdl_free(*handlep); 76587c478bd9Sstevel@tonic-gate *handlep = (ddi_acc_handle_t)NULL; 76597c478bd9Sstevel@tonic-gate } 76607c478bd9Sstevel@tonic-gate 76617c478bd9Sstevel@tonic-gate int 76627c478bd9Sstevel@tonic-gate ddi_device_zero(ddi_acc_handle_t handle, caddr_t dev_addr, size_t bytecount, 76637c478bd9Sstevel@tonic-gate ssize_t dev_advcnt, uint_t dev_datasz) 76647c478bd9Sstevel@tonic-gate { 76657c478bd9Sstevel@tonic-gate uint8_t *b; 76667c478bd9Sstevel@tonic-gate uint16_t *w; 76677c478bd9Sstevel@tonic-gate uint32_t *l; 76687c478bd9Sstevel@tonic-gate uint64_t *ll; 76697c478bd9Sstevel@tonic-gate 76707c478bd9Sstevel@tonic-gate /* check for total byte count is multiple of data transfer size */ 76717c478bd9Sstevel@tonic-gate if (bytecount != ((bytecount / dev_datasz) * dev_datasz)) 76727c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 76737c478bd9Sstevel@tonic-gate 76747c478bd9Sstevel@tonic-gate switch (dev_datasz) { 76757c478bd9Sstevel@tonic-gate case DDI_DATA_SZ01_ACC: 76767c478bd9Sstevel@tonic-gate for (b = (uint8_t *)dev_addr; 7677184cd04cScth bytecount != 0; bytecount -= 1, b += dev_advcnt) 76787c478bd9Sstevel@tonic-gate ddi_put8(handle, b, 0); 76797c478bd9Sstevel@tonic-gate break; 76807c478bd9Sstevel@tonic-gate case DDI_DATA_SZ02_ACC: 76817c478bd9Sstevel@tonic-gate for (w = (uint16_t *)dev_addr; 7682184cd04cScth bytecount != 0; bytecount -= 2, w += dev_advcnt) 76837c478bd9Sstevel@tonic-gate ddi_put16(handle, w, 0); 76847c478bd9Sstevel@tonic-gate break; 76857c478bd9Sstevel@tonic-gate case DDI_DATA_SZ04_ACC: 76867c478bd9Sstevel@tonic-gate for (l = (uint32_t *)dev_addr; 7687184cd04cScth bytecount != 0; bytecount -= 4, l += dev_advcnt) 76887c478bd9Sstevel@tonic-gate ddi_put32(handle, l, 0); 76897c478bd9Sstevel@tonic-gate break; 76907c478bd9Sstevel@tonic-gate case DDI_DATA_SZ08_ACC: 76917c478bd9Sstevel@tonic-gate for (ll = (uint64_t *)dev_addr; 7692184cd04cScth bytecount != 0; bytecount -= 8, ll += dev_advcnt) 76937c478bd9Sstevel@tonic-gate ddi_put64(handle, ll, 0x0ll); 76947c478bd9Sstevel@tonic-gate break; 76957c478bd9Sstevel@tonic-gate default: 76967c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 76977c478bd9Sstevel@tonic-gate } 76987c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 76997c478bd9Sstevel@tonic-gate } 77007c478bd9Sstevel@tonic-gate 77017c478bd9Sstevel@tonic-gate int 77027c478bd9Sstevel@tonic-gate ddi_device_copy( 77037c478bd9Sstevel@tonic-gate ddi_acc_handle_t src_handle, caddr_t src_addr, ssize_t src_advcnt, 77047c478bd9Sstevel@tonic-gate ddi_acc_handle_t dest_handle, caddr_t dest_addr, ssize_t dest_advcnt, 77057c478bd9Sstevel@tonic-gate size_t bytecount, uint_t dev_datasz) 77067c478bd9Sstevel@tonic-gate { 77077c478bd9Sstevel@tonic-gate uint8_t *b_src, *b_dst; 77087c478bd9Sstevel@tonic-gate uint16_t *w_src, *w_dst; 77097c478bd9Sstevel@tonic-gate uint32_t *l_src, *l_dst; 77107c478bd9Sstevel@tonic-gate uint64_t *ll_src, *ll_dst; 77117c478bd9Sstevel@tonic-gate 77127c478bd9Sstevel@tonic-gate /* check for total byte count is multiple of data transfer size */ 77137c478bd9Sstevel@tonic-gate if (bytecount != ((bytecount / dev_datasz) * dev_datasz)) 77147c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 77157c478bd9Sstevel@tonic-gate 77167c478bd9Sstevel@tonic-gate switch (dev_datasz) { 77177c478bd9Sstevel@tonic-gate case DDI_DATA_SZ01_ACC: 77187c478bd9Sstevel@tonic-gate b_src = (uint8_t *)src_addr; 77197c478bd9Sstevel@tonic-gate b_dst = (uint8_t *)dest_addr; 77207c478bd9Sstevel@tonic-gate 77217c478bd9Sstevel@tonic-gate for (; bytecount != 0; bytecount -= 1) { 77227c478bd9Sstevel@tonic-gate ddi_put8(dest_handle, b_dst, 7723184cd04cScth ddi_get8(src_handle, b_src)); 77247c478bd9Sstevel@tonic-gate b_dst += dest_advcnt; 77257c478bd9Sstevel@tonic-gate b_src += src_advcnt; 77267c478bd9Sstevel@tonic-gate } 77277c478bd9Sstevel@tonic-gate break; 77287c478bd9Sstevel@tonic-gate case DDI_DATA_SZ02_ACC: 77297c478bd9Sstevel@tonic-gate w_src = (uint16_t *)src_addr; 77307c478bd9Sstevel@tonic-gate w_dst = (uint16_t *)dest_addr; 77317c478bd9Sstevel@tonic-gate 77327c478bd9Sstevel@tonic-gate for (; bytecount != 0; bytecount -= 2) { 77337c478bd9Sstevel@tonic-gate ddi_put16(dest_handle, w_dst, 7734184cd04cScth ddi_get16(src_handle, w_src)); 77357c478bd9Sstevel@tonic-gate w_dst += dest_advcnt; 77367c478bd9Sstevel@tonic-gate w_src += src_advcnt; 77377c478bd9Sstevel@tonic-gate } 77387c478bd9Sstevel@tonic-gate break; 77397c478bd9Sstevel@tonic-gate case DDI_DATA_SZ04_ACC: 77407c478bd9Sstevel@tonic-gate l_src = (uint32_t *)src_addr; 77417c478bd9Sstevel@tonic-gate l_dst = (uint32_t *)dest_addr; 77427c478bd9Sstevel@tonic-gate 77437c478bd9Sstevel@tonic-gate for (; bytecount != 0; bytecount -= 4) { 77447c478bd9Sstevel@tonic-gate ddi_put32(dest_handle, l_dst, 7745184cd04cScth ddi_get32(src_handle, l_src)); 77467c478bd9Sstevel@tonic-gate l_dst += dest_advcnt; 77477c478bd9Sstevel@tonic-gate l_src += src_advcnt; 77487c478bd9Sstevel@tonic-gate } 77497c478bd9Sstevel@tonic-gate break; 77507c478bd9Sstevel@tonic-gate case DDI_DATA_SZ08_ACC: 77517c478bd9Sstevel@tonic-gate ll_src = (uint64_t *)src_addr; 77527c478bd9Sstevel@tonic-gate ll_dst = (uint64_t *)dest_addr; 77537c478bd9Sstevel@tonic-gate 77547c478bd9Sstevel@tonic-gate for (; bytecount != 0; bytecount -= 8) { 77557c478bd9Sstevel@tonic-gate ddi_put64(dest_handle, ll_dst, 7756184cd04cScth ddi_get64(src_handle, ll_src)); 77577c478bd9Sstevel@tonic-gate ll_dst += dest_advcnt; 77587c478bd9Sstevel@tonic-gate ll_src += src_advcnt; 77597c478bd9Sstevel@tonic-gate } 77607c478bd9Sstevel@tonic-gate break; 77617c478bd9Sstevel@tonic-gate default: 77627c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 77637c478bd9Sstevel@tonic-gate } 77647c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 77657c478bd9Sstevel@tonic-gate } 77667c478bd9Sstevel@tonic-gate 77677c478bd9Sstevel@tonic-gate #define swap16(value) \ 77687c478bd9Sstevel@tonic-gate ((((value) & 0xff) << 8) | ((value) >> 8)) 77697c478bd9Sstevel@tonic-gate 77707c478bd9Sstevel@tonic-gate #define swap32(value) \ 77717c478bd9Sstevel@tonic-gate (((uint32_t)swap16((uint16_t)((value) & 0xffff)) << 16) | \ 77727c478bd9Sstevel@tonic-gate (uint32_t)swap16((uint16_t)((value) >> 16))) 77737c478bd9Sstevel@tonic-gate 77747c478bd9Sstevel@tonic-gate #define swap64(value) \ 77757c478bd9Sstevel@tonic-gate (((uint64_t)swap32((uint32_t)((value) & 0xffffffff)) \ 77767c478bd9Sstevel@tonic-gate << 32) | \ 77777c478bd9Sstevel@tonic-gate (uint64_t)swap32((uint32_t)((value) >> 32))) 77787c478bd9Sstevel@tonic-gate 77797c478bd9Sstevel@tonic-gate uint16_t 77807c478bd9Sstevel@tonic-gate ddi_swap16(uint16_t value) 77817c478bd9Sstevel@tonic-gate { 77827c478bd9Sstevel@tonic-gate return (swap16(value)); 77837c478bd9Sstevel@tonic-gate } 77847c478bd9Sstevel@tonic-gate 77857c478bd9Sstevel@tonic-gate uint32_t 77867c478bd9Sstevel@tonic-gate ddi_swap32(uint32_t value) 77877c478bd9Sstevel@tonic-gate { 77887c478bd9Sstevel@tonic-gate return (swap32(value)); 77897c478bd9Sstevel@tonic-gate } 77907c478bd9Sstevel@tonic-gate 77917c478bd9Sstevel@tonic-gate uint64_t 77927c478bd9Sstevel@tonic-gate ddi_swap64(uint64_t value) 77937c478bd9Sstevel@tonic-gate { 77947c478bd9Sstevel@tonic-gate return (swap64(value)); 77957c478bd9Sstevel@tonic-gate } 77967c478bd9Sstevel@tonic-gate 77977c478bd9Sstevel@tonic-gate /* 77987c478bd9Sstevel@tonic-gate * Convert a binding name to a driver name. 77997c478bd9Sstevel@tonic-gate * A binding name is the name used to determine the driver for a 78007c478bd9Sstevel@tonic-gate * device - it may be either an alias for the driver or the name 78017c478bd9Sstevel@tonic-gate * of the driver itself. 78027c478bd9Sstevel@tonic-gate */ 78037c478bd9Sstevel@tonic-gate char * 78047c478bd9Sstevel@tonic-gate i_binding_to_drv_name(char *bname) 78057c478bd9Sstevel@tonic-gate { 78067c478bd9Sstevel@tonic-gate major_t major_no; 78077c478bd9Sstevel@tonic-gate 78087c478bd9Sstevel@tonic-gate ASSERT(bname != NULL); 78097c478bd9Sstevel@tonic-gate 78107c478bd9Sstevel@tonic-gate if ((major_no = ddi_name_to_major(bname)) == -1) 78117c478bd9Sstevel@tonic-gate return (NULL); 78127c478bd9Sstevel@tonic-gate return (ddi_major_to_name(major_no)); 78137c478bd9Sstevel@tonic-gate } 78147c478bd9Sstevel@tonic-gate 78157c478bd9Sstevel@tonic-gate /* 78167c478bd9Sstevel@tonic-gate * Search for minor name that has specified dev_t and spec_type. 78177c478bd9Sstevel@tonic-gate * If spec_type is zero then any dev_t match works. Since we 78187c478bd9Sstevel@tonic-gate * are returning a pointer to the minor name string, we require the 78197c478bd9Sstevel@tonic-gate * caller to do the locking. 78207c478bd9Sstevel@tonic-gate */ 78217c478bd9Sstevel@tonic-gate char * 78227c478bd9Sstevel@tonic-gate i_ddi_devtspectype_to_minorname(dev_info_t *dip, dev_t dev, int spec_type) 78237c478bd9Sstevel@tonic-gate { 78247c478bd9Sstevel@tonic-gate struct ddi_minor_data *dmdp; 78257c478bd9Sstevel@tonic-gate 78267c478bd9Sstevel@tonic-gate /* 78277c478bd9Sstevel@tonic-gate * The did layered driver currently intentionally returns a 78287c478bd9Sstevel@tonic-gate * devinfo ptr for an underlying sd instance based on a did 78297c478bd9Sstevel@tonic-gate * dev_t. In this case it is not an error. 78307c478bd9Sstevel@tonic-gate * 78317c478bd9Sstevel@tonic-gate * The did layered driver is associated with Sun Cluster. 78327c478bd9Sstevel@tonic-gate */ 78337c478bd9Sstevel@tonic-gate ASSERT((ddi_driver_major(dip) == getmajor(dev)) || 7834184cd04cScth (strcmp(ddi_major_to_name(getmajor(dev)), "did") == 0)); 78357c478bd9Sstevel@tonic-gate 7836b9ccdc5aScth ASSERT(DEVI_BUSY_OWNED(dip)); 78377c478bd9Sstevel@tonic-gate for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) { 78387c478bd9Sstevel@tonic-gate if (((dmdp->type == DDM_MINOR) || 78397c478bd9Sstevel@tonic-gate (dmdp->type == DDM_INTERNAL_PATH) || 78407c478bd9Sstevel@tonic-gate (dmdp->type == DDM_DEFAULT)) && 78417c478bd9Sstevel@tonic-gate (dmdp->ddm_dev == dev) && 78427c478bd9Sstevel@tonic-gate ((((spec_type & (S_IFCHR|S_IFBLK))) == 0) || 78437c478bd9Sstevel@tonic-gate (dmdp->ddm_spec_type == spec_type))) 78447c478bd9Sstevel@tonic-gate return (dmdp->ddm_name); 78457c478bd9Sstevel@tonic-gate } 78467c478bd9Sstevel@tonic-gate 78477c478bd9Sstevel@tonic-gate return (NULL); 78487c478bd9Sstevel@tonic-gate } 78497c478bd9Sstevel@tonic-gate 78507c478bd9Sstevel@tonic-gate /* 78517c478bd9Sstevel@tonic-gate * Find the devt and spectype of the specified minor_name. 78527c478bd9Sstevel@tonic-gate * Return DDI_FAILURE if minor_name not found. Since we are 78537c478bd9Sstevel@tonic-gate * returning everything via arguments we can do the locking. 78547c478bd9Sstevel@tonic-gate */ 78557c478bd9Sstevel@tonic-gate int 78567c478bd9Sstevel@tonic-gate i_ddi_minorname_to_devtspectype(dev_info_t *dip, char *minor_name, 78577c478bd9Sstevel@tonic-gate dev_t *devtp, int *spectypep) 78587c478bd9Sstevel@tonic-gate { 7859b9ccdc5aScth int circ; 78607c478bd9Sstevel@tonic-gate struct ddi_minor_data *dmdp; 78617c478bd9Sstevel@tonic-gate 78627c478bd9Sstevel@tonic-gate /* deal with clone minor nodes */ 78637c478bd9Sstevel@tonic-gate if (dip == clone_dip) { 78647c478bd9Sstevel@tonic-gate major_t major; 78657c478bd9Sstevel@tonic-gate /* 78667c478bd9Sstevel@tonic-gate * Make sure minor_name is a STREAMS driver. 78677c478bd9Sstevel@tonic-gate * We load the driver but don't attach to any instances. 78687c478bd9Sstevel@tonic-gate */ 78697c478bd9Sstevel@tonic-gate 78707c478bd9Sstevel@tonic-gate major = ddi_name_to_major(minor_name); 7871a204de77Scth if (major == DDI_MAJOR_T_NONE) 78727c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 78737c478bd9Sstevel@tonic-gate 78747c478bd9Sstevel@tonic-gate if (ddi_hold_driver(major) == NULL) 78757c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 78767c478bd9Sstevel@tonic-gate 78777c478bd9Sstevel@tonic-gate if (STREAMSTAB(major) == NULL) { 78787c478bd9Sstevel@tonic-gate ddi_rele_driver(major); 78797c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 78807c478bd9Sstevel@tonic-gate } 78817c478bd9Sstevel@tonic-gate ddi_rele_driver(major); 78827c478bd9Sstevel@tonic-gate 78837c478bd9Sstevel@tonic-gate if (devtp) 78847c478bd9Sstevel@tonic-gate *devtp = makedevice(clone_major, (minor_t)major); 78857c478bd9Sstevel@tonic-gate 78867c478bd9Sstevel@tonic-gate if (spectypep) 78877c478bd9Sstevel@tonic-gate *spectypep = S_IFCHR; 78887c478bd9Sstevel@tonic-gate 78897c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 78907c478bd9Sstevel@tonic-gate } 78917c478bd9Sstevel@tonic-gate 7892b9ccdc5aScth ndi_devi_enter(dip, &circ); 78937c478bd9Sstevel@tonic-gate for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) { 78947c478bd9Sstevel@tonic-gate if (((dmdp->type != DDM_MINOR) && 78957c478bd9Sstevel@tonic-gate (dmdp->type != DDM_INTERNAL_PATH) && 78967c478bd9Sstevel@tonic-gate (dmdp->type != DDM_DEFAULT)) || 78977c478bd9Sstevel@tonic-gate strcmp(minor_name, dmdp->ddm_name)) 78987c478bd9Sstevel@tonic-gate continue; 78997c478bd9Sstevel@tonic-gate 79007c478bd9Sstevel@tonic-gate if (devtp) 79017c478bd9Sstevel@tonic-gate *devtp = dmdp->ddm_dev; 79027c478bd9Sstevel@tonic-gate 79037c478bd9Sstevel@tonic-gate if (spectypep) 79047c478bd9Sstevel@tonic-gate *spectypep = dmdp->ddm_spec_type; 79057c478bd9Sstevel@tonic-gate 7906b9ccdc5aScth ndi_devi_exit(dip, circ); 79077c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 79087c478bd9Sstevel@tonic-gate } 7909b9ccdc5aScth ndi_devi_exit(dip, circ); 79107c478bd9Sstevel@tonic-gate 79117c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 79127c478bd9Sstevel@tonic-gate } 79137c478bd9Sstevel@tonic-gate 79147c478bd9Sstevel@tonic-gate static kmutex_t devid_gen_mutex; 79157c478bd9Sstevel@tonic-gate static short devid_gen_number; 79167c478bd9Sstevel@tonic-gate 79177c478bd9Sstevel@tonic-gate #ifdef DEBUG 79187c478bd9Sstevel@tonic-gate 79197c478bd9Sstevel@tonic-gate static int devid_register_corrupt = 0; 79207c478bd9Sstevel@tonic-gate static int devid_register_corrupt_major = 0; 79217c478bd9Sstevel@tonic-gate static int devid_register_corrupt_hint = 0; 79227c478bd9Sstevel@tonic-gate static int devid_register_corrupt_hint_major = 0; 79237c478bd9Sstevel@tonic-gate 79247c478bd9Sstevel@tonic-gate static int devid_lyr_debug = 0; 79257c478bd9Sstevel@tonic-gate 79267c478bd9Sstevel@tonic-gate #define DDI_DEBUG_DEVID_DEVTS(msg, ndevs, devs) \ 79277c478bd9Sstevel@tonic-gate if (devid_lyr_debug) \ 79287c478bd9Sstevel@tonic-gate ddi_debug_devid_devts(msg, ndevs, devs) 79297c478bd9Sstevel@tonic-gate 79307c478bd9Sstevel@tonic-gate #else 79317c478bd9Sstevel@tonic-gate 79327c478bd9Sstevel@tonic-gate #define DDI_DEBUG_DEVID_DEVTS(msg, ndevs, devs) 79337c478bd9Sstevel@tonic-gate 79347c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 79357c478bd9Sstevel@tonic-gate 79367c478bd9Sstevel@tonic-gate 79377c478bd9Sstevel@tonic-gate #ifdef DEBUG 79387c478bd9Sstevel@tonic-gate 79397c478bd9Sstevel@tonic-gate static void 79407c478bd9Sstevel@tonic-gate ddi_debug_devid_devts(char *msg, int ndevs, dev_t *devs) 79417c478bd9Sstevel@tonic-gate { 79427c478bd9Sstevel@tonic-gate int i; 79437c478bd9Sstevel@tonic-gate 79447c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "%s:\n", msg); 79457c478bd9Sstevel@tonic-gate for (i = 0; i < ndevs; i++) { 79467c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, " 0x%lx\n", devs[i]); 79477c478bd9Sstevel@tonic-gate } 79487c478bd9Sstevel@tonic-gate } 79497c478bd9Sstevel@tonic-gate 79507c478bd9Sstevel@tonic-gate static void 79517c478bd9Sstevel@tonic-gate ddi_debug_devid_paths(char *msg, int npaths, char **paths) 79527c478bd9Sstevel@tonic-gate { 79537c478bd9Sstevel@tonic-gate int i; 79547c478bd9Sstevel@tonic-gate 79557c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "%s:\n", msg); 79567c478bd9Sstevel@tonic-gate for (i = 0; i < npaths; i++) { 79577c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, " %s\n", paths[i]); 79587c478bd9Sstevel@tonic-gate } 79597c478bd9Sstevel@tonic-gate } 79607c478bd9Sstevel@tonic-gate 79617c478bd9Sstevel@tonic-gate static void 79627c478bd9Sstevel@tonic-gate ddi_debug_devid_devts_per_path(char *path, int ndevs, dev_t *devs) 79637c478bd9Sstevel@tonic-gate { 79647c478bd9Sstevel@tonic-gate int i; 79657c478bd9Sstevel@tonic-gate 79667c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "dev_ts per path %s\n", path); 79677c478bd9Sstevel@tonic-gate for (i = 0; i < ndevs; i++) { 79687c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, " 0x%lx\n", devs[i]); 79697c478bd9Sstevel@tonic-gate } 79707c478bd9Sstevel@tonic-gate } 79717c478bd9Sstevel@tonic-gate 79727c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 79737c478bd9Sstevel@tonic-gate 79747c478bd9Sstevel@tonic-gate /* 79757c478bd9Sstevel@tonic-gate * Register device id into DDI framework. 79767c478bd9Sstevel@tonic-gate * Must be called when device is attached. 79777c478bd9Sstevel@tonic-gate */ 79787c478bd9Sstevel@tonic-gate static int 79797c478bd9Sstevel@tonic-gate i_ddi_devid_register(dev_info_t *dip, ddi_devid_t devid) 79807c478bd9Sstevel@tonic-gate { 79817c478bd9Sstevel@tonic-gate impl_devid_t *i_devid = (impl_devid_t *)devid; 79827c478bd9Sstevel@tonic-gate size_t driver_len; 79837c478bd9Sstevel@tonic-gate const char *driver_name; 79847c478bd9Sstevel@tonic-gate char *devid_str; 79857c478bd9Sstevel@tonic-gate major_t major; 79867c478bd9Sstevel@tonic-gate 79877c478bd9Sstevel@tonic-gate if ((dip == NULL) || 7988a204de77Scth ((major = ddi_driver_major(dip)) == DDI_MAJOR_T_NONE)) 79897c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 79907c478bd9Sstevel@tonic-gate 79917c478bd9Sstevel@tonic-gate /* verify that the devid is valid */ 79927c478bd9Sstevel@tonic-gate if (ddi_devid_valid(devid) != DDI_SUCCESS) 79937c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 79947c478bd9Sstevel@tonic-gate 79957c478bd9Sstevel@tonic-gate /* Updating driver name hint in devid */ 79967c478bd9Sstevel@tonic-gate driver_name = ddi_driver_name(dip); 79977c478bd9Sstevel@tonic-gate driver_len = strlen(driver_name); 79987c478bd9Sstevel@tonic-gate if (driver_len > DEVID_HINT_SIZE) { 79997c478bd9Sstevel@tonic-gate /* Pick up last four characters of driver name */ 80007c478bd9Sstevel@tonic-gate driver_name += driver_len - DEVID_HINT_SIZE; 80017c478bd9Sstevel@tonic-gate driver_len = DEVID_HINT_SIZE; 80027c478bd9Sstevel@tonic-gate } 80037c478bd9Sstevel@tonic-gate bzero(i_devid->did_driver, DEVID_HINT_SIZE); 80047c478bd9Sstevel@tonic-gate bcopy(driver_name, i_devid->did_driver, driver_len); 80057c478bd9Sstevel@tonic-gate 80067c478bd9Sstevel@tonic-gate #ifdef DEBUG 80077c478bd9Sstevel@tonic-gate /* Corrupt the devid for testing. */ 80087c478bd9Sstevel@tonic-gate if (devid_register_corrupt) 80097c478bd9Sstevel@tonic-gate i_devid->did_id[0] += devid_register_corrupt; 80107c478bd9Sstevel@tonic-gate if (devid_register_corrupt_major && 80117c478bd9Sstevel@tonic-gate (major == devid_register_corrupt_major)) 80127c478bd9Sstevel@tonic-gate i_devid->did_id[0] += 1; 80137c478bd9Sstevel@tonic-gate if (devid_register_corrupt_hint) 80147c478bd9Sstevel@tonic-gate i_devid->did_driver[0] += devid_register_corrupt_hint; 80157c478bd9Sstevel@tonic-gate if (devid_register_corrupt_hint_major && 80167c478bd9Sstevel@tonic-gate (major == devid_register_corrupt_hint_major)) 80177c478bd9Sstevel@tonic-gate i_devid->did_driver[0] += 1; 80187c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 80197c478bd9Sstevel@tonic-gate 80207c478bd9Sstevel@tonic-gate /* encode the devid as a string */ 80217c478bd9Sstevel@tonic-gate if ((devid_str = ddi_devid_str_encode(devid, NULL)) == NULL) 80227c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 80237c478bd9Sstevel@tonic-gate 80247c478bd9Sstevel@tonic-gate /* add string as a string property */ 80257c478bd9Sstevel@tonic-gate if (ndi_prop_update_string(DDI_DEV_T_NONE, dip, 80267c478bd9Sstevel@tonic-gate DEVID_PROP_NAME, devid_str) != DDI_SUCCESS) { 80277c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s%d: devid property update failed", 8028184cd04cScth ddi_driver_name(dip), ddi_get_instance(dip)); 80297c478bd9Sstevel@tonic-gate ddi_devid_str_free(devid_str); 80307c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 80317c478bd9Sstevel@tonic-gate } 80327c478bd9Sstevel@tonic-gate 8033602ca9eaScth /* keep pointer to devid string for interrupt context fma code */ 8034602ca9eaScth if (DEVI(dip)->devi_devid_str) 8035602ca9eaScth ddi_devid_str_free(DEVI(dip)->devi_devid_str); 8036602ca9eaScth DEVI(dip)->devi_devid_str = devid_str; 80377c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 80387c478bd9Sstevel@tonic-gate } 80397c478bd9Sstevel@tonic-gate 80407c478bd9Sstevel@tonic-gate int 80417c478bd9Sstevel@tonic-gate ddi_devid_register(dev_info_t *dip, ddi_devid_t devid) 80427c478bd9Sstevel@tonic-gate { 80437c478bd9Sstevel@tonic-gate int rval; 80447c478bd9Sstevel@tonic-gate 80457c478bd9Sstevel@tonic-gate rval = i_ddi_devid_register(dip, devid); 80467c478bd9Sstevel@tonic-gate if (rval == DDI_SUCCESS) { 80477c478bd9Sstevel@tonic-gate /* 80487c478bd9Sstevel@tonic-gate * Register devid in devid-to-path cache 80497c478bd9Sstevel@tonic-gate */ 80507c478bd9Sstevel@tonic-gate if (e_devid_cache_register(dip, devid) == DDI_SUCCESS) { 80517c478bd9Sstevel@tonic-gate mutex_enter(&DEVI(dip)->devi_lock); 80527c478bd9Sstevel@tonic-gate DEVI(dip)->devi_flags |= DEVI_REGISTERED_DEVID; 80537c478bd9Sstevel@tonic-gate mutex_exit(&DEVI(dip)->devi_lock); 80547c478bd9Sstevel@tonic-gate } else { 80557c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s%d: failed to cache devid", 8056184cd04cScth ddi_driver_name(dip), ddi_get_instance(dip)); 80577c478bd9Sstevel@tonic-gate } 80587c478bd9Sstevel@tonic-gate } else { 80597c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s%d: failed to register devid", 8060184cd04cScth ddi_driver_name(dip), ddi_get_instance(dip)); 80617c478bd9Sstevel@tonic-gate } 80627c478bd9Sstevel@tonic-gate return (rval); 80637c478bd9Sstevel@tonic-gate } 80647c478bd9Sstevel@tonic-gate 80657c478bd9Sstevel@tonic-gate /* 80667c478bd9Sstevel@tonic-gate * Remove (unregister) device id from DDI framework. 80677c478bd9Sstevel@tonic-gate * Must be called when device is detached. 80687c478bd9Sstevel@tonic-gate */ 80697c478bd9Sstevel@tonic-gate static void 80707c478bd9Sstevel@tonic-gate i_ddi_devid_unregister(dev_info_t *dip) 80717c478bd9Sstevel@tonic-gate { 8072602ca9eaScth if (DEVI(dip)->devi_devid_str) { 8073602ca9eaScth ddi_devid_str_free(DEVI(dip)->devi_devid_str); 8074602ca9eaScth DEVI(dip)->devi_devid_str = NULL; 8075602ca9eaScth } 80767c478bd9Sstevel@tonic-gate 80777c478bd9Sstevel@tonic-gate /* remove the devid property */ 80787c478bd9Sstevel@tonic-gate (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, DEVID_PROP_NAME); 80797c478bd9Sstevel@tonic-gate } 80807c478bd9Sstevel@tonic-gate 80817c478bd9Sstevel@tonic-gate void 80827c478bd9Sstevel@tonic-gate ddi_devid_unregister(dev_info_t *dip) 80837c478bd9Sstevel@tonic-gate { 80847c478bd9Sstevel@tonic-gate mutex_enter(&DEVI(dip)->devi_lock); 80857c478bd9Sstevel@tonic-gate DEVI(dip)->devi_flags &= ~DEVI_REGISTERED_DEVID; 80867c478bd9Sstevel@tonic-gate mutex_exit(&DEVI(dip)->devi_lock); 80877c478bd9Sstevel@tonic-gate e_devid_cache_unregister(dip); 80887c478bd9Sstevel@tonic-gate i_ddi_devid_unregister(dip); 80897c478bd9Sstevel@tonic-gate } 80907c478bd9Sstevel@tonic-gate 80917c478bd9Sstevel@tonic-gate /* 80927c478bd9Sstevel@tonic-gate * Allocate and initialize a device id. 80937c478bd9Sstevel@tonic-gate */ 80947c478bd9Sstevel@tonic-gate int 80957c478bd9Sstevel@tonic-gate ddi_devid_init( 80967c478bd9Sstevel@tonic-gate dev_info_t *dip, 80977c478bd9Sstevel@tonic-gate ushort_t devid_type, 80987c478bd9Sstevel@tonic-gate ushort_t nbytes, 80997c478bd9Sstevel@tonic-gate void *id, 81007c478bd9Sstevel@tonic-gate ddi_devid_t *ret_devid) 81017c478bd9Sstevel@tonic-gate { 81027c478bd9Sstevel@tonic-gate impl_devid_t *i_devid; 81037c478bd9Sstevel@tonic-gate int sz = sizeof (*i_devid) + nbytes - sizeof (char); 81047c478bd9Sstevel@tonic-gate int driver_len; 81057c478bd9Sstevel@tonic-gate const char *driver_name; 81067c478bd9Sstevel@tonic-gate 81077c478bd9Sstevel@tonic-gate switch (devid_type) { 81087c478bd9Sstevel@tonic-gate case DEVID_SCSI3_WWN: 81097c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 81107c478bd9Sstevel@tonic-gate case DEVID_SCSI_SERIAL: 81117c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 81127c478bd9Sstevel@tonic-gate case DEVID_ATA_SERIAL: 81137c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 81147c478bd9Sstevel@tonic-gate case DEVID_ENCAP: 81157c478bd9Sstevel@tonic-gate if (nbytes == 0) 81167c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 81177c478bd9Sstevel@tonic-gate if (id == NULL) 81187c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 81197c478bd9Sstevel@tonic-gate break; 81207c478bd9Sstevel@tonic-gate case DEVID_FAB: 81217c478bd9Sstevel@tonic-gate if (nbytes != 0) 81227c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 81237c478bd9Sstevel@tonic-gate if (id != NULL) 81247c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 81257c478bd9Sstevel@tonic-gate nbytes = sizeof (int) + 81267c478bd9Sstevel@tonic-gate sizeof (struct timeval32) + sizeof (short); 81277c478bd9Sstevel@tonic-gate sz += nbytes; 81287c478bd9Sstevel@tonic-gate break; 81297c478bd9Sstevel@tonic-gate default: 81307c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 81317c478bd9Sstevel@tonic-gate } 81327c478bd9Sstevel@tonic-gate 81337c478bd9Sstevel@tonic-gate if ((i_devid = kmem_zalloc(sz, KM_SLEEP)) == NULL) 81347c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 81357c478bd9Sstevel@tonic-gate 81367c478bd9Sstevel@tonic-gate i_devid->did_magic_hi = DEVID_MAGIC_MSB; 81377c478bd9Sstevel@tonic-gate i_devid->did_magic_lo = DEVID_MAGIC_LSB; 81387c478bd9Sstevel@tonic-gate i_devid->did_rev_hi = DEVID_REV_MSB; 81397c478bd9Sstevel@tonic-gate i_devid->did_rev_lo = DEVID_REV_LSB; 81407c478bd9Sstevel@tonic-gate DEVID_FORMTYPE(i_devid, devid_type); 81417c478bd9Sstevel@tonic-gate DEVID_FORMLEN(i_devid, nbytes); 81427c478bd9Sstevel@tonic-gate 81437c478bd9Sstevel@tonic-gate /* Fill in driver name hint */ 81447c478bd9Sstevel@tonic-gate driver_name = ddi_driver_name(dip); 81457c478bd9Sstevel@tonic-gate driver_len = strlen(driver_name); 81467c478bd9Sstevel@tonic-gate if (driver_len > DEVID_HINT_SIZE) { 81477c478bd9Sstevel@tonic-gate /* Pick up last four characters of driver name */ 81487c478bd9Sstevel@tonic-gate driver_name += driver_len - DEVID_HINT_SIZE; 81497c478bd9Sstevel@tonic-gate driver_len = DEVID_HINT_SIZE; 81507c478bd9Sstevel@tonic-gate } 81517c478bd9Sstevel@tonic-gate 81527c478bd9Sstevel@tonic-gate bcopy(driver_name, i_devid->did_driver, driver_len); 81537c478bd9Sstevel@tonic-gate 81547c478bd9Sstevel@tonic-gate /* Fill in id field */ 81557c478bd9Sstevel@tonic-gate if (devid_type == DEVID_FAB) { 81567c478bd9Sstevel@tonic-gate char *cp; 81575679c89fSjv uint32_t hostid; 81587c478bd9Sstevel@tonic-gate struct timeval32 timestamp32; 81597c478bd9Sstevel@tonic-gate int i; 81607c478bd9Sstevel@tonic-gate int *ip; 81617c478bd9Sstevel@tonic-gate short gen; 81627c478bd9Sstevel@tonic-gate 81637c478bd9Sstevel@tonic-gate /* increase the generation number */ 81647c478bd9Sstevel@tonic-gate mutex_enter(&devid_gen_mutex); 81657c478bd9Sstevel@tonic-gate gen = devid_gen_number++; 81667c478bd9Sstevel@tonic-gate mutex_exit(&devid_gen_mutex); 81677c478bd9Sstevel@tonic-gate 81687c478bd9Sstevel@tonic-gate cp = i_devid->did_id; 81697c478bd9Sstevel@tonic-gate 81707c478bd9Sstevel@tonic-gate /* Fill in host id (big-endian byte ordering) */ 81715679c89fSjv hostid = zone_get_hostid(NULL); 81727c478bd9Sstevel@tonic-gate *cp++ = hibyte(hiword(hostid)); 81737c478bd9Sstevel@tonic-gate *cp++ = lobyte(hiword(hostid)); 81747c478bd9Sstevel@tonic-gate *cp++ = hibyte(loword(hostid)); 81757c478bd9Sstevel@tonic-gate *cp++ = lobyte(loword(hostid)); 81767c478bd9Sstevel@tonic-gate 81777c478bd9Sstevel@tonic-gate /* 81787c478bd9Sstevel@tonic-gate * Fill in timestamp (big-endian byte ordering) 81797c478bd9Sstevel@tonic-gate * 81807c478bd9Sstevel@tonic-gate * (Note that the format may have to be changed 81817c478bd9Sstevel@tonic-gate * before 2038 comes around, though it's arguably 81827c478bd9Sstevel@tonic-gate * unique enough as it is..) 81837c478bd9Sstevel@tonic-gate */ 81847c478bd9Sstevel@tonic-gate uniqtime32(×tamp32); 81857c478bd9Sstevel@tonic-gate ip = (int *)×tamp32; 81867c478bd9Sstevel@tonic-gate for (i = 0; 81877c478bd9Sstevel@tonic-gate i < sizeof (timestamp32) / sizeof (int); i++, ip++) { 81887c478bd9Sstevel@tonic-gate int val; 81897c478bd9Sstevel@tonic-gate val = *ip; 81907c478bd9Sstevel@tonic-gate *cp++ = hibyte(hiword(val)); 81917c478bd9Sstevel@tonic-gate *cp++ = lobyte(hiword(val)); 81927c478bd9Sstevel@tonic-gate *cp++ = hibyte(loword(val)); 81937c478bd9Sstevel@tonic-gate *cp++ = lobyte(loword(val)); 81947c478bd9Sstevel@tonic-gate } 81957c478bd9Sstevel@tonic-gate 81967c478bd9Sstevel@tonic-gate /* fill in the generation number */ 81977c478bd9Sstevel@tonic-gate *cp++ = hibyte(gen); 81987c478bd9Sstevel@tonic-gate *cp++ = lobyte(gen); 81997c478bd9Sstevel@tonic-gate } else 82007c478bd9Sstevel@tonic-gate bcopy(id, i_devid->did_id, nbytes); 82017c478bd9Sstevel@tonic-gate 82027c478bd9Sstevel@tonic-gate /* return device id */ 82037c478bd9Sstevel@tonic-gate *ret_devid = (ddi_devid_t)i_devid; 82047c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 82057c478bd9Sstevel@tonic-gate } 82067c478bd9Sstevel@tonic-gate 82078d483882Smlf int 82088d483882Smlf ddi_devid_get(dev_info_t *dip, ddi_devid_t *ret_devid) 82098d483882Smlf { 82108d483882Smlf return (i_ddi_devi_get_devid(DDI_DEV_T_ANY, dip, ret_devid)); 82118d483882Smlf } 82128d483882Smlf 82137c478bd9Sstevel@tonic-gate int 82147c478bd9Sstevel@tonic-gate i_ddi_devi_get_devid(dev_t dev, dev_info_t *dip, ddi_devid_t *ret_devid) 82157c478bd9Sstevel@tonic-gate { 82167c478bd9Sstevel@tonic-gate char *devidstr; 82177c478bd9Sstevel@tonic-gate 82187c478bd9Sstevel@tonic-gate ASSERT(dev != DDI_DEV_T_NONE); 82197c478bd9Sstevel@tonic-gate 82207c478bd9Sstevel@tonic-gate /* look up the property, devt specific first */ 82217c478bd9Sstevel@tonic-gate if (ddi_prop_lookup_string(dev, dip, DDI_PROP_DONTPASS, 82227c478bd9Sstevel@tonic-gate DEVID_PROP_NAME, &devidstr) != DDI_PROP_SUCCESS) { 82237c478bd9Sstevel@tonic-gate if ((dev == DDI_DEV_T_ANY) || 82247c478bd9Sstevel@tonic-gate (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 8225184cd04cScth DDI_PROP_DONTPASS, DEVID_PROP_NAME, &devidstr) != 8226184cd04cScth DDI_PROP_SUCCESS)) { 8227184cd04cScth return (DDI_FAILURE); 82287c478bd9Sstevel@tonic-gate } 82297c478bd9Sstevel@tonic-gate } 82307c478bd9Sstevel@tonic-gate 82317c478bd9Sstevel@tonic-gate /* convert to binary form */ 82327c478bd9Sstevel@tonic-gate if (ddi_devid_str_decode(devidstr, ret_devid, NULL) == -1) { 82337c478bd9Sstevel@tonic-gate ddi_prop_free(devidstr); 82347c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 82357c478bd9Sstevel@tonic-gate } 82367c478bd9Sstevel@tonic-gate ddi_prop_free(devidstr); 82377c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 82387c478bd9Sstevel@tonic-gate } 82397c478bd9Sstevel@tonic-gate 82407c478bd9Sstevel@tonic-gate /* 82417c478bd9Sstevel@tonic-gate * Return a copy of the device id for dev_t 82427c478bd9Sstevel@tonic-gate */ 82437c478bd9Sstevel@tonic-gate int 82447c478bd9Sstevel@tonic-gate ddi_lyr_get_devid(dev_t dev, ddi_devid_t *ret_devid) 82457c478bd9Sstevel@tonic-gate { 82467c478bd9Sstevel@tonic-gate dev_info_t *dip; 82477c478bd9Sstevel@tonic-gate int rval; 82487c478bd9Sstevel@tonic-gate 82497c478bd9Sstevel@tonic-gate /* get the dip */ 82507c478bd9Sstevel@tonic-gate if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 82517c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 82527c478bd9Sstevel@tonic-gate 82537c478bd9Sstevel@tonic-gate rval = i_ddi_devi_get_devid(dev, dip, ret_devid); 82547c478bd9Sstevel@tonic-gate 82557c478bd9Sstevel@tonic-gate ddi_release_devi(dip); /* e_ddi_hold_devi_by_dev() */ 82567c478bd9Sstevel@tonic-gate return (rval); 82577c478bd9Sstevel@tonic-gate } 82587c478bd9Sstevel@tonic-gate 82597c478bd9Sstevel@tonic-gate /* 82607c478bd9Sstevel@tonic-gate * Return a copy of the minor name for dev_t and spec_type 82617c478bd9Sstevel@tonic-gate */ 82627c478bd9Sstevel@tonic-gate int 82637c478bd9Sstevel@tonic-gate ddi_lyr_get_minor_name(dev_t dev, int spec_type, char **minor_name) 82647c478bd9Sstevel@tonic-gate { 8265b9ccdc5aScth char *buf; 8266b9ccdc5aScth int circ; 82677c478bd9Sstevel@tonic-gate dev_info_t *dip; 82687c478bd9Sstevel@tonic-gate char *nm; 8269b9ccdc5aScth int rval; 82707c478bd9Sstevel@tonic-gate 8271b9ccdc5aScth if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) { 8272b9ccdc5aScth *minor_name = NULL; 82737c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 82747c478bd9Sstevel@tonic-gate } 82757c478bd9Sstevel@tonic-gate 8276b9ccdc5aScth /* Find the minor name and copy into max size buf */ 8277b9ccdc5aScth buf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 8278b9ccdc5aScth ndi_devi_enter(dip, &circ); 8279b9ccdc5aScth nm = i_ddi_devtspectype_to_minorname(dip, dev, spec_type); 8280b9ccdc5aScth if (nm) 8281b9ccdc5aScth (void) strcpy(buf, nm); 8282b9ccdc5aScth ndi_devi_exit(dip, circ); 8283b9ccdc5aScth ddi_release_devi(dip); /* e_ddi_hold_devi_by_dev() */ 82847c478bd9Sstevel@tonic-gate 8285b9ccdc5aScth if (nm) { 8286b9ccdc5aScth /* duplicate into min size buf for return result */ 8287b9ccdc5aScth *minor_name = i_ddi_strdup(buf, KM_SLEEP); 8288b9ccdc5aScth rval = DDI_SUCCESS; 8289b9ccdc5aScth } else { 82907c478bd9Sstevel@tonic-gate *minor_name = NULL; 8291b9ccdc5aScth rval = DDI_FAILURE; 82927c478bd9Sstevel@tonic-gate } 82937c478bd9Sstevel@tonic-gate 8294b9ccdc5aScth /* free max size buf and return */ 8295b9ccdc5aScth kmem_free(buf, MAXNAMELEN); 8296b9ccdc5aScth return (rval); 82977c478bd9Sstevel@tonic-gate } 82987c478bd9Sstevel@tonic-gate 82997c478bd9Sstevel@tonic-gate int 83007c478bd9Sstevel@tonic-gate ddi_lyr_devid_to_devlist( 83017c478bd9Sstevel@tonic-gate ddi_devid_t devid, 83027c478bd9Sstevel@tonic-gate char *minor_name, 83037c478bd9Sstevel@tonic-gate int *retndevs, 83047c478bd9Sstevel@tonic-gate dev_t **retdevs) 83057c478bd9Sstevel@tonic-gate { 83067c478bd9Sstevel@tonic-gate ASSERT(ddi_devid_valid(devid) == DDI_SUCCESS); 83077c478bd9Sstevel@tonic-gate 83087c478bd9Sstevel@tonic-gate if (e_devid_cache_to_devt_list(devid, minor_name, 83097c478bd9Sstevel@tonic-gate retndevs, retdevs) == DDI_SUCCESS) { 83107c478bd9Sstevel@tonic-gate ASSERT(*retndevs > 0); 83117c478bd9Sstevel@tonic-gate DDI_DEBUG_DEVID_DEVTS("ddi_lyr_devid_to_devlist", 8312184cd04cScth *retndevs, *retdevs); 83137c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 83147c478bd9Sstevel@tonic-gate } 83157c478bd9Sstevel@tonic-gate 83167c478bd9Sstevel@tonic-gate if (e_ddi_devid_discovery(devid) == DDI_FAILURE) { 83177c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 83187c478bd9Sstevel@tonic-gate } 83197c478bd9Sstevel@tonic-gate 83207c478bd9Sstevel@tonic-gate if (e_devid_cache_to_devt_list(devid, minor_name, 83217c478bd9Sstevel@tonic-gate retndevs, retdevs) == DDI_SUCCESS) { 83227c478bd9Sstevel@tonic-gate ASSERT(*retndevs > 0); 83237c478bd9Sstevel@tonic-gate DDI_DEBUG_DEVID_DEVTS("ddi_lyr_devid_to_devlist", 8324184cd04cScth *retndevs, *retdevs); 83257c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 83267c478bd9Sstevel@tonic-gate } 83277c478bd9Sstevel@tonic-gate 83287c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 83297c478bd9Sstevel@tonic-gate } 83307c478bd9Sstevel@tonic-gate 83317c478bd9Sstevel@tonic-gate void 83327c478bd9Sstevel@tonic-gate ddi_lyr_free_devlist(dev_t *devlist, int ndevs) 83337c478bd9Sstevel@tonic-gate { 83347c478bd9Sstevel@tonic-gate kmem_free(devlist, sizeof (dev_t) * ndevs); 83357c478bd9Sstevel@tonic-gate } 83367c478bd9Sstevel@tonic-gate 83377c478bd9Sstevel@tonic-gate /* 83387c478bd9Sstevel@tonic-gate * Note: This will need to be fixed if we ever allow processes to 83397c478bd9Sstevel@tonic-gate * have more than one data model per exec. 83407c478bd9Sstevel@tonic-gate */ 83417c478bd9Sstevel@tonic-gate model_t 83427c478bd9Sstevel@tonic-gate ddi_mmap_get_model(void) 83437c478bd9Sstevel@tonic-gate { 83447c478bd9Sstevel@tonic-gate return (get_udatamodel()); 83457c478bd9Sstevel@tonic-gate } 83467c478bd9Sstevel@tonic-gate 83477c478bd9Sstevel@tonic-gate model_t 83487c478bd9Sstevel@tonic-gate ddi_model_convert_from(model_t model) 83497c478bd9Sstevel@tonic-gate { 83507c478bd9Sstevel@tonic-gate return ((model & DDI_MODEL_MASK) & ~DDI_MODEL_NATIVE); 83517c478bd9Sstevel@tonic-gate } 83527c478bd9Sstevel@tonic-gate 83537c478bd9Sstevel@tonic-gate /* 83547c478bd9Sstevel@tonic-gate * ddi interfaces managing storage and retrieval of eventcookies. 83557c478bd9Sstevel@tonic-gate */ 83567c478bd9Sstevel@tonic-gate 83577c478bd9Sstevel@tonic-gate /* 83587c478bd9Sstevel@tonic-gate * Invoke bus nexus driver's implementation of the 83597c478bd9Sstevel@tonic-gate * (*bus_remove_eventcall)() interface to remove a registered 83607c478bd9Sstevel@tonic-gate * callback handler for "event". 83617c478bd9Sstevel@tonic-gate */ 83627c478bd9Sstevel@tonic-gate int 83637c478bd9Sstevel@tonic-gate ddi_remove_event_handler(ddi_callback_id_t id) 83647c478bd9Sstevel@tonic-gate { 83657c478bd9Sstevel@tonic-gate ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)id; 83667c478bd9Sstevel@tonic-gate dev_info_t *ddip; 83677c478bd9Sstevel@tonic-gate 83687c478bd9Sstevel@tonic-gate ASSERT(cb); 83697c478bd9Sstevel@tonic-gate if (!cb) { 83707c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 83717c478bd9Sstevel@tonic-gate } 83727c478bd9Sstevel@tonic-gate 83737c478bd9Sstevel@tonic-gate ddip = NDI_EVENT_DDIP(cb->ndi_evtcb_cookie); 83747c478bd9Sstevel@tonic-gate return (ndi_busop_remove_eventcall(ddip, id)); 83757c478bd9Sstevel@tonic-gate } 83767c478bd9Sstevel@tonic-gate 83777c478bd9Sstevel@tonic-gate /* 83787c478bd9Sstevel@tonic-gate * Invoke bus nexus driver's implementation of the 83797c478bd9Sstevel@tonic-gate * (*bus_add_eventcall)() interface to register a callback handler 83807c478bd9Sstevel@tonic-gate * for "event". 83817c478bd9Sstevel@tonic-gate */ 83827c478bd9Sstevel@tonic-gate int 83837c478bd9Sstevel@tonic-gate ddi_add_event_handler(dev_info_t *dip, ddi_eventcookie_t event, 83847c478bd9Sstevel@tonic-gate void (*handler)(dev_info_t *, ddi_eventcookie_t, void *, void *), 83857c478bd9Sstevel@tonic-gate void *arg, ddi_callback_id_t *id) 83867c478bd9Sstevel@tonic-gate { 83877c478bd9Sstevel@tonic-gate return (ndi_busop_add_eventcall(dip, dip, event, handler, arg, id)); 83887c478bd9Sstevel@tonic-gate } 83897c478bd9Sstevel@tonic-gate 83907c478bd9Sstevel@tonic-gate 83917c478bd9Sstevel@tonic-gate /* 83927c478bd9Sstevel@tonic-gate * Return a handle for event "name" by calling up the device tree 83937c478bd9Sstevel@tonic-gate * hierarchy via (*bus_get_eventcookie)() interface until claimed 83947c478bd9Sstevel@tonic-gate * by a bus nexus or top of dev_info tree is reached. 83957c478bd9Sstevel@tonic-gate */ 83967c478bd9Sstevel@tonic-gate int 83977c478bd9Sstevel@tonic-gate ddi_get_eventcookie(dev_info_t *dip, char *name, 83987c478bd9Sstevel@tonic-gate ddi_eventcookie_t *event_cookiep) 83997c478bd9Sstevel@tonic-gate { 84007c478bd9Sstevel@tonic-gate return (ndi_busop_get_eventcookie(dip, dip, 84017c478bd9Sstevel@tonic-gate name, event_cookiep)); 84027c478bd9Sstevel@tonic-gate } 84037c478bd9Sstevel@tonic-gate 84047c478bd9Sstevel@tonic-gate /* 84057c478bd9Sstevel@tonic-gate * This procedure is provided as the general callback function when 84067c478bd9Sstevel@tonic-gate * umem_lockmemory calls as_add_callback for long term memory locking. 84077c478bd9Sstevel@tonic-gate * When as_unmap, as_setprot, or as_free encounter segments which have 84087c478bd9Sstevel@tonic-gate * locked memory, this callback will be invoked. 84097c478bd9Sstevel@tonic-gate */ 84107c478bd9Sstevel@tonic-gate void 84117c478bd9Sstevel@tonic-gate umem_lock_undo(struct as *as, void *arg, uint_t event) 84127c478bd9Sstevel@tonic-gate { 84137c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(as, event)) 84147c478bd9Sstevel@tonic-gate struct ddi_umem_cookie *cp = (struct ddi_umem_cookie *)arg; 84157c478bd9Sstevel@tonic-gate 84167c478bd9Sstevel@tonic-gate /* 84177c478bd9Sstevel@tonic-gate * Call the cleanup function. Decrement the cookie reference 84187c478bd9Sstevel@tonic-gate * count, if it goes to zero, return the memory for the cookie. 84197c478bd9Sstevel@tonic-gate * The i_ddi_umem_unlock for this cookie may or may not have been 84207c478bd9Sstevel@tonic-gate * called already. It is the responsibility of the caller of 84217c478bd9Sstevel@tonic-gate * umem_lockmemory to handle the case of the cleanup routine 84227c478bd9Sstevel@tonic-gate * being called after a ddi_umem_unlock for the cookie 84237c478bd9Sstevel@tonic-gate * was called. 84247c478bd9Sstevel@tonic-gate */ 84257c478bd9Sstevel@tonic-gate 84267c478bd9Sstevel@tonic-gate (*cp->callbacks.cbo_umem_lock_cleanup)((ddi_umem_cookie_t)cp); 84277c478bd9Sstevel@tonic-gate 84287c478bd9Sstevel@tonic-gate /* remove the cookie if reference goes to zero */ 84297c478bd9Sstevel@tonic-gate if (atomic_add_long_nv((ulong_t *)(&(cp->cook_refcnt)), -1) == 0) { 84307c478bd9Sstevel@tonic-gate kmem_free(cp, sizeof (struct ddi_umem_cookie)); 84317c478bd9Sstevel@tonic-gate } 84327c478bd9Sstevel@tonic-gate } 84337c478bd9Sstevel@tonic-gate 84347c478bd9Sstevel@tonic-gate /* 84357c478bd9Sstevel@tonic-gate * The following two Consolidation Private routines provide generic 84367c478bd9Sstevel@tonic-gate * interfaces to increase/decrease the amount of device-locked memory. 84377c478bd9Sstevel@tonic-gate * 84387c478bd9Sstevel@tonic-gate * To keep project_rele and project_hold consistent, i_ddi_decr_locked_memory() 84397c478bd9Sstevel@tonic-gate * must be called every time i_ddi_incr_locked_memory() is called. 84407c478bd9Sstevel@tonic-gate */ 84417c478bd9Sstevel@tonic-gate int 84427c478bd9Sstevel@tonic-gate /* ARGSUSED */ 8443c6939658Ssl i_ddi_incr_locked_memory(proc_t *procp, rctl_qty_t inc) 84447c478bd9Sstevel@tonic-gate { 8445c6939658Ssl ASSERT(procp != NULL); 8446c6939658Ssl mutex_enter(&procp->p_lock); 8447c6939658Ssl if (rctl_incr_locked_mem(procp, NULL, inc, 1)) { 8448c6939658Ssl mutex_exit(&procp->p_lock); 84497c478bd9Sstevel@tonic-gate return (ENOMEM); 84507c478bd9Sstevel@tonic-gate } 8451c6939658Ssl mutex_exit(&procp->p_lock); 84527c478bd9Sstevel@tonic-gate return (0); 84537c478bd9Sstevel@tonic-gate } 84547c478bd9Sstevel@tonic-gate 84557c478bd9Sstevel@tonic-gate /* 84567c478bd9Sstevel@tonic-gate * To keep project_rele and project_hold consistent, i_ddi_incr_locked_memory() 84577c478bd9Sstevel@tonic-gate * must be called every time i_ddi_decr_locked_memory() is called. 84587c478bd9Sstevel@tonic-gate */ 84597c478bd9Sstevel@tonic-gate /* ARGSUSED */ 84607c478bd9Sstevel@tonic-gate void 8461c6939658Ssl i_ddi_decr_locked_memory(proc_t *procp, rctl_qty_t dec) 84627c478bd9Sstevel@tonic-gate { 8463c6939658Ssl ASSERT(procp != NULL); 8464c6939658Ssl mutex_enter(&procp->p_lock); 8465c6939658Ssl rctl_decr_locked_mem(procp, NULL, dec, 1); 8466c6939658Ssl mutex_exit(&procp->p_lock); 84677c478bd9Sstevel@tonic-gate } 84687c478bd9Sstevel@tonic-gate 84697c478bd9Sstevel@tonic-gate /* 8470c6939658Ssl * This routine checks if the max-locked-memory resource ctl is 84717c478bd9Sstevel@tonic-gate * exceeded, if not increments it, grabs a hold on the project. 84727c478bd9Sstevel@tonic-gate * Returns 0 if successful otherwise returns error code 84737c478bd9Sstevel@tonic-gate */ 84747c478bd9Sstevel@tonic-gate static int 84757c478bd9Sstevel@tonic-gate umem_incr_devlockmem(struct ddi_umem_cookie *cookie) 84767c478bd9Sstevel@tonic-gate { 84777c478bd9Sstevel@tonic-gate proc_t *procp; 84787c478bd9Sstevel@tonic-gate int ret; 84797c478bd9Sstevel@tonic-gate 84807c478bd9Sstevel@tonic-gate ASSERT(cookie); 84817c478bd9Sstevel@tonic-gate procp = cookie->procp; 84827c478bd9Sstevel@tonic-gate ASSERT(procp); 84837c478bd9Sstevel@tonic-gate 8484c6939658Ssl if ((ret = i_ddi_incr_locked_memory(procp, 8485184cd04cScth cookie->size)) != 0) { 84867c478bd9Sstevel@tonic-gate return (ret); 84877c478bd9Sstevel@tonic-gate } 84887c478bd9Sstevel@tonic-gate return (0); 84897c478bd9Sstevel@tonic-gate } 84907c478bd9Sstevel@tonic-gate 84917c478bd9Sstevel@tonic-gate /* 8492c6939658Ssl * Decrements the max-locked-memory resource ctl and releases 84937c478bd9Sstevel@tonic-gate * the hold on the project that was acquired during umem_incr_devlockmem 84947c478bd9Sstevel@tonic-gate */ 84957c478bd9Sstevel@tonic-gate static void 84967c478bd9Sstevel@tonic-gate umem_decr_devlockmem(struct ddi_umem_cookie *cookie) 84977c478bd9Sstevel@tonic-gate { 8498c6939658Ssl proc_t *proc; 84997c478bd9Sstevel@tonic-gate 8500c6939658Ssl proc = (proc_t *)cookie->procp; 8501c6939658Ssl if (!proc) 85027c478bd9Sstevel@tonic-gate return; 85037c478bd9Sstevel@tonic-gate 8504c6939658Ssl i_ddi_decr_locked_memory(proc, cookie->size); 85057c478bd9Sstevel@tonic-gate } 85067c478bd9Sstevel@tonic-gate 85077c478bd9Sstevel@tonic-gate /* 85087c478bd9Sstevel@tonic-gate * A consolidation private function which is essentially equivalent to 85097c478bd9Sstevel@tonic-gate * ddi_umem_lock but with the addition of arguments ops_vector and procp. 85107c478bd9Sstevel@tonic-gate * A call to as_add_callback is done if DDI_UMEMLOCK_LONGTERM is set, and 85117c478bd9Sstevel@tonic-gate * the ops_vector is valid. 85127c478bd9Sstevel@tonic-gate * 85137c478bd9Sstevel@tonic-gate * Lock the virtual address range in the current process and create a 85147c478bd9Sstevel@tonic-gate * ddi_umem_cookie (of type UMEM_LOCKED). This can be used to pass to 85157c478bd9Sstevel@tonic-gate * ddi_umem_iosetup to create a buf or do devmap_umem_setup/remap to export 85167c478bd9Sstevel@tonic-gate * to user space. 85177c478bd9Sstevel@tonic-gate * 85187c478bd9Sstevel@tonic-gate * Note: The resource control accounting currently uses a full charge model 85197c478bd9Sstevel@tonic-gate * in other words attempts to lock the same/overlapping areas of memory 85207c478bd9Sstevel@tonic-gate * will deduct the full size of the buffer from the projects running 85217c478bd9Sstevel@tonic-gate * counter for the device locked memory. 85227c478bd9Sstevel@tonic-gate * 85237c478bd9Sstevel@tonic-gate * addr, size should be PAGESIZE aligned 85247c478bd9Sstevel@tonic-gate * 85257c478bd9Sstevel@tonic-gate * flags - DDI_UMEMLOCK_READ, DDI_UMEMLOCK_WRITE or both 85267c478bd9Sstevel@tonic-gate * identifies whether the locked memory will be read or written or both 85277c478bd9Sstevel@tonic-gate * DDI_UMEMLOCK_LONGTERM must be set when the locking will 85287c478bd9Sstevel@tonic-gate * be maintained for an indefinitely long period (essentially permanent), 85297c478bd9Sstevel@tonic-gate * rather than for what would be required for a typical I/O completion. 85307c478bd9Sstevel@tonic-gate * When DDI_UMEMLOCK_LONGTERM is set, umem_lockmemory will return EFAULT 85317c478bd9Sstevel@tonic-gate * if the memory pertains to a regular file which is mapped MAP_SHARED. 85327c478bd9Sstevel@tonic-gate * This is to prevent a deadlock if a file truncation is attempted after 85337c478bd9Sstevel@tonic-gate * after the locking is done. 85347c478bd9Sstevel@tonic-gate * 85357c478bd9Sstevel@tonic-gate * Returns 0 on success 85367c478bd9Sstevel@tonic-gate * EINVAL - for invalid parameters 85377c478bd9Sstevel@tonic-gate * EPERM, ENOMEM and other error codes returned by as_pagelock 85387c478bd9Sstevel@tonic-gate * ENOMEM - is returned if the current request to lock memory exceeds 8539c6939658Ssl * *.max-locked-memory resource control value. 85407c478bd9Sstevel@tonic-gate * EFAULT - memory pertains to a regular file mapped shared and 85417c478bd9Sstevel@tonic-gate * and DDI_UMEMLOCK_LONGTERM flag is set 85427c478bd9Sstevel@tonic-gate * EAGAIN - could not start the ddi_umem_unlock list processing thread 85437c478bd9Sstevel@tonic-gate */ 85447c478bd9Sstevel@tonic-gate int 85457c478bd9Sstevel@tonic-gate umem_lockmemory(caddr_t addr, size_t len, int flags, ddi_umem_cookie_t *cookie, 85467c478bd9Sstevel@tonic-gate struct umem_callback_ops *ops_vector, 85477c478bd9Sstevel@tonic-gate proc_t *procp) 85487c478bd9Sstevel@tonic-gate { 85497c478bd9Sstevel@tonic-gate int error; 85507c478bd9Sstevel@tonic-gate struct ddi_umem_cookie *p; 85517c478bd9Sstevel@tonic-gate void (*driver_callback)() = NULL; 8552d863b343SBill Taylor struct as *as; 85537c478bd9Sstevel@tonic-gate struct seg *seg; 85547c478bd9Sstevel@tonic-gate vnode_t *vp; 85557c478bd9Sstevel@tonic-gate 8556d863b343SBill Taylor /* Allow device drivers to not have to reference "curproc" */ 8557d863b343SBill Taylor if (procp == NULL) 8558d863b343SBill Taylor procp = curproc; 8559d863b343SBill Taylor as = procp->p_as; 85607c478bd9Sstevel@tonic-gate *cookie = NULL; /* in case of any error return */ 85617c478bd9Sstevel@tonic-gate 85627c478bd9Sstevel@tonic-gate /* These are the only three valid flags */ 85637c478bd9Sstevel@tonic-gate if ((flags & ~(DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE | 85647c478bd9Sstevel@tonic-gate DDI_UMEMLOCK_LONGTERM)) != 0) 85657c478bd9Sstevel@tonic-gate return (EINVAL); 85667c478bd9Sstevel@tonic-gate 85677c478bd9Sstevel@tonic-gate /* At least one (can be both) of the two access flags must be set */ 85687c478bd9Sstevel@tonic-gate if ((flags & (DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE)) == 0) 85697c478bd9Sstevel@tonic-gate return (EINVAL); 85707c478bd9Sstevel@tonic-gate 85717c478bd9Sstevel@tonic-gate /* addr and len must be page-aligned */ 85727c478bd9Sstevel@tonic-gate if (((uintptr_t)addr & PAGEOFFSET) != 0) 85737c478bd9Sstevel@tonic-gate return (EINVAL); 85747c478bd9Sstevel@tonic-gate 85757c478bd9Sstevel@tonic-gate if ((len & PAGEOFFSET) != 0) 85767c478bd9Sstevel@tonic-gate return (EINVAL); 85777c478bd9Sstevel@tonic-gate 85787c478bd9Sstevel@tonic-gate /* 85797c478bd9Sstevel@tonic-gate * For longterm locking a driver callback must be specified; if 85807c478bd9Sstevel@tonic-gate * not longterm then a callback is optional. 85817c478bd9Sstevel@tonic-gate */ 85827c478bd9Sstevel@tonic-gate if (ops_vector != NULL) { 85837c478bd9Sstevel@tonic-gate if (ops_vector->cbo_umem_callback_version != 85847c478bd9Sstevel@tonic-gate UMEM_CALLBACK_VERSION) 85857c478bd9Sstevel@tonic-gate return (EINVAL); 85867c478bd9Sstevel@tonic-gate else 85877c478bd9Sstevel@tonic-gate driver_callback = ops_vector->cbo_umem_lock_cleanup; 85887c478bd9Sstevel@tonic-gate } 85897c478bd9Sstevel@tonic-gate if ((driver_callback == NULL) && (flags & DDI_UMEMLOCK_LONGTERM)) 85907c478bd9Sstevel@tonic-gate return (EINVAL); 85917c478bd9Sstevel@tonic-gate 85927c478bd9Sstevel@tonic-gate /* 85937c478bd9Sstevel@tonic-gate * Call i_ddi_umem_unlock_thread_start if necessary. It will 85947c478bd9Sstevel@tonic-gate * be called on first ddi_umem_lock or umem_lockmemory call. 85957c478bd9Sstevel@tonic-gate */ 85967c478bd9Sstevel@tonic-gate if (ddi_umem_unlock_thread == NULL) 85977c478bd9Sstevel@tonic-gate i_ddi_umem_unlock_thread_start(); 85987c478bd9Sstevel@tonic-gate 85997c478bd9Sstevel@tonic-gate /* Allocate memory for the cookie */ 86007c478bd9Sstevel@tonic-gate p = kmem_zalloc(sizeof (struct ddi_umem_cookie), KM_SLEEP); 86017c478bd9Sstevel@tonic-gate 86027c478bd9Sstevel@tonic-gate /* Convert the flags to seg_rw type */ 86037c478bd9Sstevel@tonic-gate if (flags & DDI_UMEMLOCK_WRITE) { 86047c478bd9Sstevel@tonic-gate p->s_flags = S_WRITE; 86057c478bd9Sstevel@tonic-gate } else { 86067c478bd9Sstevel@tonic-gate p->s_flags = S_READ; 86077c478bd9Sstevel@tonic-gate } 86087c478bd9Sstevel@tonic-gate 86097c478bd9Sstevel@tonic-gate /* Store procp in cookie for later iosetup/unlock */ 86107c478bd9Sstevel@tonic-gate p->procp = (void *)procp; 86117c478bd9Sstevel@tonic-gate 86127c478bd9Sstevel@tonic-gate /* 86137c478bd9Sstevel@tonic-gate * Store the struct as pointer in cookie for later use by 86147c478bd9Sstevel@tonic-gate * ddi_umem_unlock. The proc->p_as will be stale if ddi_umem_unlock 86157c478bd9Sstevel@tonic-gate * is called after relvm is called. 86167c478bd9Sstevel@tonic-gate */ 86177c478bd9Sstevel@tonic-gate p->asp = as; 86187c478bd9Sstevel@tonic-gate 86197c478bd9Sstevel@tonic-gate /* 86207c478bd9Sstevel@tonic-gate * The size field is needed for lockmem accounting. 86217c478bd9Sstevel@tonic-gate */ 86227c478bd9Sstevel@tonic-gate p->size = len; 86237c478bd9Sstevel@tonic-gate 86247c478bd9Sstevel@tonic-gate if (umem_incr_devlockmem(p) != 0) { 86257c478bd9Sstevel@tonic-gate /* 86267c478bd9Sstevel@tonic-gate * The requested memory cannot be locked 86277c478bd9Sstevel@tonic-gate */ 86287c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 86297c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)NULL; 86307c478bd9Sstevel@tonic-gate return (ENOMEM); 86317c478bd9Sstevel@tonic-gate } 86327c478bd9Sstevel@tonic-gate 86337c478bd9Sstevel@tonic-gate /* Lock the pages corresponding to addr, len in memory */ 86347c478bd9Sstevel@tonic-gate error = as_pagelock(as, &(p->pparray), addr, len, p->s_flags); 86357c478bd9Sstevel@tonic-gate if (error != 0) { 86367c478bd9Sstevel@tonic-gate umem_decr_devlockmem(p); 86377c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 86387c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)NULL; 86397c478bd9Sstevel@tonic-gate return (error); 86407c478bd9Sstevel@tonic-gate } 86417c478bd9Sstevel@tonic-gate 86427c478bd9Sstevel@tonic-gate /* 86437c478bd9Sstevel@tonic-gate * For longterm locking the addr must pertain to a seg_vn segment or 86447c478bd9Sstevel@tonic-gate * or a seg_spt segment. 86457c478bd9Sstevel@tonic-gate * If the segment pertains to a regular file, it cannot be 86467c478bd9Sstevel@tonic-gate * mapped MAP_SHARED. 86477c478bd9Sstevel@tonic-gate * This is to prevent a deadlock if a file truncation is attempted 86487c478bd9Sstevel@tonic-gate * after the locking is done. 86497c478bd9Sstevel@tonic-gate * Doing this after as_pagelock guarantees persistence of the as; if 86507c478bd9Sstevel@tonic-gate * an unacceptable segment is found, the cleanup includes calling 86517c478bd9Sstevel@tonic-gate * as_pageunlock before returning EFAULT. 8652d863b343SBill Taylor * 8653d863b343SBill Taylor * segdev is allowed here as it is already locked. This allows 8654d863b343SBill Taylor * for memory exported by drivers through mmap() (which is already 8655d863b343SBill Taylor * locked) to be allowed for LONGTERM. 86567c478bd9Sstevel@tonic-gate */ 86577c478bd9Sstevel@tonic-gate if (flags & DDI_UMEMLOCK_LONGTERM) { 86587c478bd9Sstevel@tonic-gate extern struct seg_ops segspt_shmops; 8659d863b343SBill Taylor extern struct seg_ops segdev_ops; 86607c478bd9Sstevel@tonic-gate AS_LOCK_ENTER(as, &as->a_lock, RW_READER); 86617c478bd9Sstevel@tonic-gate for (seg = as_segat(as, addr); ; seg = AS_SEGNEXT(as, seg)) { 86627c478bd9Sstevel@tonic-gate if (seg == NULL || seg->s_base > addr + len) 86637c478bd9Sstevel@tonic-gate break; 8664d863b343SBill Taylor if (seg->s_ops == &segdev_ops) 8665d863b343SBill Taylor continue; 86667c478bd9Sstevel@tonic-gate if (((seg->s_ops != &segvn_ops) && 86677c478bd9Sstevel@tonic-gate (seg->s_ops != &segspt_shmops)) || 86687c478bd9Sstevel@tonic-gate ((SEGOP_GETVP(seg, addr, &vp) == 0 && 86697c478bd9Sstevel@tonic-gate vp != NULL && vp->v_type == VREG) && 86707c478bd9Sstevel@tonic-gate (SEGOP_GETTYPE(seg, addr) & MAP_SHARED))) { 86717c478bd9Sstevel@tonic-gate as_pageunlock(as, p->pparray, 8672184cd04cScth addr, len, p->s_flags); 86737c478bd9Sstevel@tonic-gate AS_LOCK_EXIT(as, &as->a_lock); 86747c478bd9Sstevel@tonic-gate umem_decr_devlockmem(p); 86757c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 86767c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)NULL; 86777c478bd9Sstevel@tonic-gate return (EFAULT); 86787c478bd9Sstevel@tonic-gate } 86797c478bd9Sstevel@tonic-gate } 86807c478bd9Sstevel@tonic-gate AS_LOCK_EXIT(as, &as->a_lock); 86817c478bd9Sstevel@tonic-gate } 86827c478bd9Sstevel@tonic-gate 86837c478bd9Sstevel@tonic-gate 86847c478bd9Sstevel@tonic-gate /* Initialize the fields in the ddi_umem_cookie */ 86857c478bd9Sstevel@tonic-gate p->cvaddr = addr; 86867c478bd9Sstevel@tonic-gate p->type = UMEM_LOCKED; 86877c478bd9Sstevel@tonic-gate if (driver_callback != NULL) { 86887c478bd9Sstevel@tonic-gate /* i_ddi_umem_unlock and umem_lock_undo may need the cookie */ 86897c478bd9Sstevel@tonic-gate p->cook_refcnt = 2; 86907c478bd9Sstevel@tonic-gate p->callbacks = *ops_vector; 86917c478bd9Sstevel@tonic-gate } else { 86927c478bd9Sstevel@tonic-gate /* only i_ddi_umme_unlock needs the cookie */ 86937c478bd9Sstevel@tonic-gate p->cook_refcnt = 1; 86947c478bd9Sstevel@tonic-gate } 86957c478bd9Sstevel@tonic-gate 86967c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)p; 86977c478bd9Sstevel@tonic-gate 86987c478bd9Sstevel@tonic-gate /* 86997c478bd9Sstevel@tonic-gate * If a driver callback was specified, add an entry to the 87007c478bd9Sstevel@tonic-gate * as struct callback list. The as_pagelock above guarantees 87017c478bd9Sstevel@tonic-gate * the persistence of as. 87027c478bd9Sstevel@tonic-gate */ 87037c478bd9Sstevel@tonic-gate if (driver_callback) { 87047c478bd9Sstevel@tonic-gate error = as_add_callback(as, umem_lock_undo, p, AS_ALL_EVENT, 8705184cd04cScth addr, len, KM_SLEEP); 87067c478bd9Sstevel@tonic-gate if (error != 0) { 87077c478bd9Sstevel@tonic-gate as_pageunlock(as, p->pparray, 8708184cd04cScth addr, len, p->s_flags); 87097c478bd9Sstevel@tonic-gate umem_decr_devlockmem(p); 87107c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 87117c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)NULL; 87127c478bd9Sstevel@tonic-gate } 87137c478bd9Sstevel@tonic-gate } 87147c478bd9Sstevel@tonic-gate return (error); 87157c478bd9Sstevel@tonic-gate } 87167c478bd9Sstevel@tonic-gate 87177c478bd9Sstevel@tonic-gate /* 87187c478bd9Sstevel@tonic-gate * Unlock the pages locked by ddi_umem_lock or umem_lockmemory and free 87197c478bd9Sstevel@tonic-gate * the cookie. Called from i_ddi_umem_unlock_thread. 87207c478bd9Sstevel@tonic-gate */ 87217c478bd9Sstevel@tonic-gate 87227c478bd9Sstevel@tonic-gate static void 87237c478bd9Sstevel@tonic-gate i_ddi_umem_unlock(struct ddi_umem_cookie *p) 87247c478bd9Sstevel@tonic-gate { 87257c478bd9Sstevel@tonic-gate uint_t rc; 87267c478bd9Sstevel@tonic-gate 87277c478bd9Sstevel@tonic-gate /* 87287c478bd9Sstevel@tonic-gate * There is no way to determine whether a callback to 87297c478bd9Sstevel@tonic-gate * umem_lock_undo was registered via as_add_callback. 87307c478bd9Sstevel@tonic-gate * (i.e. umem_lockmemory was called with DDI_MEMLOCK_LONGTERM and 87317c478bd9Sstevel@tonic-gate * a valid callback function structure.) as_delete_callback 87327c478bd9Sstevel@tonic-gate * is called to delete a possible registered callback. If the 87337c478bd9Sstevel@tonic-gate * return from as_delete_callbacks is AS_CALLBACK_DELETED, it 87347c478bd9Sstevel@tonic-gate * indicates that there was a callback registered, and that is was 87357c478bd9Sstevel@tonic-gate * successfully deleted. Thus, the cookie reference count 87367c478bd9Sstevel@tonic-gate * will never be decremented by umem_lock_undo. Just return the 87377c478bd9Sstevel@tonic-gate * memory for the cookie, since both users of the cookie are done. 87387c478bd9Sstevel@tonic-gate * A return of AS_CALLBACK_NOTFOUND indicates a callback was 87397c478bd9Sstevel@tonic-gate * never registered. A return of AS_CALLBACK_DELETE_DEFERRED 87407c478bd9Sstevel@tonic-gate * indicates that callback processing is taking place and, and 87417c478bd9Sstevel@tonic-gate * umem_lock_undo is, or will be, executing, and thus decrementing 87427c478bd9Sstevel@tonic-gate * the cookie reference count when it is complete. 87437c478bd9Sstevel@tonic-gate * 87447c478bd9Sstevel@tonic-gate * This needs to be done before as_pageunlock so that the 87457c478bd9Sstevel@tonic-gate * persistence of as is guaranteed because of the locked pages. 87467c478bd9Sstevel@tonic-gate * 87477c478bd9Sstevel@tonic-gate */ 87487c478bd9Sstevel@tonic-gate rc = as_delete_callback(p->asp, p); 87497c478bd9Sstevel@tonic-gate 87507c478bd9Sstevel@tonic-gate 87517c478bd9Sstevel@tonic-gate /* 87527c478bd9Sstevel@tonic-gate * The proc->p_as will be stale if i_ddi_umem_unlock is called 87537c478bd9Sstevel@tonic-gate * after relvm is called so use p->asp. 87547c478bd9Sstevel@tonic-gate */ 87557c478bd9Sstevel@tonic-gate as_pageunlock(p->asp, p->pparray, p->cvaddr, p->size, p->s_flags); 87567c478bd9Sstevel@tonic-gate 87577c478bd9Sstevel@tonic-gate /* 87587c478bd9Sstevel@tonic-gate * Now that we have unlocked the memory decrement the 8759c6939658Ssl * *.max-locked-memory rctl 87607c478bd9Sstevel@tonic-gate */ 87617c478bd9Sstevel@tonic-gate umem_decr_devlockmem(p); 87627c478bd9Sstevel@tonic-gate 87637c478bd9Sstevel@tonic-gate if (rc == AS_CALLBACK_DELETED) { 87647c478bd9Sstevel@tonic-gate /* umem_lock_undo will not happen, return the cookie memory */ 87657c478bd9Sstevel@tonic-gate ASSERT(p->cook_refcnt == 2); 87667c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 87677c478bd9Sstevel@tonic-gate } else { 87687c478bd9Sstevel@tonic-gate /* 87697c478bd9Sstevel@tonic-gate * umem_undo_lock may happen if as_delete_callback returned 87707c478bd9Sstevel@tonic-gate * AS_CALLBACK_DELETE_DEFERRED. In that case, decrement the 87717c478bd9Sstevel@tonic-gate * reference count, atomically, and return the cookie 87727c478bd9Sstevel@tonic-gate * memory if the reference count goes to zero. The only 87737c478bd9Sstevel@tonic-gate * other value for rc is AS_CALLBACK_NOTFOUND. In that 87747c478bd9Sstevel@tonic-gate * case, just return the cookie memory. 87757c478bd9Sstevel@tonic-gate */ 87767c478bd9Sstevel@tonic-gate if ((rc != AS_CALLBACK_DELETE_DEFERRED) || 87777c478bd9Sstevel@tonic-gate (atomic_add_long_nv((ulong_t *)(&(p->cook_refcnt)), -1) 87787c478bd9Sstevel@tonic-gate == 0)) { 87797c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 87807c478bd9Sstevel@tonic-gate } 87817c478bd9Sstevel@tonic-gate } 87827c478bd9Sstevel@tonic-gate } 87837c478bd9Sstevel@tonic-gate 87847c478bd9Sstevel@tonic-gate /* 87857c478bd9Sstevel@tonic-gate * i_ddi_umem_unlock_thread - deferred ddi_umem_unlock list handler. 87867c478bd9Sstevel@tonic-gate * 87877c478bd9Sstevel@tonic-gate * Call i_ddi_umem_unlock for entries in the ddi_umem_unlock list 87887c478bd9Sstevel@tonic-gate * until it is empty. Then, wait for more to be added. This thread is awoken 87897c478bd9Sstevel@tonic-gate * via calls to ddi_umem_unlock. 87907c478bd9Sstevel@tonic-gate */ 87917c478bd9Sstevel@tonic-gate 87927c478bd9Sstevel@tonic-gate static void 87937c478bd9Sstevel@tonic-gate i_ddi_umem_unlock_thread(void) 87947c478bd9Sstevel@tonic-gate { 87957c478bd9Sstevel@tonic-gate struct ddi_umem_cookie *ret_cookie; 87967c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 87977c478bd9Sstevel@tonic-gate 87987c478bd9Sstevel@tonic-gate /* process the ddi_umem_unlock list */ 87997c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &ddi_umem_unlock_mutex, 88007c478bd9Sstevel@tonic-gate callb_generic_cpr, "unlock_thread"); 88017c478bd9Sstevel@tonic-gate for (;;) { 88027c478bd9Sstevel@tonic-gate mutex_enter(&ddi_umem_unlock_mutex); 88037c478bd9Sstevel@tonic-gate if (ddi_umem_unlock_head != NULL) { /* list not empty */ 88047c478bd9Sstevel@tonic-gate ret_cookie = ddi_umem_unlock_head; 88057c478bd9Sstevel@tonic-gate /* take if off the list */ 88067c478bd9Sstevel@tonic-gate if ((ddi_umem_unlock_head = 88077c478bd9Sstevel@tonic-gate ddi_umem_unlock_head->unl_forw) == NULL) { 88087c478bd9Sstevel@tonic-gate ddi_umem_unlock_tail = NULL; 88097c478bd9Sstevel@tonic-gate } 88107c478bd9Sstevel@tonic-gate mutex_exit(&ddi_umem_unlock_mutex); 88117c478bd9Sstevel@tonic-gate /* unlock the pages in this cookie */ 88127c478bd9Sstevel@tonic-gate (void) i_ddi_umem_unlock(ret_cookie); 88137c478bd9Sstevel@tonic-gate } else { /* list is empty, wait for next ddi_umem_unlock */ 88147c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 88157c478bd9Sstevel@tonic-gate cv_wait(&ddi_umem_unlock_cv, &ddi_umem_unlock_mutex); 88167c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &ddi_umem_unlock_mutex); 88177c478bd9Sstevel@tonic-gate mutex_exit(&ddi_umem_unlock_mutex); 88187c478bd9Sstevel@tonic-gate } 88197c478bd9Sstevel@tonic-gate } 88207c478bd9Sstevel@tonic-gate /* ddi_umem_unlock_thread does not exit */ 88217c478bd9Sstevel@tonic-gate /* NOTREACHED */ 88227c478bd9Sstevel@tonic-gate } 88237c478bd9Sstevel@tonic-gate 88247c478bd9Sstevel@tonic-gate /* 88257c478bd9Sstevel@tonic-gate * Start the thread that will process the ddi_umem_unlock list if it is 88267c478bd9Sstevel@tonic-gate * not already started (i_ddi_umem_unlock_thread). 88277c478bd9Sstevel@tonic-gate */ 88287c478bd9Sstevel@tonic-gate static void 88297c478bd9Sstevel@tonic-gate i_ddi_umem_unlock_thread_start(void) 88307c478bd9Sstevel@tonic-gate { 88317c478bd9Sstevel@tonic-gate mutex_enter(&ddi_umem_unlock_mutex); 88327c478bd9Sstevel@tonic-gate if (ddi_umem_unlock_thread == NULL) { 88337c478bd9Sstevel@tonic-gate ddi_umem_unlock_thread = thread_create(NULL, 0, 88347c478bd9Sstevel@tonic-gate i_ddi_umem_unlock_thread, NULL, 0, &p0, 88357c478bd9Sstevel@tonic-gate TS_RUN, minclsyspri); 88367c478bd9Sstevel@tonic-gate } 88377c478bd9Sstevel@tonic-gate mutex_exit(&ddi_umem_unlock_mutex); 88387c478bd9Sstevel@tonic-gate } 88397c478bd9Sstevel@tonic-gate 88407c478bd9Sstevel@tonic-gate /* 88417c478bd9Sstevel@tonic-gate * Lock the virtual address range in the current process and create a 88427c478bd9Sstevel@tonic-gate * ddi_umem_cookie (of type UMEM_LOCKED). This can be used to pass to 88437c478bd9Sstevel@tonic-gate * ddi_umem_iosetup to create a buf or do devmap_umem_setup/remap to export 88447c478bd9Sstevel@tonic-gate * to user space. 88457c478bd9Sstevel@tonic-gate * 88467c478bd9Sstevel@tonic-gate * Note: The resource control accounting currently uses a full charge model 88477c478bd9Sstevel@tonic-gate * in other words attempts to lock the same/overlapping areas of memory 88487c478bd9Sstevel@tonic-gate * will deduct the full size of the buffer from the projects running 88497c478bd9Sstevel@tonic-gate * counter for the device locked memory. This applies to umem_lockmemory too. 88507c478bd9Sstevel@tonic-gate * 88517c478bd9Sstevel@tonic-gate * addr, size should be PAGESIZE aligned 88527c478bd9Sstevel@tonic-gate * flags - DDI_UMEMLOCK_READ, DDI_UMEMLOCK_WRITE or both 88537c478bd9Sstevel@tonic-gate * identifies whether the locked memory will be read or written or both 88547c478bd9Sstevel@tonic-gate * 88557c478bd9Sstevel@tonic-gate * Returns 0 on success 88567c478bd9Sstevel@tonic-gate * EINVAL - for invalid parameters 88577c478bd9Sstevel@tonic-gate * EPERM, ENOMEM and other error codes returned by as_pagelock 88587c478bd9Sstevel@tonic-gate * ENOMEM - is returned if the current request to lock memory exceeds 8859c6939658Ssl * *.max-locked-memory resource control value. 88607c478bd9Sstevel@tonic-gate * EAGAIN - could not start the ddi_umem_unlock list processing thread 88617c478bd9Sstevel@tonic-gate */ 88627c478bd9Sstevel@tonic-gate int 88637c478bd9Sstevel@tonic-gate ddi_umem_lock(caddr_t addr, size_t len, int flags, ddi_umem_cookie_t *cookie) 88647c478bd9Sstevel@tonic-gate { 88657c478bd9Sstevel@tonic-gate int error; 88667c478bd9Sstevel@tonic-gate struct ddi_umem_cookie *p; 88677c478bd9Sstevel@tonic-gate 88687c478bd9Sstevel@tonic-gate *cookie = NULL; /* in case of any error return */ 88697c478bd9Sstevel@tonic-gate 88707c478bd9Sstevel@tonic-gate /* These are the only two valid flags */ 88717c478bd9Sstevel@tonic-gate if ((flags & ~(DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE)) != 0) { 88727c478bd9Sstevel@tonic-gate return (EINVAL); 88737c478bd9Sstevel@tonic-gate } 88747c478bd9Sstevel@tonic-gate 88757c478bd9Sstevel@tonic-gate /* At least one of the two flags (or both) must be set */ 88767c478bd9Sstevel@tonic-gate if ((flags & (DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE)) == 0) { 88777c478bd9Sstevel@tonic-gate return (EINVAL); 88787c478bd9Sstevel@tonic-gate } 88797c478bd9Sstevel@tonic-gate 88807c478bd9Sstevel@tonic-gate /* addr and len must be page-aligned */ 88817c478bd9Sstevel@tonic-gate if (((uintptr_t)addr & PAGEOFFSET) != 0) { 88827c478bd9Sstevel@tonic-gate return (EINVAL); 88837c478bd9Sstevel@tonic-gate } 88847c478bd9Sstevel@tonic-gate 88857c478bd9Sstevel@tonic-gate if ((len & PAGEOFFSET) != 0) { 88867c478bd9Sstevel@tonic-gate return (EINVAL); 88877c478bd9Sstevel@tonic-gate } 88887c478bd9Sstevel@tonic-gate 88897c478bd9Sstevel@tonic-gate /* 88907c478bd9Sstevel@tonic-gate * Call i_ddi_umem_unlock_thread_start if necessary. It will 88917c478bd9Sstevel@tonic-gate * be called on first ddi_umem_lock or umem_lockmemory call. 88927c478bd9Sstevel@tonic-gate */ 88937c478bd9Sstevel@tonic-gate if (ddi_umem_unlock_thread == NULL) 88947c478bd9Sstevel@tonic-gate i_ddi_umem_unlock_thread_start(); 88957c478bd9Sstevel@tonic-gate 88967c478bd9Sstevel@tonic-gate /* Allocate memory for the cookie */ 88977c478bd9Sstevel@tonic-gate p = kmem_zalloc(sizeof (struct ddi_umem_cookie), KM_SLEEP); 88987c478bd9Sstevel@tonic-gate 88997c478bd9Sstevel@tonic-gate /* Convert the flags to seg_rw type */ 89007c478bd9Sstevel@tonic-gate if (flags & DDI_UMEMLOCK_WRITE) { 89017c478bd9Sstevel@tonic-gate p->s_flags = S_WRITE; 89027c478bd9Sstevel@tonic-gate } else { 89037c478bd9Sstevel@tonic-gate p->s_flags = S_READ; 89047c478bd9Sstevel@tonic-gate } 89057c478bd9Sstevel@tonic-gate 89067c478bd9Sstevel@tonic-gate /* Store curproc in cookie for later iosetup/unlock */ 89077c478bd9Sstevel@tonic-gate p->procp = (void *)curproc; 89087c478bd9Sstevel@tonic-gate 89097c478bd9Sstevel@tonic-gate /* 89107c478bd9Sstevel@tonic-gate * Store the struct as pointer in cookie for later use by 89117c478bd9Sstevel@tonic-gate * ddi_umem_unlock. The proc->p_as will be stale if ddi_umem_unlock 89127c478bd9Sstevel@tonic-gate * is called after relvm is called. 89137c478bd9Sstevel@tonic-gate */ 89147c478bd9Sstevel@tonic-gate p->asp = curproc->p_as; 89157c478bd9Sstevel@tonic-gate /* 89167c478bd9Sstevel@tonic-gate * The size field is needed for lockmem accounting. 89177c478bd9Sstevel@tonic-gate */ 89187c478bd9Sstevel@tonic-gate p->size = len; 89197c478bd9Sstevel@tonic-gate 89207c478bd9Sstevel@tonic-gate if (umem_incr_devlockmem(p) != 0) { 89217c478bd9Sstevel@tonic-gate /* 89227c478bd9Sstevel@tonic-gate * The requested memory cannot be locked 89237c478bd9Sstevel@tonic-gate */ 89247c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 89257c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)NULL; 89267c478bd9Sstevel@tonic-gate return (ENOMEM); 89277c478bd9Sstevel@tonic-gate } 89287c478bd9Sstevel@tonic-gate 89297c478bd9Sstevel@tonic-gate /* Lock the pages corresponding to addr, len in memory */ 89307c478bd9Sstevel@tonic-gate error = as_pagelock(((proc_t *)p->procp)->p_as, &(p->pparray), 89317c478bd9Sstevel@tonic-gate addr, len, p->s_flags); 89327c478bd9Sstevel@tonic-gate if (error != 0) { 89337c478bd9Sstevel@tonic-gate umem_decr_devlockmem(p); 89347c478bd9Sstevel@tonic-gate kmem_free(p, sizeof (struct ddi_umem_cookie)); 89357c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)NULL; 89367c478bd9Sstevel@tonic-gate return (error); 89377c478bd9Sstevel@tonic-gate } 89387c478bd9Sstevel@tonic-gate 89397c478bd9Sstevel@tonic-gate /* Initialize the fields in the ddi_umem_cookie */ 89407c478bd9Sstevel@tonic-gate p->cvaddr = addr; 89417c478bd9Sstevel@tonic-gate p->type = UMEM_LOCKED; 89427c478bd9Sstevel@tonic-gate p->cook_refcnt = 1; 89437c478bd9Sstevel@tonic-gate 89447c478bd9Sstevel@tonic-gate *cookie = (ddi_umem_cookie_t)p; 89457c478bd9Sstevel@tonic-gate return (error); 89467c478bd9Sstevel@tonic-gate } 89477c478bd9Sstevel@tonic-gate 89487c478bd9Sstevel@tonic-gate /* 89497c478bd9Sstevel@tonic-gate * Add the cookie to the ddi_umem_unlock list. Pages will be 89507c478bd9Sstevel@tonic-gate * unlocked by i_ddi_umem_unlock_thread. 89517c478bd9Sstevel@tonic-gate */ 89527c478bd9Sstevel@tonic-gate 89537c478bd9Sstevel@tonic-gate void 89547c478bd9Sstevel@tonic-gate ddi_umem_unlock(ddi_umem_cookie_t cookie) 89557c478bd9Sstevel@tonic-gate { 89567c478bd9Sstevel@tonic-gate struct ddi_umem_cookie *p = (struct ddi_umem_cookie *)cookie; 89577c478bd9Sstevel@tonic-gate 89587c478bd9Sstevel@tonic-gate ASSERT(p->type == UMEM_LOCKED); 89597c478bd9Sstevel@tonic-gate ASSERT(CPU_ON_INTR(CPU) == 0); /* cannot be high level */ 89607c478bd9Sstevel@tonic-gate ASSERT(ddi_umem_unlock_thread != NULL); 89617c478bd9Sstevel@tonic-gate 89627c478bd9Sstevel@tonic-gate p->unl_forw = (struct ddi_umem_cookie *)NULL; /* end of list */ 89639bbaf432Seota /* 89649bbaf432Seota * Queue the unlock request and notify i_ddi_umem_unlock thread 89659bbaf432Seota * if it's called in the interrupt context. Otherwise, unlock pages 89669bbaf432Seota * immediately. 89679bbaf432Seota */ 89689bbaf432Seota if (servicing_interrupt()) { 89699bbaf432Seota /* queue the unlock request and notify the thread */ 89709bbaf432Seota mutex_enter(&ddi_umem_unlock_mutex); 89719bbaf432Seota if (ddi_umem_unlock_head == NULL) { 89729bbaf432Seota ddi_umem_unlock_head = ddi_umem_unlock_tail = p; 89739bbaf432Seota cv_broadcast(&ddi_umem_unlock_cv); 89749bbaf432Seota } else { 89759bbaf432Seota ddi_umem_unlock_tail->unl_forw = p; 89769bbaf432Seota ddi_umem_unlock_tail = p; 89779bbaf432Seota } 89789bbaf432Seota mutex_exit(&ddi_umem_unlock_mutex); 89797c478bd9Sstevel@tonic-gate } else { 89809bbaf432Seota /* unlock the pages right away */ 89819bbaf432Seota (void) i_ddi_umem_unlock(p); 89827c478bd9Sstevel@tonic-gate } 89837c478bd9Sstevel@tonic-gate } 89847c478bd9Sstevel@tonic-gate 89857c478bd9Sstevel@tonic-gate /* 89867c478bd9Sstevel@tonic-gate * Create a buf structure from a ddi_umem_cookie 89877c478bd9Sstevel@tonic-gate * cookie - is a ddi_umem_cookie for from ddi_umem_lock and ddi_umem_alloc 89887c478bd9Sstevel@tonic-gate * (only UMEM_LOCKED & KMEM_NON_PAGEABLE types supported) 89897c478bd9Sstevel@tonic-gate * off, len - identifies the portion of the memory represented by the cookie 89907c478bd9Sstevel@tonic-gate * that the buf points to. 89917c478bd9Sstevel@tonic-gate * NOTE: off, len need to follow the alignment/size restrictions of the 89927c478bd9Sstevel@tonic-gate * device (dev) that this buf will be passed to. Some devices 89937c478bd9Sstevel@tonic-gate * will accept unrestricted alignment/size, whereas others (such as 89947c478bd9Sstevel@tonic-gate * st) require some block-size alignment/size. It is the caller's 89957c478bd9Sstevel@tonic-gate * responsibility to ensure that the alignment/size restrictions 89967c478bd9Sstevel@tonic-gate * are met (we cannot assert as we do not know the restrictions) 89977c478bd9Sstevel@tonic-gate * 89987c478bd9Sstevel@tonic-gate * direction - is one of B_READ or B_WRITE and needs to be compatible with 89997c478bd9Sstevel@tonic-gate * the flags used in ddi_umem_lock 90007c478bd9Sstevel@tonic-gate * 90017c478bd9Sstevel@tonic-gate * The following three arguments are used to initialize fields in the 90027c478bd9Sstevel@tonic-gate * buf structure and are uninterpreted by this routine. 90037c478bd9Sstevel@tonic-gate * 90047c478bd9Sstevel@tonic-gate * dev 90057c478bd9Sstevel@tonic-gate * blkno 90067c478bd9Sstevel@tonic-gate * iodone 90077c478bd9Sstevel@tonic-gate * 90087c478bd9Sstevel@tonic-gate * sleepflag - is one of DDI_UMEM_SLEEP or DDI_UMEM_NOSLEEP 90097c478bd9Sstevel@tonic-gate * 90107c478bd9Sstevel@tonic-gate * Returns a buf structure pointer on success (to be freed by freerbuf) 90117c478bd9Sstevel@tonic-gate * NULL on any parameter error or memory alloc failure 90127c478bd9Sstevel@tonic-gate * 90137c478bd9Sstevel@tonic-gate */ 90147c478bd9Sstevel@tonic-gate struct buf * 90157c478bd9Sstevel@tonic-gate ddi_umem_iosetup(ddi_umem_cookie_t cookie, off_t off, size_t len, 90167c478bd9Sstevel@tonic-gate int direction, dev_t dev, daddr_t blkno, 90177c478bd9Sstevel@tonic-gate int (*iodone)(struct buf *), int sleepflag) 90187c478bd9Sstevel@tonic-gate { 90197c478bd9Sstevel@tonic-gate struct ddi_umem_cookie *p = (struct ddi_umem_cookie *)cookie; 90207c478bd9Sstevel@tonic-gate struct buf *bp; 90217c478bd9Sstevel@tonic-gate 90227c478bd9Sstevel@tonic-gate /* 90237c478bd9Sstevel@tonic-gate * check for valid cookie offset, len 90247c478bd9Sstevel@tonic-gate */ 90257c478bd9Sstevel@tonic-gate if ((off + len) > p->size) { 90267c478bd9Sstevel@tonic-gate return (NULL); 90277c478bd9Sstevel@tonic-gate } 90287c478bd9Sstevel@tonic-gate 90297c478bd9Sstevel@tonic-gate if (len > p->size) { 90307c478bd9Sstevel@tonic-gate return (NULL); 90317c478bd9Sstevel@tonic-gate } 90327c478bd9Sstevel@tonic-gate 90337c478bd9Sstevel@tonic-gate /* direction has to be one of B_READ or B_WRITE */ 90347c478bd9Sstevel@tonic-gate if ((direction != B_READ) && (direction != B_WRITE)) { 90357c478bd9Sstevel@tonic-gate return (NULL); 90367c478bd9Sstevel@tonic-gate } 90377c478bd9Sstevel@tonic-gate 90387c478bd9Sstevel@tonic-gate /* These are the only two valid sleepflags */ 90397c478bd9Sstevel@tonic-gate if ((sleepflag != DDI_UMEM_SLEEP) && (sleepflag != DDI_UMEM_NOSLEEP)) { 90407c478bd9Sstevel@tonic-gate return (NULL); 90417c478bd9Sstevel@tonic-gate } 90427c478bd9Sstevel@tonic-gate 90437c478bd9Sstevel@tonic-gate /* 90447c478bd9Sstevel@tonic-gate * Only cookies of type UMEM_LOCKED and KMEM_NON_PAGEABLE are supported 90457c478bd9Sstevel@tonic-gate */ 90467c478bd9Sstevel@tonic-gate if ((p->type != UMEM_LOCKED) && (p->type != KMEM_NON_PAGEABLE)) { 90477c478bd9Sstevel@tonic-gate return (NULL); 90487c478bd9Sstevel@tonic-gate } 90497c478bd9Sstevel@tonic-gate 90507c478bd9Sstevel@tonic-gate /* If type is KMEM_NON_PAGEABLE procp is NULL */ 90517c478bd9Sstevel@tonic-gate ASSERT((p->type == KMEM_NON_PAGEABLE) ? 9052184cd04cScth (p->procp == NULL) : (p->procp != NULL)); 90537c478bd9Sstevel@tonic-gate 90547c478bd9Sstevel@tonic-gate bp = kmem_alloc(sizeof (struct buf), sleepflag); 90557c478bd9Sstevel@tonic-gate if (bp == NULL) { 90567c478bd9Sstevel@tonic-gate return (NULL); 90577c478bd9Sstevel@tonic-gate } 90587c478bd9Sstevel@tonic-gate bioinit(bp); 90597c478bd9Sstevel@tonic-gate 90607c478bd9Sstevel@tonic-gate bp->b_flags = B_BUSY | B_PHYS | direction; 90617c478bd9Sstevel@tonic-gate bp->b_edev = dev; 90627c478bd9Sstevel@tonic-gate bp->b_lblkno = blkno; 90637c478bd9Sstevel@tonic-gate bp->b_iodone = iodone; 90647c478bd9Sstevel@tonic-gate bp->b_bcount = len; 90657c478bd9Sstevel@tonic-gate bp->b_proc = (proc_t *)p->procp; 90667c478bd9Sstevel@tonic-gate ASSERT(((uintptr_t)(p->cvaddr) & PAGEOFFSET) == 0); 90677c478bd9Sstevel@tonic-gate bp->b_un.b_addr = (caddr_t)((uintptr_t)(p->cvaddr) + off); 90687c478bd9Sstevel@tonic-gate if (p->pparray != NULL) { 90697c478bd9Sstevel@tonic-gate bp->b_flags |= B_SHADOW; 90707c478bd9Sstevel@tonic-gate ASSERT(((uintptr_t)(p->cvaddr) & PAGEOFFSET) == 0); 90717c478bd9Sstevel@tonic-gate bp->b_shadow = p->pparray + btop(off); 90727c478bd9Sstevel@tonic-gate } 90737c478bd9Sstevel@tonic-gate return (bp); 90747c478bd9Sstevel@tonic-gate } 90757c478bd9Sstevel@tonic-gate 90767c478bd9Sstevel@tonic-gate /* 90777c478bd9Sstevel@tonic-gate * Fault-handling and related routines 90787c478bd9Sstevel@tonic-gate */ 90797c478bd9Sstevel@tonic-gate 90807c478bd9Sstevel@tonic-gate ddi_devstate_t 90817c478bd9Sstevel@tonic-gate ddi_get_devstate(dev_info_t *dip) 90827c478bd9Sstevel@tonic-gate { 90837c478bd9Sstevel@tonic-gate if (DEVI_IS_DEVICE_OFFLINE(dip)) 90847c478bd9Sstevel@tonic-gate return (DDI_DEVSTATE_OFFLINE); 90857c478bd9Sstevel@tonic-gate else if (DEVI_IS_DEVICE_DOWN(dip) || DEVI_IS_BUS_DOWN(dip)) 90867c478bd9Sstevel@tonic-gate return (DDI_DEVSTATE_DOWN); 90877c478bd9Sstevel@tonic-gate else if (DEVI_IS_BUS_QUIESCED(dip)) 90887c478bd9Sstevel@tonic-gate return (DDI_DEVSTATE_QUIESCED); 90897c478bd9Sstevel@tonic-gate else if (DEVI_IS_DEVICE_DEGRADED(dip)) 90907c478bd9Sstevel@tonic-gate return (DDI_DEVSTATE_DEGRADED); 90917c478bd9Sstevel@tonic-gate else 90927c478bd9Sstevel@tonic-gate return (DDI_DEVSTATE_UP); 90937c478bd9Sstevel@tonic-gate } 90947c478bd9Sstevel@tonic-gate 90957c478bd9Sstevel@tonic-gate void 90967c478bd9Sstevel@tonic-gate ddi_dev_report_fault(dev_info_t *dip, ddi_fault_impact_t impact, 90977c478bd9Sstevel@tonic-gate ddi_fault_location_t location, const char *message) 90987c478bd9Sstevel@tonic-gate { 90997c478bd9Sstevel@tonic-gate struct ddi_fault_event_data fd; 91007c478bd9Sstevel@tonic-gate ddi_eventcookie_t ec; 91017c478bd9Sstevel@tonic-gate 91027c478bd9Sstevel@tonic-gate /* 91037c478bd9Sstevel@tonic-gate * Assemble all the information into a fault-event-data structure 91047c478bd9Sstevel@tonic-gate */ 91057c478bd9Sstevel@tonic-gate fd.f_dip = dip; 91067c478bd9Sstevel@tonic-gate fd.f_impact = impact; 91077c478bd9Sstevel@tonic-gate fd.f_location = location; 91087c478bd9Sstevel@tonic-gate fd.f_message = message; 91097c478bd9Sstevel@tonic-gate fd.f_oldstate = ddi_get_devstate(dip); 91107c478bd9Sstevel@tonic-gate 91117c478bd9Sstevel@tonic-gate /* 91127c478bd9Sstevel@tonic-gate * Get eventcookie from defining parent. 91137c478bd9Sstevel@tonic-gate */ 91147c478bd9Sstevel@tonic-gate if (ddi_get_eventcookie(dip, DDI_DEVI_FAULT_EVENT, &ec) != 91157c478bd9Sstevel@tonic-gate DDI_SUCCESS) 91167c478bd9Sstevel@tonic-gate return; 91177c478bd9Sstevel@tonic-gate 91187c478bd9Sstevel@tonic-gate (void) ndi_post_event(dip, dip, ec, &fd); 91197c478bd9Sstevel@tonic-gate } 91207c478bd9Sstevel@tonic-gate 91217c478bd9Sstevel@tonic-gate char * 91227c478bd9Sstevel@tonic-gate i_ddi_devi_class(dev_info_t *dip) 91237c478bd9Sstevel@tonic-gate { 91247c478bd9Sstevel@tonic-gate return (DEVI(dip)->devi_device_class); 91257c478bd9Sstevel@tonic-gate } 91267c478bd9Sstevel@tonic-gate 91277c478bd9Sstevel@tonic-gate int 91287c478bd9Sstevel@tonic-gate i_ddi_set_devi_class(dev_info_t *dip, char *devi_class, int flag) 91297c478bd9Sstevel@tonic-gate { 91307c478bd9Sstevel@tonic-gate struct dev_info *devi = DEVI(dip); 91317c478bd9Sstevel@tonic-gate 91327c478bd9Sstevel@tonic-gate mutex_enter(&devi->devi_lock); 91337c478bd9Sstevel@tonic-gate 91347c478bd9Sstevel@tonic-gate if (devi->devi_device_class) 91357c478bd9Sstevel@tonic-gate kmem_free(devi->devi_device_class, 91367c478bd9Sstevel@tonic-gate strlen(devi->devi_device_class) + 1); 91377c478bd9Sstevel@tonic-gate 91387c478bd9Sstevel@tonic-gate if ((devi->devi_device_class = i_ddi_strdup(devi_class, flag)) 91397c478bd9Sstevel@tonic-gate != NULL) { 91407c478bd9Sstevel@tonic-gate mutex_exit(&devi->devi_lock); 91417c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 91427c478bd9Sstevel@tonic-gate } 91437c478bd9Sstevel@tonic-gate 91447c478bd9Sstevel@tonic-gate mutex_exit(&devi->devi_lock); 91457c478bd9Sstevel@tonic-gate 91467c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 91477c478bd9Sstevel@tonic-gate } 91487c478bd9Sstevel@tonic-gate 91497c478bd9Sstevel@tonic-gate 91507c478bd9Sstevel@tonic-gate /* 91517c478bd9Sstevel@tonic-gate * Task Queues DDI interfaces. 91527c478bd9Sstevel@tonic-gate */ 91537c478bd9Sstevel@tonic-gate 91547c478bd9Sstevel@tonic-gate /* ARGSUSED */ 91557c478bd9Sstevel@tonic-gate ddi_taskq_t * 91567c478bd9Sstevel@tonic-gate ddi_taskq_create(dev_info_t *dip, const char *name, int nthreads, 91577c478bd9Sstevel@tonic-gate pri_t pri, uint_t cflags) 91587c478bd9Sstevel@tonic-gate { 91597c478bd9Sstevel@tonic-gate char full_name[TASKQ_NAMELEN]; 91607c478bd9Sstevel@tonic-gate const char *tq_name; 91617c478bd9Sstevel@tonic-gate int nodeid = 0; 91627c478bd9Sstevel@tonic-gate 91637c478bd9Sstevel@tonic-gate if (dip == NULL) 91647c478bd9Sstevel@tonic-gate tq_name = name; 91657c478bd9Sstevel@tonic-gate else { 91667c478bd9Sstevel@tonic-gate nodeid = ddi_get_instance(dip); 91677c478bd9Sstevel@tonic-gate 91687c478bd9Sstevel@tonic-gate if (name == NULL) 91697c478bd9Sstevel@tonic-gate name = "tq"; 91707c478bd9Sstevel@tonic-gate 91717c478bd9Sstevel@tonic-gate (void) snprintf(full_name, sizeof (full_name), "%s_%s", 91727c478bd9Sstevel@tonic-gate ddi_driver_name(dip), name); 91737c478bd9Sstevel@tonic-gate 91747c478bd9Sstevel@tonic-gate tq_name = full_name; 91757c478bd9Sstevel@tonic-gate } 91767c478bd9Sstevel@tonic-gate 91777c478bd9Sstevel@tonic-gate return ((ddi_taskq_t *)taskq_create_instance(tq_name, nodeid, nthreads, 9178184cd04cScth pri == TASKQ_DEFAULTPRI ? minclsyspri : pri, 9179184cd04cScth nthreads, INT_MAX, TASKQ_PREPOPULATE)); 91807c478bd9Sstevel@tonic-gate } 91817c478bd9Sstevel@tonic-gate 91827c478bd9Sstevel@tonic-gate void 91837c478bd9Sstevel@tonic-gate ddi_taskq_destroy(ddi_taskq_t *tq) 91847c478bd9Sstevel@tonic-gate { 91857c478bd9Sstevel@tonic-gate taskq_destroy((taskq_t *)tq); 91867c478bd9Sstevel@tonic-gate } 91877c478bd9Sstevel@tonic-gate 91887c478bd9Sstevel@tonic-gate int 91897c478bd9Sstevel@tonic-gate ddi_taskq_dispatch(ddi_taskq_t *tq, void (* func)(void *), 91907c478bd9Sstevel@tonic-gate void *arg, uint_t dflags) 91917c478bd9Sstevel@tonic-gate { 91927c478bd9Sstevel@tonic-gate taskqid_t id = taskq_dispatch((taskq_t *)tq, func, arg, 91937c478bd9Sstevel@tonic-gate dflags == DDI_SLEEP ? TQ_SLEEP : TQ_NOSLEEP); 91947c478bd9Sstevel@tonic-gate 91957c478bd9Sstevel@tonic-gate return (id != 0 ? DDI_SUCCESS : DDI_FAILURE); 91967c478bd9Sstevel@tonic-gate } 91977c478bd9Sstevel@tonic-gate 91987c478bd9Sstevel@tonic-gate void 91997c478bd9Sstevel@tonic-gate ddi_taskq_wait(ddi_taskq_t *tq) 92007c478bd9Sstevel@tonic-gate { 92017c478bd9Sstevel@tonic-gate taskq_wait((taskq_t *)tq); 92027c478bd9Sstevel@tonic-gate } 92037c478bd9Sstevel@tonic-gate 92047c478bd9Sstevel@tonic-gate void 92057c478bd9Sstevel@tonic-gate ddi_taskq_suspend(ddi_taskq_t *tq) 92067c478bd9Sstevel@tonic-gate { 92077c478bd9Sstevel@tonic-gate taskq_suspend((taskq_t *)tq); 92087c478bd9Sstevel@tonic-gate } 92097c478bd9Sstevel@tonic-gate 92107c478bd9Sstevel@tonic-gate boolean_t 92117c478bd9Sstevel@tonic-gate ddi_taskq_suspended(ddi_taskq_t *tq) 92127c478bd9Sstevel@tonic-gate { 92137c478bd9Sstevel@tonic-gate return (taskq_suspended((taskq_t *)tq)); 92147c478bd9Sstevel@tonic-gate } 92157c478bd9Sstevel@tonic-gate 92167c478bd9Sstevel@tonic-gate void 92177c478bd9Sstevel@tonic-gate ddi_taskq_resume(ddi_taskq_t *tq) 92187c478bd9Sstevel@tonic-gate { 92197c478bd9Sstevel@tonic-gate taskq_resume((taskq_t *)tq); 92207c478bd9Sstevel@tonic-gate } 92217c478bd9Sstevel@tonic-gate 92227c478bd9Sstevel@tonic-gate int 92237c478bd9Sstevel@tonic-gate ddi_parse( 92247c478bd9Sstevel@tonic-gate const char *ifname, 92257c478bd9Sstevel@tonic-gate char *alnum, 92267c478bd9Sstevel@tonic-gate uint_t *nump) 92277c478bd9Sstevel@tonic-gate { 92287c478bd9Sstevel@tonic-gate const char *p; 92297c478bd9Sstevel@tonic-gate int l; 92307c478bd9Sstevel@tonic-gate ulong_t num; 92317c478bd9Sstevel@tonic-gate boolean_t nonum = B_TRUE; 92327c478bd9Sstevel@tonic-gate char c; 92337c478bd9Sstevel@tonic-gate 92347c478bd9Sstevel@tonic-gate l = strlen(ifname); 92357c478bd9Sstevel@tonic-gate for (p = ifname + l; p != ifname; l--) { 92367c478bd9Sstevel@tonic-gate c = *--p; 92377c478bd9Sstevel@tonic-gate if (!isdigit(c)) { 92387c478bd9Sstevel@tonic-gate (void) strlcpy(alnum, ifname, l + 1); 92397c478bd9Sstevel@tonic-gate if (ddi_strtoul(p + 1, NULL, 10, &num) != 0) 92407c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 92417c478bd9Sstevel@tonic-gate break; 92427c478bd9Sstevel@tonic-gate } 92437c478bd9Sstevel@tonic-gate nonum = B_FALSE; 92447c478bd9Sstevel@tonic-gate } 92457c478bd9Sstevel@tonic-gate if (l == 0 || nonum) 92467c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 92477c478bd9Sstevel@tonic-gate 92487c478bd9Sstevel@tonic-gate *nump = num; 92497c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 92507c478bd9Sstevel@tonic-gate } 925119397407SSherry Moore 925219397407SSherry Moore /* 925319397407SSherry Moore * Default initialization function for drivers that don't need to quiesce. 925419397407SSherry Moore */ 925519397407SSherry Moore /* ARGSUSED */ 925619397407SSherry Moore int 925719397407SSherry Moore ddi_quiesce_not_needed(dev_info_t *dip) 925819397407SSherry Moore { 925919397407SSherry Moore return (DDI_SUCCESS); 926019397407SSherry Moore } 926119397407SSherry Moore 926219397407SSherry Moore /* 926319397407SSherry Moore * Initialization function for drivers that should implement quiesce() 926419397407SSherry Moore * but haven't yet. 926519397407SSherry Moore */ 926619397407SSherry Moore /* ARGSUSED */ 926719397407SSherry Moore int 926819397407SSherry Moore ddi_quiesce_not_supported(dev_info_t *dip) 926919397407SSherry Moore { 927019397407SSherry Moore return (DDI_FAILURE); 927119397407SSherry Moore } 92725febcb4aSScott Carter, SD IOSW 92737f0b8309SEdward Pilatowicz char * 92747f0b8309SEdward Pilatowicz ddi_strdup(const char *str, int flag) 92757f0b8309SEdward Pilatowicz { 92767f0b8309SEdward Pilatowicz int n; 92777f0b8309SEdward Pilatowicz char *ptr; 92787f0b8309SEdward Pilatowicz 92797f0b8309SEdward Pilatowicz ASSERT(str != NULL); 92807f0b8309SEdward Pilatowicz ASSERT((flag == KM_SLEEP) || (flag == KM_NOSLEEP)); 92817f0b8309SEdward Pilatowicz 92827f0b8309SEdward Pilatowicz n = strlen(str); 92837f0b8309SEdward Pilatowicz if ((ptr = kmem_alloc(n + 1, flag)) == NULL) 92847f0b8309SEdward Pilatowicz return (NULL); 92857f0b8309SEdward Pilatowicz bcopy(str, ptr, n + 1); 92867f0b8309SEdward Pilatowicz return (ptr); 92877f0b8309SEdward Pilatowicz } 92887f0b8309SEdward Pilatowicz 92897f0b8309SEdward Pilatowicz char * 92907f0b8309SEdward Pilatowicz strdup(const char *str) 92917f0b8309SEdward Pilatowicz { 92927f0b8309SEdward Pilatowicz return (ddi_strdup(str, KM_SLEEP)); 92937f0b8309SEdward Pilatowicz } 92947f0b8309SEdward Pilatowicz 92957f0b8309SEdward Pilatowicz void 92967f0b8309SEdward Pilatowicz strfree(char *str) 92977f0b8309SEdward Pilatowicz { 92987f0b8309SEdward Pilatowicz ASSERT(str != NULL); 92997f0b8309SEdward Pilatowicz kmem_free(str, strlen(str) + 1); 93007f0b8309SEdward Pilatowicz } 93017f0b8309SEdward Pilatowicz 93025febcb4aSScott Carter, SD IOSW /* 93035febcb4aSScott Carter, SD IOSW * Generic DDI callback interfaces. 93045febcb4aSScott Carter, SD IOSW */ 93055febcb4aSScott Carter, SD IOSW 93065febcb4aSScott Carter, SD IOSW int 93075febcb4aSScott Carter, SD IOSW ddi_cb_register(dev_info_t *dip, ddi_cb_flags_t flags, ddi_cb_func_t cbfunc, 93085febcb4aSScott Carter, SD IOSW void *arg1, void *arg2, ddi_cb_handle_t *ret_hdlp) 93095febcb4aSScott Carter, SD IOSW { 93105febcb4aSScott Carter, SD IOSW ddi_cb_t *cbp; 93115febcb4aSScott Carter, SD IOSW 93125febcb4aSScott Carter, SD IOSW ASSERT(dip != NULL); 93135febcb4aSScott Carter, SD IOSW ASSERT(DDI_CB_FLAG_VALID(flags)); 93145febcb4aSScott Carter, SD IOSW ASSERT(cbfunc != NULL); 93155febcb4aSScott Carter, SD IOSW ASSERT(ret_hdlp != NULL); 93165febcb4aSScott Carter, SD IOSW 93175febcb4aSScott Carter, SD IOSW /* Sanity check the context */ 93185febcb4aSScott Carter, SD IOSW ASSERT(!servicing_interrupt()); 93195febcb4aSScott Carter, SD IOSW if (servicing_interrupt()) 93205febcb4aSScott Carter, SD IOSW return (DDI_FAILURE); 93215febcb4aSScott Carter, SD IOSW 93225febcb4aSScott Carter, SD IOSW /* Validate parameters */ 93235febcb4aSScott Carter, SD IOSW if ((dip == NULL) || !DDI_CB_FLAG_VALID(flags) || 93245febcb4aSScott Carter, SD IOSW (cbfunc == NULL) || (ret_hdlp == NULL)) 93255febcb4aSScott Carter, SD IOSW return (DDI_EINVAL); 93265febcb4aSScott Carter, SD IOSW 93275febcb4aSScott Carter, SD IOSW /* Check for previous registration */ 93285febcb4aSScott Carter, SD IOSW if (DEVI(dip)->devi_cb_p != NULL) 93295febcb4aSScott Carter, SD IOSW return (DDI_EALREADY); 93305febcb4aSScott Carter, SD IOSW 93315febcb4aSScott Carter, SD IOSW /* Allocate and initialize callback */ 93325febcb4aSScott Carter, SD IOSW cbp = kmem_zalloc(sizeof (ddi_cb_t), KM_SLEEP); 93335febcb4aSScott Carter, SD IOSW cbp->cb_dip = dip; 93345febcb4aSScott Carter, SD IOSW cbp->cb_func = cbfunc; 93355febcb4aSScott Carter, SD IOSW cbp->cb_arg1 = arg1; 93365febcb4aSScott Carter, SD IOSW cbp->cb_arg2 = arg2; 93375febcb4aSScott Carter, SD IOSW cbp->cb_flags = flags; 93385febcb4aSScott Carter, SD IOSW DEVI(dip)->devi_cb_p = cbp; 93395febcb4aSScott Carter, SD IOSW 93405febcb4aSScott Carter, SD IOSW /* If adding an IRM callback, notify IRM */ 93415febcb4aSScott Carter, SD IOSW if (flags & DDI_CB_FLAG_INTR) 93425febcb4aSScott Carter, SD IOSW i_ddi_irm_set_cb(dip, B_TRUE); 93435febcb4aSScott Carter, SD IOSW 93445febcb4aSScott Carter, SD IOSW *ret_hdlp = (ddi_cb_handle_t)&(DEVI(dip)->devi_cb_p); 93455febcb4aSScott Carter, SD IOSW return (DDI_SUCCESS); 93465febcb4aSScott Carter, SD IOSW } 93475febcb4aSScott Carter, SD IOSW 93485febcb4aSScott Carter, SD IOSW int 93495febcb4aSScott Carter, SD IOSW ddi_cb_unregister(ddi_cb_handle_t hdl) 93505febcb4aSScott Carter, SD IOSW { 93515febcb4aSScott Carter, SD IOSW ddi_cb_t *cbp; 93525febcb4aSScott Carter, SD IOSW dev_info_t *dip; 93535febcb4aSScott Carter, SD IOSW 93545febcb4aSScott Carter, SD IOSW ASSERT(hdl != NULL); 93555febcb4aSScott Carter, SD IOSW 93565febcb4aSScott Carter, SD IOSW /* Sanity check the context */ 93575febcb4aSScott Carter, SD IOSW ASSERT(!servicing_interrupt()); 93585febcb4aSScott Carter, SD IOSW if (servicing_interrupt()) 93595febcb4aSScott Carter, SD IOSW return (DDI_FAILURE); 93605febcb4aSScott Carter, SD IOSW 93615febcb4aSScott Carter, SD IOSW /* Validate parameters */ 93625febcb4aSScott Carter, SD IOSW if ((hdl == NULL) || ((cbp = *(ddi_cb_t **)hdl) == NULL) || 93635febcb4aSScott Carter, SD IOSW ((dip = cbp->cb_dip) == NULL)) 93645febcb4aSScott Carter, SD IOSW return (DDI_EINVAL); 93655febcb4aSScott Carter, SD IOSW 93665febcb4aSScott Carter, SD IOSW /* If removing an IRM callback, notify IRM */ 93675febcb4aSScott Carter, SD IOSW if (cbp->cb_flags & DDI_CB_FLAG_INTR) 93685febcb4aSScott Carter, SD IOSW i_ddi_irm_set_cb(dip, B_FALSE); 93695febcb4aSScott Carter, SD IOSW 93705febcb4aSScott Carter, SD IOSW /* Destroy the callback */ 93715febcb4aSScott Carter, SD IOSW kmem_free(cbp, sizeof (ddi_cb_t)); 93725febcb4aSScott Carter, SD IOSW DEVI(dip)->devi_cb_p = NULL; 93735febcb4aSScott Carter, SD IOSW 93745febcb4aSScott Carter, SD IOSW return (DDI_SUCCESS); 93755febcb4aSScott Carter, SD IOSW } 9376*a3114836SGerry Liu 9377*a3114836SGerry Liu /* 9378*a3114836SGerry Liu * Platform independent DR routines 9379*a3114836SGerry Liu */ 9380*a3114836SGerry Liu 9381*a3114836SGerry Liu static int 9382*a3114836SGerry Liu ndi2errno(int n) 9383*a3114836SGerry Liu { 9384*a3114836SGerry Liu int err = 0; 9385*a3114836SGerry Liu 9386*a3114836SGerry Liu switch (n) { 9387*a3114836SGerry Liu case NDI_NOMEM: 9388*a3114836SGerry Liu err = ENOMEM; 9389*a3114836SGerry Liu break; 9390*a3114836SGerry Liu case NDI_BUSY: 9391*a3114836SGerry Liu err = EBUSY; 9392*a3114836SGerry Liu break; 9393*a3114836SGerry Liu case NDI_FAULT: 9394*a3114836SGerry Liu err = EFAULT; 9395*a3114836SGerry Liu break; 9396*a3114836SGerry Liu case NDI_FAILURE: 9397*a3114836SGerry Liu err = EIO; 9398*a3114836SGerry Liu break; 9399*a3114836SGerry Liu case NDI_SUCCESS: 9400*a3114836SGerry Liu break; 9401*a3114836SGerry Liu case NDI_BADHANDLE: 9402*a3114836SGerry Liu default: 9403*a3114836SGerry Liu err = EINVAL; 9404*a3114836SGerry Liu break; 9405*a3114836SGerry Liu } 9406*a3114836SGerry Liu return (err); 9407*a3114836SGerry Liu } 9408*a3114836SGerry Liu 9409*a3114836SGerry Liu /* 9410*a3114836SGerry Liu * Prom tree node list 9411*a3114836SGerry Liu */ 9412*a3114836SGerry Liu struct ptnode { 9413*a3114836SGerry Liu pnode_t nodeid; 9414*a3114836SGerry Liu struct ptnode *next; 9415*a3114836SGerry Liu }; 9416*a3114836SGerry Liu 9417*a3114836SGerry Liu /* 9418*a3114836SGerry Liu * Prom tree walk arg 9419*a3114836SGerry Liu */ 9420*a3114836SGerry Liu struct pta { 9421*a3114836SGerry Liu dev_info_t *pdip; 9422*a3114836SGerry Liu devi_branch_t *bp; 9423*a3114836SGerry Liu uint_t flags; 9424*a3114836SGerry Liu dev_info_t *fdip; 9425*a3114836SGerry Liu struct ptnode *head; 9426*a3114836SGerry Liu }; 9427*a3114836SGerry Liu 9428*a3114836SGerry Liu static void 9429*a3114836SGerry Liu visit_node(pnode_t nodeid, struct pta *ap) 9430*a3114836SGerry Liu { 9431*a3114836SGerry Liu struct ptnode **nextp; 9432*a3114836SGerry Liu int (*select)(pnode_t, void *, uint_t); 9433*a3114836SGerry Liu 9434*a3114836SGerry Liu ASSERT(nodeid != OBP_NONODE && nodeid != OBP_BADNODE); 9435*a3114836SGerry Liu 9436*a3114836SGerry Liu select = ap->bp->create.prom_branch_select; 9437*a3114836SGerry Liu 9438*a3114836SGerry Liu ASSERT(select); 9439*a3114836SGerry Liu 9440*a3114836SGerry Liu if (select(nodeid, ap->bp->arg, 0) == DDI_SUCCESS) { 9441*a3114836SGerry Liu 9442*a3114836SGerry Liu for (nextp = &ap->head; *nextp; nextp = &(*nextp)->next) 9443*a3114836SGerry Liu ; 9444*a3114836SGerry Liu 9445*a3114836SGerry Liu *nextp = kmem_zalloc(sizeof (struct ptnode), KM_SLEEP); 9446*a3114836SGerry Liu 9447*a3114836SGerry Liu (*nextp)->nodeid = nodeid; 9448*a3114836SGerry Liu } 9449*a3114836SGerry Liu 9450*a3114836SGerry Liu if ((ap->flags & DEVI_BRANCH_CHILD) == DEVI_BRANCH_CHILD) 9451*a3114836SGerry Liu return; 9452*a3114836SGerry Liu 9453*a3114836SGerry Liu nodeid = prom_childnode(nodeid); 9454*a3114836SGerry Liu while (nodeid != OBP_NONODE && nodeid != OBP_BADNODE) { 9455*a3114836SGerry Liu visit_node(nodeid, ap); 9456*a3114836SGerry Liu nodeid = prom_nextnode(nodeid); 9457*a3114836SGerry Liu } 9458*a3114836SGerry Liu } 9459*a3114836SGerry Liu 9460*a3114836SGerry Liu /* 9461*a3114836SGerry Liu * NOTE: The caller of this function must check for device contracts 9462*a3114836SGerry Liu * or LDI callbacks against this dip before setting the dip offline. 9463*a3114836SGerry Liu */ 9464*a3114836SGerry Liu static int 9465*a3114836SGerry Liu set_infant_dip_offline(dev_info_t *dip, void *arg) 9466*a3114836SGerry Liu { 9467*a3114836SGerry Liu char *path = (char *)arg; 9468*a3114836SGerry Liu 9469*a3114836SGerry Liu ASSERT(dip); 9470*a3114836SGerry Liu ASSERT(arg); 9471*a3114836SGerry Liu 9472*a3114836SGerry Liu if (i_ddi_node_state(dip) >= DS_ATTACHED) { 9473*a3114836SGerry Liu (void) ddi_pathname(dip, path); 9474*a3114836SGerry Liu cmn_err(CE_WARN, "Attempt to set offline flag on attached " 9475*a3114836SGerry Liu "node: %s", path); 9476*a3114836SGerry Liu return (DDI_FAILURE); 9477*a3114836SGerry Liu } 9478*a3114836SGerry Liu 9479*a3114836SGerry Liu mutex_enter(&(DEVI(dip)->devi_lock)); 9480*a3114836SGerry Liu if (!DEVI_IS_DEVICE_OFFLINE(dip)) 9481*a3114836SGerry Liu DEVI_SET_DEVICE_OFFLINE(dip); 9482*a3114836SGerry Liu mutex_exit(&(DEVI(dip)->devi_lock)); 9483*a3114836SGerry Liu 9484*a3114836SGerry Liu return (DDI_SUCCESS); 9485*a3114836SGerry Liu } 9486*a3114836SGerry Liu 9487*a3114836SGerry Liu typedef struct result { 9488*a3114836SGerry Liu char *path; 9489*a3114836SGerry Liu int result; 9490*a3114836SGerry Liu } result_t; 9491*a3114836SGerry Liu 9492*a3114836SGerry Liu static int 9493*a3114836SGerry Liu dip_set_offline(dev_info_t *dip, void *arg) 9494*a3114836SGerry Liu { 9495*a3114836SGerry Liu int end; 9496*a3114836SGerry Liu result_t *resp = (result_t *)arg; 9497*a3114836SGerry Liu 9498*a3114836SGerry Liu ASSERT(dip); 9499*a3114836SGerry Liu ASSERT(resp); 9500*a3114836SGerry Liu 9501*a3114836SGerry Liu /* 9502*a3114836SGerry Liu * We stop the walk if e_ddi_offline_notify() returns 9503*a3114836SGerry Liu * failure, because this implies that one or more consumers 9504*a3114836SGerry Liu * (either LDI or contract based) has blocked the offline. 9505*a3114836SGerry Liu * So there is no point in conitnuing the walk 9506*a3114836SGerry Liu */ 9507*a3114836SGerry Liu if (e_ddi_offline_notify(dip) == DDI_FAILURE) { 9508*a3114836SGerry Liu resp->result = DDI_FAILURE; 9509*a3114836SGerry Liu return (DDI_WALK_TERMINATE); 9510*a3114836SGerry Liu } 9511*a3114836SGerry Liu 9512*a3114836SGerry Liu /* 9513*a3114836SGerry Liu * If set_infant_dip_offline() returns failure, it implies 9514*a3114836SGerry Liu * that we failed to set a particular dip offline. This 9515*a3114836SGerry Liu * does not imply that the offline as a whole should fail. 9516*a3114836SGerry Liu * We want to do the best we can, so we continue the walk. 9517*a3114836SGerry Liu */ 9518*a3114836SGerry Liu if (set_infant_dip_offline(dip, resp->path) == DDI_SUCCESS) 9519*a3114836SGerry Liu end = DDI_SUCCESS; 9520*a3114836SGerry Liu else 9521*a3114836SGerry Liu end = DDI_FAILURE; 9522*a3114836SGerry Liu 9523*a3114836SGerry Liu e_ddi_offline_finalize(dip, end); 9524*a3114836SGerry Liu 9525*a3114836SGerry Liu return (DDI_WALK_CONTINUE); 9526*a3114836SGerry Liu } 9527*a3114836SGerry Liu 9528*a3114836SGerry Liu /* 9529*a3114836SGerry Liu * The call to e_ddi_offline_notify() exists for the 9530*a3114836SGerry Liu * unlikely error case that a branch we are trying to 9531*a3114836SGerry Liu * create already exists and has device contracts or LDI 9532*a3114836SGerry Liu * event callbacks against it. 9533*a3114836SGerry Liu * 9534*a3114836SGerry Liu * We allow create to succeed for such branches only if 9535*a3114836SGerry Liu * no constraints block the offline. 9536*a3114836SGerry Liu */ 9537*a3114836SGerry Liu static int 9538*a3114836SGerry Liu branch_set_offline(dev_info_t *dip, char *path) 9539*a3114836SGerry Liu { 9540*a3114836SGerry Liu int circ; 9541*a3114836SGerry Liu int end; 9542*a3114836SGerry Liu result_t res; 9543*a3114836SGerry Liu 9544*a3114836SGerry Liu 9545*a3114836SGerry Liu if (e_ddi_offline_notify(dip) == DDI_FAILURE) { 9546*a3114836SGerry Liu return (DDI_FAILURE); 9547*a3114836SGerry Liu } 9548*a3114836SGerry Liu 9549*a3114836SGerry Liu if (set_infant_dip_offline(dip, path) == DDI_SUCCESS) 9550*a3114836SGerry Liu end = DDI_SUCCESS; 9551*a3114836SGerry Liu else 9552*a3114836SGerry Liu end = DDI_FAILURE; 9553*a3114836SGerry Liu 9554*a3114836SGerry Liu e_ddi_offline_finalize(dip, end); 9555*a3114836SGerry Liu 9556*a3114836SGerry Liu if (end == DDI_FAILURE) 9557*a3114836SGerry Liu return (DDI_FAILURE); 9558*a3114836SGerry Liu 9559*a3114836SGerry Liu res.result = DDI_SUCCESS; 9560*a3114836SGerry Liu res.path = path; 9561*a3114836SGerry Liu 9562*a3114836SGerry Liu ndi_devi_enter(dip, &circ); 9563*a3114836SGerry Liu ddi_walk_devs(ddi_get_child(dip), dip_set_offline, &res); 9564*a3114836SGerry Liu ndi_devi_exit(dip, circ); 9565*a3114836SGerry Liu 9566*a3114836SGerry Liu return (res.result); 9567*a3114836SGerry Liu } 9568*a3114836SGerry Liu 9569*a3114836SGerry Liu /*ARGSUSED*/ 9570*a3114836SGerry Liu static int 9571*a3114836SGerry Liu create_prom_branch(void *arg, int has_changed) 9572*a3114836SGerry Liu { 9573*a3114836SGerry Liu int circ; 9574*a3114836SGerry Liu int exists, rv; 9575*a3114836SGerry Liu pnode_t nodeid; 9576*a3114836SGerry Liu struct ptnode *tnp; 9577*a3114836SGerry Liu dev_info_t *dip; 9578*a3114836SGerry Liu struct pta *ap = arg; 9579*a3114836SGerry Liu devi_branch_t *bp; 9580*a3114836SGerry Liu char *path; 9581*a3114836SGerry Liu 9582*a3114836SGerry Liu ASSERT(ap); 9583*a3114836SGerry Liu ASSERT(ap->fdip == NULL); 9584*a3114836SGerry Liu ASSERT(ap->pdip && ndi_dev_is_prom_node(ap->pdip)); 9585*a3114836SGerry Liu 9586*a3114836SGerry Liu bp = ap->bp; 9587*a3114836SGerry Liu 9588*a3114836SGerry Liu nodeid = ddi_get_nodeid(ap->pdip); 9589*a3114836SGerry Liu if (nodeid == OBP_NONODE || nodeid == OBP_BADNODE) { 9590*a3114836SGerry Liu cmn_err(CE_WARN, "create_prom_branch: invalid " 9591*a3114836SGerry Liu "nodeid: 0x%x", nodeid); 9592*a3114836SGerry Liu return (EINVAL); 9593*a3114836SGerry Liu } 9594*a3114836SGerry Liu 9595*a3114836SGerry Liu ap->head = NULL; 9596*a3114836SGerry Liu 9597*a3114836SGerry Liu nodeid = prom_childnode(nodeid); 9598*a3114836SGerry Liu while (nodeid != OBP_NONODE && nodeid != OBP_BADNODE) { 9599*a3114836SGerry Liu visit_node(nodeid, ap); 9600*a3114836SGerry Liu nodeid = prom_nextnode(nodeid); 9601*a3114836SGerry Liu } 9602*a3114836SGerry Liu 9603*a3114836SGerry Liu if (ap->head == NULL) 9604*a3114836SGerry Liu return (ENODEV); 9605*a3114836SGerry Liu 9606*a3114836SGerry Liu path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 9607*a3114836SGerry Liu rv = 0; 9608*a3114836SGerry Liu while ((tnp = ap->head) != NULL) { 9609*a3114836SGerry Liu ap->head = tnp->next; 9610*a3114836SGerry Liu 9611*a3114836SGerry Liu ndi_devi_enter(ap->pdip, &circ); 9612*a3114836SGerry Liu 9613*a3114836SGerry Liu /* 9614*a3114836SGerry Liu * Check if the branch already exists. 9615*a3114836SGerry Liu */ 9616*a3114836SGerry Liu exists = 0; 9617*a3114836SGerry Liu dip = e_ddi_nodeid_to_dip(tnp->nodeid); 9618*a3114836SGerry Liu if (dip != NULL) { 9619*a3114836SGerry Liu exists = 1; 9620*a3114836SGerry Liu 9621*a3114836SGerry Liu /* Parent is held busy, so release hold */ 9622*a3114836SGerry Liu ndi_rele_devi(dip); 9623*a3114836SGerry Liu #ifdef DEBUG 9624*a3114836SGerry Liu cmn_err(CE_WARN, "create_prom_branch: dip(%p) exists" 9625*a3114836SGerry Liu " for nodeid 0x%x", (void *)dip, tnp->nodeid); 9626*a3114836SGerry Liu #endif 9627*a3114836SGerry Liu } else { 9628*a3114836SGerry Liu dip = i_ddi_create_branch(ap->pdip, tnp->nodeid); 9629*a3114836SGerry Liu } 9630*a3114836SGerry Liu 9631*a3114836SGerry Liu kmem_free(tnp, sizeof (struct ptnode)); 9632*a3114836SGerry Liu 9633*a3114836SGerry Liu /* 9634*a3114836SGerry Liu * Hold the branch if it is not already held 9635*a3114836SGerry Liu */ 9636*a3114836SGerry Liu if (dip && !exists) { 9637*a3114836SGerry Liu e_ddi_branch_hold(dip); 9638*a3114836SGerry Liu } 9639*a3114836SGerry Liu 9640*a3114836SGerry Liu ASSERT(dip == NULL || e_ddi_branch_held(dip)); 9641*a3114836SGerry Liu 9642*a3114836SGerry Liu /* 9643*a3114836SGerry Liu * Set all dips in the newly created branch offline so that 9644*a3114836SGerry Liu * only a "configure" operation can attach 9645*a3114836SGerry Liu * the branch 9646*a3114836SGerry Liu */ 9647*a3114836SGerry Liu if (dip == NULL || branch_set_offline(dip, path) 9648*a3114836SGerry Liu == DDI_FAILURE) { 9649*a3114836SGerry Liu ndi_devi_exit(ap->pdip, circ); 9650*a3114836SGerry Liu rv = EIO; 9651*a3114836SGerry Liu continue; 9652*a3114836SGerry Liu } 9653*a3114836SGerry Liu 9654*a3114836SGerry Liu ASSERT(ddi_get_parent(dip) == ap->pdip); 9655*a3114836SGerry Liu 9656*a3114836SGerry Liu ndi_devi_exit(ap->pdip, circ); 9657*a3114836SGerry Liu 9658*a3114836SGerry Liu if (ap->flags & DEVI_BRANCH_CONFIGURE) { 9659*a3114836SGerry Liu int error = e_ddi_branch_configure(dip, &ap->fdip, 0); 9660*a3114836SGerry Liu if (error && rv == 0) 9661*a3114836SGerry Liu rv = error; 9662*a3114836SGerry Liu } 9663*a3114836SGerry Liu 9664*a3114836SGerry Liu /* 9665*a3114836SGerry Liu * Invoke devi_branch_callback() (if it exists) only for 9666*a3114836SGerry Liu * newly created branches 9667*a3114836SGerry Liu */ 9668*a3114836SGerry Liu if (bp->devi_branch_callback && !exists) 9669*a3114836SGerry Liu bp->devi_branch_callback(dip, bp->arg, 0); 9670*a3114836SGerry Liu } 9671*a3114836SGerry Liu 9672*a3114836SGerry Liu kmem_free(path, MAXPATHLEN); 9673*a3114836SGerry Liu 9674*a3114836SGerry Liu return (rv); 9675*a3114836SGerry Liu } 9676*a3114836SGerry Liu 9677*a3114836SGerry Liu static int 9678*a3114836SGerry Liu sid_node_create(dev_info_t *pdip, devi_branch_t *bp, dev_info_t **rdipp) 9679*a3114836SGerry Liu { 9680*a3114836SGerry Liu int rv, circ, len; 9681*a3114836SGerry Liu int i, flags, ret; 9682*a3114836SGerry Liu dev_info_t *dip; 9683*a3114836SGerry Liu char *nbuf; 9684*a3114836SGerry Liu char *path; 9685*a3114836SGerry Liu static const char *noname = "<none>"; 9686*a3114836SGerry Liu 9687*a3114836SGerry Liu ASSERT(pdip); 9688*a3114836SGerry Liu ASSERT(DEVI_BUSY_OWNED(pdip)); 9689*a3114836SGerry Liu 9690*a3114836SGerry Liu flags = 0; 9691*a3114836SGerry Liu 9692*a3114836SGerry Liu /* 9693*a3114836SGerry Liu * Creating the root of a branch ? 9694*a3114836SGerry Liu */ 9695*a3114836SGerry Liu if (rdipp) { 9696*a3114836SGerry Liu *rdipp = NULL; 9697*a3114836SGerry Liu flags = DEVI_BRANCH_ROOT; 9698*a3114836SGerry Liu } 9699*a3114836SGerry Liu 9700*a3114836SGerry Liu ndi_devi_alloc_sleep(pdip, (char *)noname, DEVI_SID_NODEID, &dip); 9701*a3114836SGerry Liu rv = bp->create.sid_branch_create(dip, bp->arg, flags); 9702*a3114836SGerry Liu 9703*a3114836SGerry Liu nbuf = kmem_alloc(OBP_MAXDRVNAME, KM_SLEEP); 9704*a3114836SGerry Liu 9705*a3114836SGerry Liu if (rv == DDI_WALK_ERROR) { 9706*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_create: Error setting" 9707*a3114836SGerry Liu " properties on devinfo node %p", (void *)dip); 9708*a3114836SGerry Liu goto fail; 9709*a3114836SGerry Liu } 9710*a3114836SGerry Liu 9711*a3114836SGerry Liu len = OBP_MAXDRVNAME; 9712*a3114836SGerry Liu if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, 9713*a3114836SGerry Liu DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "name", nbuf, &len) 9714*a3114836SGerry Liu != DDI_PROP_SUCCESS) { 9715*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_create: devinfo node %p has" 9716*a3114836SGerry Liu "no name property", (void *)dip); 9717*a3114836SGerry Liu goto fail; 9718*a3114836SGerry Liu } 9719*a3114836SGerry Liu 9720*a3114836SGerry Liu ASSERT(i_ddi_node_state(dip) == DS_PROTO); 9721*a3114836SGerry Liu if (ndi_devi_set_nodename(dip, nbuf, 0) != NDI_SUCCESS) { 9722*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_create: cannot set name (%s)" 9723*a3114836SGerry Liu " for devinfo node %p", nbuf, (void *)dip); 9724*a3114836SGerry Liu goto fail; 9725*a3114836SGerry Liu } 9726*a3114836SGerry Liu 9727*a3114836SGerry Liu kmem_free(nbuf, OBP_MAXDRVNAME); 9728*a3114836SGerry Liu 9729*a3114836SGerry Liu /* 9730*a3114836SGerry Liu * Ignore bind failures just like boot does 9731*a3114836SGerry Liu */ 9732*a3114836SGerry Liu (void) ndi_devi_bind_driver(dip, 0); 9733*a3114836SGerry Liu 9734*a3114836SGerry Liu switch (rv) { 9735*a3114836SGerry Liu case DDI_WALK_CONTINUE: 9736*a3114836SGerry Liu case DDI_WALK_PRUNESIB: 9737*a3114836SGerry Liu ndi_devi_enter(dip, &circ); 9738*a3114836SGerry Liu 9739*a3114836SGerry Liu i = DDI_WALK_CONTINUE; 9740*a3114836SGerry Liu for (; i == DDI_WALK_CONTINUE; ) { 9741*a3114836SGerry Liu i = sid_node_create(dip, bp, NULL); 9742*a3114836SGerry Liu } 9743*a3114836SGerry Liu 9744*a3114836SGerry Liu ASSERT(i == DDI_WALK_ERROR || i == DDI_WALK_PRUNESIB); 9745*a3114836SGerry Liu if (i == DDI_WALK_ERROR) 9746*a3114836SGerry Liu rv = i; 9747*a3114836SGerry Liu /* 9748*a3114836SGerry Liu * If PRUNESIB stop creating siblings 9749*a3114836SGerry Liu * of dip's child. Subsequent walk behavior 9750*a3114836SGerry Liu * is determined by rv returned by dip. 9751*a3114836SGerry Liu */ 9752*a3114836SGerry Liu 9753*a3114836SGerry Liu ndi_devi_exit(dip, circ); 9754*a3114836SGerry Liu break; 9755*a3114836SGerry Liu case DDI_WALK_TERMINATE: 9756*a3114836SGerry Liu /* 9757*a3114836SGerry Liu * Don't create children and ask our parent 9758*a3114836SGerry Liu * to not create siblings either. 9759*a3114836SGerry Liu */ 9760*a3114836SGerry Liu rv = DDI_WALK_PRUNESIB; 9761*a3114836SGerry Liu break; 9762*a3114836SGerry Liu case DDI_WALK_PRUNECHILD: 9763*a3114836SGerry Liu /* 9764*a3114836SGerry Liu * Don't create children, but ask parent to continue 9765*a3114836SGerry Liu * with siblings. 9766*a3114836SGerry Liu */ 9767*a3114836SGerry Liu rv = DDI_WALK_CONTINUE; 9768*a3114836SGerry Liu break; 9769*a3114836SGerry Liu default: 9770*a3114836SGerry Liu ASSERT(0); 9771*a3114836SGerry Liu break; 9772*a3114836SGerry Liu } 9773*a3114836SGerry Liu 9774*a3114836SGerry Liu if (rdipp) 9775*a3114836SGerry Liu *rdipp = dip; 9776*a3114836SGerry Liu 9777*a3114836SGerry Liu /* 9778*a3114836SGerry Liu * Set device offline - only the "configure" op should cause an attach. 9779*a3114836SGerry Liu * Note that it is safe to set the dip offline without checking 9780*a3114836SGerry Liu * for either device contract or layered driver (LDI) based constraints 9781*a3114836SGerry Liu * since there cannot be any contracts or LDI opens of this device. 9782*a3114836SGerry Liu * This is because this node is a newly created dip with the parent busy 9783*a3114836SGerry Liu * held, so no other thread can come in and attach this dip. A dip that 9784*a3114836SGerry Liu * has never been attached cannot have contracts since by definition 9785*a3114836SGerry Liu * a device contract (an agreement between a process and a device minor 9786*a3114836SGerry Liu * node) can only be created against a device that has minor nodes 9787*a3114836SGerry Liu * i.e is attached. Similarly an LDI open will only succeed if the 9788*a3114836SGerry Liu * dip is attached. We assert below that the dip is not attached. 9789*a3114836SGerry Liu */ 9790*a3114836SGerry Liu ASSERT(i_ddi_node_state(dip) < DS_ATTACHED); 9791*a3114836SGerry Liu path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 9792*a3114836SGerry Liu ret = set_infant_dip_offline(dip, path); 9793*a3114836SGerry Liu ASSERT(ret == DDI_SUCCESS); 9794*a3114836SGerry Liu kmem_free(path, MAXPATHLEN); 9795*a3114836SGerry Liu 9796*a3114836SGerry Liu return (rv); 9797*a3114836SGerry Liu fail: 9798*a3114836SGerry Liu (void) ndi_devi_free(dip); 9799*a3114836SGerry Liu kmem_free(nbuf, OBP_MAXDRVNAME); 9800*a3114836SGerry Liu return (DDI_WALK_ERROR); 9801*a3114836SGerry Liu } 9802*a3114836SGerry Liu 9803*a3114836SGerry Liu static int 9804*a3114836SGerry Liu create_sid_branch( 9805*a3114836SGerry Liu dev_info_t *pdip, 9806*a3114836SGerry Liu devi_branch_t *bp, 9807*a3114836SGerry Liu dev_info_t **dipp, 9808*a3114836SGerry Liu uint_t flags) 9809*a3114836SGerry Liu { 9810*a3114836SGerry Liu int rv = 0, state = DDI_WALK_CONTINUE; 9811*a3114836SGerry Liu dev_info_t *rdip; 9812*a3114836SGerry Liu 9813*a3114836SGerry Liu while (state == DDI_WALK_CONTINUE) { 9814*a3114836SGerry Liu int circ; 9815*a3114836SGerry Liu 9816*a3114836SGerry Liu ndi_devi_enter(pdip, &circ); 9817*a3114836SGerry Liu 9818*a3114836SGerry Liu state = sid_node_create(pdip, bp, &rdip); 9819*a3114836SGerry Liu if (rdip == NULL) { 9820*a3114836SGerry Liu ndi_devi_exit(pdip, circ); 9821*a3114836SGerry Liu ASSERT(state == DDI_WALK_ERROR); 9822*a3114836SGerry Liu break; 9823*a3114836SGerry Liu } 9824*a3114836SGerry Liu 9825*a3114836SGerry Liu e_ddi_branch_hold(rdip); 9826*a3114836SGerry Liu 9827*a3114836SGerry Liu ndi_devi_exit(pdip, circ); 9828*a3114836SGerry Liu 9829*a3114836SGerry Liu if (flags & DEVI_BRANCH_CONFIGURE) { 9830*a3114836SGerry Liu int error = e_ddi_branch_configure(rdip, dipp, 0); 9831*a3114836SGerry Liu if (error && rv == 0) 9832*a3114836SGerry Liu rv = error; 9833*a3114836SGerry Liu } 9834*a3114836SGerry Liu 9835*a3114836SGerry Liu /* 9836*a3114836SGerry Liu * devi_branch_callback() is optional 9837*a3114836SGerry Liu */ 9838*a3114836SGerry Liu if (bp->devi_branch_callback) 9839*a3114836SGerry Liu bp->devi_branch_callback(rdip, bp->arg, 0); 9840*a3114836SGerry Liu } 9841*a3114836SGerry Liu 9842*a3114836SGerry Liu ASSERT(state == DDI_WALK_ERROR || state == DDI_WALK_PRUNESIB); 9843*a3114836SGerry Liu 9844*a3114836SGerry Liu return (state == DDI_WALK_ERROR ? EIO : rv); 9845*a3114836SGerry Liu } 9846*a3114836SGerry Liu 9847*a3114836SGerry Liu int 9848*a3114836SGerry Liu e_ddi_branch_create( 9849*a3114836SGerry Liu dev_info_t *pdip, 9850*a3114836SGerry Liu devi_branch_t *bp, 9851*a3114836SGerry Liu dev_info_t **dipp, 9852*a3114836SGerry Liu uint_t flags) 9853*a3114836SGerry Liu { 9854*a3114836SGerry Liu int prom_devi, sid_devi, error; 9855*a3114836SGerry Liu 9856*a3114836SGerry Liu if (pdip == NULL || bp == NULL || bp->type == 0) 9857*a3114836SGerry Liu return (EINVAL); 9858*a3114836SGerry Liu 9859*a3114836SGerry Liu prom_devi = (bp->type == DEVI_BRANCH_PROM) ? 1 : 0; 9860*a3114836SGerry Liu sid_devi = (bp->type == DEVI_BRANCH_SID) ? 1 : 0; 9861*a3114836SGerry Liu 9862*a3114836SGerry Liu if (prom_devi && bp->create.prom_branch_select == NULL) 9863*a3114836SGerry Liu return (EINVAL); 9864*a3114836SGerry Liu else if (sid_devi && bp->create.sid_branch_create == NULL) 9865*a3114836SGerry Liu return (EINVAL); 9866*a3114836SGerry Liu else if (!prom_devi && !sid_devi) 9867*a3114836SGerry Liu return (EINVAL); 9868*a3114836SGerry Liu 9869*a3114836SGerry Liu if (flags & DEVI_BRANCH_EVENT) 9870*a3114836SGerry Liu return (EINVAL); 9871*a3114836SGerry Liu 9872*a3114836SGerry Liu if (prom_devi) { 9873*a3114836SGerry Liu struct pta pta = {0}; 9874*a3114836SGerry Liu 9875*a3114836SGerry Liu pta.pdip = pdip; 9876*a3114836SGerry Liu pta.bp = bp; 9877*a3114836SGerry Liu pta.flags = flags; 9878*a3114836SGerry Liu 9879*a3114836SGerry Liu error = prom_tree_access(create_prom_branch, &pta, NULL); 9880*a3114836SGerry Liu 9881*a3114836SGerry Liu if (dipp) 9882*a3114836SGerry Liu *dipp = pta.fdip; 9883*a3114836SGerry Liu else if (pta.fdip) 9884*a3114836SGerry Liu ndi_rele_devi(pta.fdip); 9885*a3114836SGerry Liu } else { 9886*a3114836SGerry Liu error = create_sid_branch(pdip, bp, dipp, flags); 9887*a3114836SGerry Liu } 9888*a3114836SGerry Liu 9889*a3114836SGerry Liu return (error); 9890*a3114836SGerry Liu } 9891*a3114836SGerry Liu 9892*a3114836SGerry Liu int 9893*a3114836SGerry Liu e_ddi_branch_configure(dev_info_t *rdip, dev_info_t **dipp, uint_t flags) 9894*a3114836SGerry Liu { 9895*a3114836SGerry Liu int rv; 9896*a3114836SGerry Liu char *devnm; 9897*a3114836SGerry Liu dev_info_t *pdip; 9898*a3114836SGerry Liu 9899*a3114836SGerry Liu if (dipp) 9900*a3114836SGerry Liu *dipp = NULL; 9901*a3114836SGerry Liu 9902*a3114836SGerry Liu if (rdip == NULL || flags != 0 || (flags & DEVI_BRANCH_EVENT)) 9903*a3114836SGerry Liu return (EINVAL); 9904*a3114836SGerry Liu 9905*a3114836SGerry Liu pdip = ddi_get_parent(rdip); 9906*a3114836SGerry Liu 9907*a3114836SGerry Liu ndi_hold_devi(pdip); 9908*a3114836SGerry Liu 9909*a3114836SGerry Liu if (!e_ddi_branch_held(rdip)) { 9910*a3114836SGerry Liu ndi_rele_devi(pdip); 9911*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_configure: " 9912*a3114836SGerry Liu "dip(%p) not held", (void *)rdip); 9913*a3114836SGerry Liu return (EINVAL); 9914*a3114836SGerry Liu } 9915*a3114836SGerry Liu 9916*a3114836SGerry Liu if (i_ddi_node_state(rdip) < DS_INITIALIZED) { 9917*a3114836SGerry Liu /* 9918*a3114836SGerry Liu * First attempt to bind a driver. If we fail, return 9919*a3114836SGerry Liu * success (On some platforms, dips for some device 9920*a3114836SGerry Liu * types (CPUs) may not have a driver) 9921*a3114836SGerry Liu */ 9922*a3114836SGerry Liu if (ndi_devi_bind_driver(rdip, 0) != NDI_SUCCESS) { 9923*a3114836SGerry Liu ndi_rele_devi(pdip); 9924*a3114836SGerry Liu return (0); 9925*a3114836SGerry Liu } 9926*a3114836SGerry Liu 9927*a3114836SGerry Liu if (ddi_initchild(pdip, rdip) != DDI_SUCCESS) { 9928*a3114836SGerry Liu rv = NDI_FAILURE; 9929*a3114836SGerry Liu goto out; 9930*a3114836SGerry Liu } 9931*a3114836SGerry Liu } 9932*a3114836SGerry Liu 9933*a3114836SGerry Liu ASSERT(i_ddi_node_state(rdip) >= DS_INITIALIZED); 9934*a3114836SGerry Liu 9935*a3114836SGerry Liu devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP); 9936*a3114836SGerry Liu 9937*a3114836SGerry Liu (void) ddi_deviname(rdip, devnm); 9938*a3114836SGerry Liu 9939*a3114836SGerry Liu if ((rv = ndi_devi_config_one(pdip, devnm+1, &rdip, 9940*a3114836SGerry Liu NDI_DEVI_ONLINE | NDI_CONFIG)) == NDI_SUCCESS) { 9941*a3114836SGerry Liu /* release hold from ndi_devi_config_one() */ 9942*a3114836SGerry Liu ndi_rele_devi(rdip); 9943*a3114836SGerry Liu } 9944*a3114836SGerry Liu 9945*a3114836SGerry Liu kmem_free(devnm, MAXNAMELEN + 1); 9946*a3114836SGerry Liu out: 9947*a3114836SGerry Liu if (rv != NDI_SUCCESS && dipp && rdip) { 9948*a3114836SGerry Liu ndi_hold_devi(rdip); 9949*a3114836SGerry Liu *dipp = rdip; 9950*a3114836SGerry Liu } 9951*a3114836SGerry Liu ndi_rele_devi(pdip); 9952*a3114836SGerry Liu return (ndi2errno(rv)); 9953*a3114836SGerry Liu } 9954*a3114836SGerry Liu 9955*a3114836SGerry Liu void 9956*a3114836SGerry Liu e_ddi_branch_hold(dev_info_t *rdip) 9957*a3114836SGerry Liu { 9958*a3114836SGerry Liu if (e_ddi_branch_held(rdip)) { 9959*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_hold: branch already held"); 9960*a3114836SGerry Liu return; 9961*a3114836SGerry Liu } 9962*a3114836SGerry Liu 9963*a3114836SGerry Liu mutex_enter(&DEVI(rdip)->devi_lock); 9964*a3114836SGerry Liu if ((DEVI(rdip)->devi_flags & DEVI_BRANCH_HELD) == 0) { 9965*a3114836SGerry Liu DEVI(rdip)->devi_flags |= DEVI_BRANCH_HELD; 9966*a3114836SGerry Liu DEVI(rdip)->devi_ref++; 9967*a3114836SGerry Liu } 9968*a3114836SGerry Liu ASSERT(DEVI(rdip)->devi_ref > 0); 9969*a3114836SGerry Liu mutex_exit(&DEVI(rdip)->devi_lock); 9970*a3114836SGerry Liu } 9971*a3114836SGerry Liu 9972*a3114836SGerry Liu int 9973*a3114836SGerry Liu e_ddi_branch_held(dev_info_t *rdip) 9974*a3114836SGerry Liu { 9975*a3114836SGerry Liu int rv = 0; 9976*a3114836SGerry Liu 9977*a3114836SGerry Liu mutex_enter(&DEVI(rdip)->devi_lock); 9978*a3114836SGerry Liu if ((DEVI(rdip)->devi_flags & DEVI_BRANCH_HELD) && 9979*a3114836SGerry Liu DEVI(rdip)->devi_ref > 0) { 9980*a3114836SGerry Liu rv = 1; 9981*a3114836SGerry Liu } 9982*a3114836SGerry Liu mutex_exit(&DEVI(rdip)->devi_lock); 9983*a3114836SGerry Liu 9984*a3114836SGerry Liu return (rv); 9985*a3114836SGerry Liu } 9986*a3114836SGerry Liu 9987*a3114836SGerry Liu void 9988*a3114836SGerry Liu e_ddi_branch_rele(dev_info_t *rdip) 9989*a3114836SGerry Liu { 9990*a3114836SGerry Liu mutex_enter(&DEVI(rdip)->devi_lock); 9991*a3114836SGerry Liu DEVI(rdip)->devi_flags &= ~DEVI_BRANCH_HELD; 9992*a3114836SGerry Liu DEVI(rdip)->devi_ref--; 9993*a3114836SGerry Liu mutex_exit(&DEVI(rdip)->devi_lock); 9994*a3114836SGerry Liu } 9995*a3114836SGerry Liu 9996*a3114836SGerry Liu int 9997*a3114836SGerry Liu e_ddi_branch_unconfigure( 9998*a3114836SGerry Liu dev_info_t *rdip, 9999*a3114836SGerry Liu dev_info_t **dipp, 10000*a3114836SGerry Liu uint_t flags) 10001*a3114836SGerry Liu { 10002*a3114836SGerry Liu int circ, rv; 10003*a3114836SGerry Liu int destroy; 10004*a3114836SGerry Liu char *devnm; 10005*a3114836SGerry Liu uint_t nflags; 10006*a3114836SGerry Liu dev_info_t *pdip; 10007*a3114836SGerry Liu 10008*a3114836SGerry Liu if (dipp) 10009*a3114836SGerry Liu *dipp = NULL; 10010*a3114836SGerry Liu 10011*a3114836SGerry Liu if (rdip == NULL) 10012*a3114836SGerry Liu return (EINVAL); 10013*a3114836SGerry Liu 10014*a3114836SGerry Liu pdip = ddi_get_parent(rdip); 10015*a3114836SGerry Liu 10016*a3114836SGerry Liu ASSERT(pdip); 10017*a3114836SGerry Liu 10018*a3114836SGerry Liu /* 10019*a3114836SGerry Liu * Check if caller holds pdip busy - can cause deadlocks during 10020*a3114836SGerry Liu * devfs_clean() 10021*a3114836SGerry Liu */ 10022*a3114836SGerry Liu if (DEVI_BUSY_OWNED(pdip)) { 10023*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_unconfigure: failed: parent" 10024*a3114836SGerry Liu " devinfo node(%p) is busy held", (void *)pdip); 10025*a3114836SGerry Liu return (EINVAL); 10026*a3114836SGerry Liu } 10027*a3114836SGerry Liu 10028*a3114836SGerry Liu destroy = (flags & DEVI_BRANCH_DESTROY) ? 1 : 0; 10029*a3114836SGerry Liu 10030*a3114836SGerry Liu devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP); 10031*a3114836SGerry Liu 10032*a3114836SGerry Liu ndi_devi_enter(pdip, &circ); 10033*a3114836SGerry Liu (void) ddi_deviname(rdip, devnm); 10034*a3114836SGerry Liu ndi_devi_exit(pdip, circ); 10035*a3114836SGerry Liu 10036*a3114836SGerry Liu /* 10037*a3114836SGerry Liu * ddi_deviname() returns a component name with / prepended. 10038*a3114836SGerry Liu */ 10039*a3114836SGerry Liu (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE); 10040*a3114836SGerry Liu 10041*a3114836SGerry Liu ndi_devi_enter(pdip, &circ); 10042*a3114836SGerry Liu 10043*a3114836SGerry Liu /* 10044*a3114836SGerry Liu * Recreate device name as it may have changed state (init/uninit) 10045*a3114836SGerry Liu * when parent busy lock was dropped for devfs_clean() 10046*a3114836SGerry Liu */ 10047*a3114836SGerry Liu (void) ddi_deviname(rdip, devnm); 10048*a3114836SGerry Liu 10049*a3114836SGerry Liu if (!e_ddi_branch_held(rdip)) { 10050*a3114836SGerry Liu kmem_free(devnm, MAXNAMELEN + 1); 10051*a3114836SGerry Liu ndi_devi_exit(pdip, circ); 10052*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_%s_branch: dip(%p) not held", 10053*a3114836SGerry Liu destroy ? "destroy" : "unconfigure", (void *)rdip); 10054*a3114836SGerry Liu return (EINVAL); 10055*a3114836SGerry Liu } 10056*a3114836SGerry Liu 10057*a3114836SGerry Liu /* 10058*a3114836SGerry Liu * Release hold on the branch. This is ok since we are holding the 10059*a3114836SGerry Liu * parent busy. If rdip is not removed, we must do a hold on the 10060*a3114836SGerry Liu * branch before returning. 10061*a3114836SGerry Liu */ 10062*a3114836SGerry Liu e_ddi_branch_rele(rdip); 10063*a3114836SGerry Liu 10064*a3114836SGerry Liu nflags = NDI_DEVI_OFFLINE; 10065*a3114836SGerry Liu if (destroy || (flags & DEVI_BRANCH_DESTROY)) { 10066*a3114836SGerry Liu nflags |= NDI_DEVI_REMOVE; 10067*a3114836SGerry Liu destroy = 1; 10068*a3114836SGerry Liu } else { 10069*a3114836SGerry Liu nflags |= NDI_UNCONFIG; /* uninit but don't remove */ 10070*a3114836SGerry Liu } 10071*a3114836SGerry Liu 10072*a3114836SGerry Liu if (flags & DEVI_BRANCH_EVENT) 10073*a3114836SGerry Liu nflags |= NDI_POST_EVENT; 10074*a3114836SGerry Liu 10075*a3114836SGerry Liu if (i_ddi_devi_attached(pdip) && 10076*a3114836SGerry Liu (i_ddi_node_state(rdip) >= DS_INITIALIZED)) { 10077*a3114836SGerry Liu rv = ndi_devi_unconfig_one(pdip, devnm+1, dipp, nflags); 10078*a3114836SGerry Liu } else { 10079*a3114836SGerry Liu rv = e_ddi_devi_unconfig(rdip, dipp, nflags); 10080*a3114836SGerry Liu if (rv == NDI_SUCCESS) { 10081*a3114836SGerry Liu ASSERT(!destroy || ddi_get_child(rdip) == NULL); 10082*a3114836SGerry Liu rv = ndi_devi_offline(rdip, nflags); 10083*a3114836SGerry Liu } 10084*a3114836SGerry Liu } 10085*a3114836SGerry Liu 10086*a3114836SGerry Liu if (!destroy || rv != NDI_SUCCESS) { 10087*a3114836SGerry Liu /* The dip still exists, so do a hold */ 10088*a3114836SGerry Liu e_ddi_branch_hold(rdip); 10089*a3114836SGerry Liu } 10090*a3114836SGerry Liu out: 10091*a3114836SGerry Liu kmem_free(devnm, MAXNAMELEN + 1); 10092*a3114836SGerry Liu ndi_devi_exit(pdip, circ); 10093*a3114836SGerry Liu return (ndi2errno(rv)); 10094*a3114836SGerry Liu } 10095*a3114836SGerry Liu 10096*a3114836SGerry Liu int 10097*a3114836SGerry Liu e_ddi_branch_destroy(dev_info_t *rdip, dev_info_t **dipp, uint_t flag) 10098*a3114836SGerry Liu { 10099*a3114836SGerry Liu return (e_ddi_branch_unconfigure(rdip, dipp, 10100*a3114836SGerry Liu flag|DEVI_BRANCH_DESTROY)); 10101*a3114836SGerry Liu } 10102*a3114836SGerry Liu 10103*a3114836SGerry Liu /* 10104*a3114836SGerry Liu * Number of chains for hash table 10105*a3114836SGerry Liu */ 10106*a3114836SGerry Liu #define NUMCHAINS 17 10107*a3114836SGerry Liu 10108*a3114836SGerry Liu /* 10109*a3114836SGerry Liu * Devinfo busy arg 10110*a3114836SGerry Liu */ 10111*a3114836SGerry Liu struct devi_busy { 10112*a3114836SGerry Liu int dv_total; 10113*a3114836SGerry Liu int s_total; 10114*a3114836SGerry Liu mod_hash_t *dv_hash; 10115*a3114836SGerry Liu mod_hash_t *s_hash; 10116*a3114836SGerry Liu int (*callback)(dev_info_t *, void *, uint_t); 10117*a3114836SGerry Liu void *arg; 10118*a3114836SGerry Liu }; 10119*a3114836SGerry Liu 10120*a3114836SGerry Liu static int 10121*a3114836SGerry Liu visit_dip(dev_info_t *dip, void *arg) 10122*a3114836SGerry Liu { 10123*a3114836SGerry Liu uintptr_t sbusy, dvbusy, ref; 10124*a3114836SGerry Liu struct devi_busy *bsp = arg; 10125*a3114836SGerry Liu 10126*a3114836SGerry Liu ASSERT(bsp->callback); 10127*a3114836SGerry Liu 10128*a3114836SGerry Liu /* 10129*a3114836SGerry Liu * A dip cannot be busy if its reference count is 0 10130*a3114836SGerry Liu */ 10131*a3114836SGerry Liu if ((ref = e_ddi_devi_holdcnt(dip)) == 0) { 10132*a3114836SGerry Liu return (bsp->callback(dip, bsp->arg, 0)); 10133*a3114836SGerry Liu } 10134*a3114836SGerry Liu 10135*a3114836SGerry Liu if (mod_hash_find(bsp->dv_hash, dip, (mod_hash_val_t *)&dvbusy)) 10136*a3114836SGerry Liu dvbusy = 0; 10137*a3114836SGerry Liu 10138*a3114836SGerry Liu /* 10139*a3114836SGerry Liu * To catch device opens currently maintained on specfs common snodes. 10140*a3114836SGerry Liu */ 10141*a3114836SGerry Liu if (mod_hash_find(bsp->s_hash, dip, (mod_hash_val_t *)&sbusy)) 10142*a3114836SGerry Liu sbusy = 0; 10143*a3114836SGerry Liu 10144*a3114836SGerry Liu #ifdef DEBUG 10145*a3114836SGerry Liu if (ref < sbusy || ref < dvbusy) { 10146*a3114836SGerry Liu cmn_err(CE_WARN, "dip(%p): sopen = %lu, dvopen = %lu " 10147*a3114836SGerry Liu "dip ref = %lu\n", (void *)dip, sbusy, dvbusy, ref); 10148*a3114836SGerry Liu } 10149*a3114836SGerry Liu #endif 10150*a3114836SGerry Liu 10151*a3114836SGerry Liu dvbusy = (sbusy > dvbusy) ? sbusy : dvbusy; 10152*a3114836SGerry Liu 10153*a3114836SGerry Liu return (bsp->callback(dip, bsp->arg, dvbusy)); 10154*a3114836SGerry Liu } 10155*a3114836SGerry Liu 10156*a3114836SGerry Liu static int 10157*a3114836SGerry Liu visit_snode(struct snode *sp, void *arg) 10158*a3114836SGerry Liu { 10159*a3114836SGerry Liu uintptr_t sbusy; 10160*a3114836SGerry Liu dev_info_t *dip; 10161*a3114836SGerry Liu int count; 10162*a3114836SGerry Liu struct devi_busy *bsp = arg; 10163*a3114836SGerry Liu 10164*a3114836SGerry Liu ASSERT(sp); 10165*a3114836SGerry Liu 10166*a3114836SGerry Liu /* 10167*a3114836SGerry Liu * The stable lock is held. This prevents 10168*a3114836SGerry Liu * the snode and its associated dip from 10169*a3114836SGerry Liu * going away. 10170*a3114836SGerry Liu */ 10171*a3114836SGerry Liu dip = NULL; 10172*a3114836SGerry Liu count = spec_devi_open_count(sp, &dip); 10173*a3114836SGerry Liu 10174*a3114836SGerry Liu if (count <= 0) 10175*a3114836SGerry Liu return (DDI_WALK_CONTINUE); 10176*a3114836SGerry Liu 10177*a3114836SGerry Liu ASSERT(dip); 10178*a3114836SGerry Liu 10179*a3114836SGerry Liu if (mod_hash_remove(bsp->s_hash, dip, (mod_hash_val_t *)&sbusy)) 10180*a3114836SGerry Liu sbusy = count; 10181*a3114836SGerry Liu else 10182*a3114836SGerry Liu sbusy += count; 10183*a3114836SGerry Liu 10184*a3114836SGerry Liu if (mod_hash_insert(bsp->s_hash, dip, (mod_hash_val_t)sbusy)) { 10185*a3114836SGerry Liu cmn_err(CE_WARN, "%s: s_hash insert failed: dip=0x%p, " 10186*a3114836SGerry Liu "sbusy = %lu", "e_ddi_branch_referenced", 10187*a3114836SGerry Liu (void *)dip, sbusy); 10188*a3114836SGerry Liu } 10189*a3114836SGerry Liu 10190*a3114836SGerry Liu bsp->s_total += count; 10191*a3114836SGerry Liu 10192*a3114836SGerry Liu return (DDI_WALK_CONTINUE); 10193*a3114836SGerry Liu } 10194*a3114836SGerry Liu 10195*a3114836SGerry Liu static void 10196*a3114836SGerry Liu visit_dvnode(struct dv_node *dv, void *arg) 10197*a3114836SGerry Liu { 10198*a3114836SGerry Liu uintptr_t dvbusy; 10199*a3114836SGerry Liu uint_t count; 10200*a3114836SGerry Liu struct vnode *vp; 10201*a3114836SGerry Liu struct devi_busy *bsp = arg; 10202*a3114836SGerry Liu 10203*a3114836SGerry Liu ASSERT(dv && dv->dv_devi); 10204*a3114836SGerry Liu 10205*a3114836SGerry Liu vp = DVTOV(dv); 10206*a3114836SGerry Liu 10207*a3114836SGerry Liu mutex_enter(&vp->v_lock); 10208*a3114836SGerry Liu count = vp->v_count; 10209*a3114836SGerry Liu mutex_exit(&vp->v_lock); 10210*a3114836SGerry Liu 10211*a3114836SGerry Liu if (!count) 10212*a3114836SGerry Liu return; 10213*a3114836SGerry Liu 10214*a3114836SGerry Liu if (mod_hash_remove(bsp->dv_hash, dv->dv_devi, 10215*a3114836SGerry Liu (mod_hash_val_t *)&dvbusy)) 10216*a3114836SGerry Liu dvbusy = count; 10217*a3114836SGerry Liu else 10218*a3114836SGerry Liu dvbusy += count; 10219*a3114836SGerry Liu 10220*a3114836SGerry Liu if (mod_hash_insert(bsp->dv_hash, dv->dv_devi, 10221*a3114836SGerry Liu (mod_hash_val_t)dvbusy)) { 10222*a3114836SGerry Liu cmn_err(CE_WARN, "%s: dv_hash insert failed: dip=0x%p, " 10223*a3114836SGerry Liu "dvbusy=%lu", "e_ddi_branch_referenced", 10224*a3114836SGerry Liu (void *)dv->dv_devi, dvbusy); 10225*a3114836SGerry Liu } 10226*a3114836SGerry Liu 10227*a3114836SGerry Liu bsp->dv_total += count; 10228*a3114836SGerry Liu } 10229*a3114836SGerry Liu 10230*a3114836SGerry Liu /* 10231*a3114836SGerry Liu * Returns reference count on success or -1 on failure. 10232*a3114836SGerry Liu */ 10233*a3114836SGerry Liu int 10234*a3114836SGerry Liu e_ddi_branch_referenced( 10235*a3114836SGerry Liu dev_info_t *rdip, 10236*a3114836SGerry Liu int (*callback)(dev_info_t *dip, void *arg, uint_t ref), 10237*a3114836SGerry Liu void *arg) 10238*a3114836SGerry Liu { 10239*a3114836SGerry Liu int circ; 10240*a3114836SGerry Liu char *path; 10241*a3114836SGerry Liu dev_info_t *pdip; 10242*a3114836SGerry Liu struct devi_busy bsa = {0}; 10243*a3114836SGerry Liu 10244*a3114836SGerry Liu ASSERT(rdip); 10245*a3114836SGerry Liu 10246*a3114836SGerry Liu path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 10247*a3114836SGerry Liu 10248*a3114836SGerry Liu ndi_hold_devi(rdip); 10249*a3114836SGerry Liu 10250*a3114836SGerry Liu pdip = ddi_get_parent(rdip); 10251*a3114836SGerry Liu 10252*a3114836SGerry Liu ASSERT(pdip); 10253*a3114836SGerry Liu 10254*a3114836SGerry Liu /* 10255*a3114836SGerry Liu * Check if caller holds pdip busy - can cause deadlocks during 10256*a3114836SGerry Liu * devfs_walk() 10257*a3114836SGerry Liu */ 10258*a3114836SGerry Liu if (!e_ddi_branch_held(rdip) || DEVI_BUSY_OWNED(pdip)) { 10259*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_referenced: failed: " 10260*a3114836SGerry Liu "devinfo branch(%p) not held or parent busy held", 10261*a3114836SGerry Liu (void *)rdip); 10262*a3114836SGerry Liu ndi_rele_devi(rdip); 10263*a3114836SGerry Liu kmem_free(path, MAXPATHLEN); 10264*a3114836SGerry Liu return (-1); 10265*a3114836SGerry Liu } 10266*a3114836SGerry Liu 10267*a3114836SGerry Liu ndi_devi_enter(pdip, &circ); 10268*a3114836SGerry Liu (void) ddi_pathname(rdip, path); 10269*a3114836SGerry Liu ndi_devi_exit(pdip, circ); 10270*a3114836SGerry Liu 10271*a3114836SGerry Liu bsa.dv_hash = mod_hash_create_ptrhash("dv_node busy hash", NUMCHAINS, 10272*a3114836SGerry Liu mod_hash_null_valdtor, sizeof (struct dev_info)); 10273*a3114836SGerry Liu 10274*a3114836SGerry Liu bsa.s_hash = mod_hash_create_ptrhash("snode busy hash", NUMCHAINS, 10275*a3114836SGerry Liu mod_hash_null_valdtor, sizeof (struct snode)); 10276*a3114836SGerry Liu 10277*a3114836SGerry Liu if (devfs_walk(path, visit_dvnode, &bsa)) { 10278*a3114836SGerry Liu cmn_err(CE_WARN, "e_ddi_branch_referenced: " 10279*a3114836SGerry Liu "devfs walk failed for: %s", path); 10280*a3114836SGerry Liu kmem_free(path, MAXPATHLEN); 10281*a3114836SGerry Liu bsa.s_total = bsa.dv_total = -1; 10282*a3114836SGerry Liu goto out; 10283*a3114836SGerry Liu } 10284*a3114836SGerry Liu 10285*a3114836SGerry Liu kmem_free(path, MAXPATHLEN); 10286*a3114836SGerry Liu 10287*a3114836SGerry Liu /* 10288*a3114836SGerry Liu * Walk the snode table to detect device opens, which are currently 10289*a3114836SGerry Liu * maintained on specfs common snodes. 10290*a3114836SGerry Liu */ 10291*a3114836SGerry Liu spec_snode_walk(visit_snode, &bsa); 10292*a3114836SGerry Liu 10293*a3114836SGerry Liu if (callback == NULL) 10294*a3114836SGerry Liu goto out; 10295*a3114836SGerry Liu 10296*a3114836SGerry Liu bsa.callback = callback; 10297*a3114836SGerry Liu bsa.arg = arg; 10298*a3114836SGerry Liu 10299*a3114836SGerry Liu if (visit_dip(rdip, &bsa) == DDI_WALK_CONTINUE) { 10300*a3114836SGerry Liu ndi_devi_enter(rdip, &circ); 10301*a3114836SGerry Liu ddi_walk_devs(ddi_get_child(rdip), visit_dip, &bsa); 10302*a3114836SGerry Liu ndi_devi_exit(rdip, circ); 10303*a3114836SGerry Liu } 10304*a3114836SGerry Liu 10305*a3114836SGerry Liu out: 10306*a3114836SGerry Liu ndi_rele_devi(rdip); 10307*a3114836SGerry Liu mod_hash_destroy_ptrhash(bsa.s_hash); 10308*a3114836SGerry Liu mod_hash_destroy_ptrhash(bsa.dv_hash); 10309*a3114836SGerry Liu return (bsa.s_total > bsa.dv_total ? bsa.s_total : bsa.dv_total); 10310*a3114836SGerry Liu } 10311