1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2014 Garrett D'Amore <garrett@damore.org>
  25  */
  26 
  27 #include <sys/note.h>
  28 #include <sys/types.h>
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/buf.h>
  32 #include <sys/uio.h>
  33 #include <sys/cred.h>
  34 #include <sys/poll.h>
  35 #include <sys/mman.h>
  36 #include <sys/kmem.h>
  37 #include <sys/model.h>
  38 #include <sys/file.h>
  39 #include <sys/proc.h>
  40 #include <sys/open.h>
  41 #include <sys/user.h>
  42 #include <sys/t_lock.h>
  43 #include <sys/vm.h>
  44 #include <sys/stat.h>
  45 #include <vm/hat.h>
  46 #include <vm/seg.h>
  47 #include <vm/seg_vn.h>
  48 #include <vm/seg_dev.h>
  49 #include <vm/as.h>
  50 #include <sys/cmn_err.h>
  51 #include <sys/cpuvar.h>
  52 #include <sys/debug.h>
  53 #include <sys/autoconf.h>
  54 #include <sys/sunddi.h>
  55 #include <sys/esunddi.h>
  56 #include <sys/sunndi.h>
  57 #include <sys/kstat.h>
  58 #include <sys/conf.h>
  59 #include <sys/ddi_impldefs.h>     /* include implementation structure defs */
  60 #include <sys/ndi_impldefs.h>     /* include prototypes */
  61 #include <sys/ddi_periodic.h>
  62 #include <sys/hwconf.h>
  63 #include <sys/pathname.h>
  64 #include <sys/modctl.h>
  65 #include <sys/epm.h>
  66 #include <sys/devctl.h>
  67 #include <sys/callb.h>
  68 #include <sys/cladm.h>
  69 #include <sys/sysevent.h>
  70 #include <sys/dacf_impl.h>
  71 #include <sys/ddidevmap.h>
  72 #include <sys/bootconf.h>
  73 #include <sys/disp.h>
  74 #include <sys/atomic.h>
  75 #include <sys/promif.h>
  76 #include <sys/instance.h>
  77 #include <sys/sysevent/eventdefs.h>
  78 #include <sys/task.h>
  79 #include <sys/project.h>
  80 #include <sys/taskq.h>
  81 #include <sys/devpolicy.h>
  82 #include <sys/ctype.h>
  83 #include <net/if.h>
  84 #include <sys/rctl.h>
  85 #include <sys/zone.h>
  86 #include <sys/clock_impl.h>
  87 #include <sys/ddi.h>
  88 #include <sys/modhash.h>
  89 #include <sys/sunldi_impl.h>
  90 #include <sys/fs/dv_node.h>
  91 #include <sys/fs/snode.h>
  92 
  93 extern  pri_t   minclsyspri;
  94 
  95 extern  rctl_hndl_t rc_project_locked_mem;
  96 extern  rctl_hndl_t rc_zone_locked_mem;
  97 
  98 #ifdef DEBUG
  99 static int sunddi_debug = 0;
 100 #endif /* DEBUG */
 101 
 102 /* ddi_umem_unlock miscellaneous */
 103 
 104 static  void    i_ddi_umem_unlock_thread_start(void);
 105 
 106 static  kmutex_t        ddi_umem_unlock_mutex; /* unlock list mutex */
 107 static  kcondvar_t      ddi_umem_unlock_cv; /* unlock list block/unblock */
 108 static  kthread_t       *ddi_umem_unlock_thread;
 109 /*
 110  * The ddi_umem_unlock FIFO list.  NULL head pointer indicates empty list.
 111  */
 112 static  struct  ddi_umem_cookie *ddi_umem_unlock_head = NULL;
 113 static  struct  ddi_umem_cookie *ddi_umem_unlock_tail = NULL;
 114 
 115 /*
 116  * DDI(Sun) Function and flag definitions:
 117  */
 118 
 119 #if defined(__x86)
 120 /*
 121  * Used to indicate which entries were chosen from a range.
 122  */
 123 char    *chosen_reg = "chosen-reg";
 124 #endif
 125 
 126 /*
 127  * Function used to ring system console bell
 128  */
 129 void (*ddi_console_bell_func)(clock_t duration);
 130 
 131 /*
 132  * Creating register mappings and handling interrupts:
 133  */
 134 
 135 /*
 136  * Generic ddi_map: Call parent to fulfill request...
 137  */
 138 
 139 int
 140 ddi_map(dev_info_t *dp, ddi_map_req_t *mp, off_t offset,
 141     off_t len, caddr_t *addrp)
 142 {
 143         dev_info_t *pdip;
 144 
 145         ASSERT(dp);
 146         pdip = (dev_info_t *)DEVI(dp)->devi_parent;
 147         return ((DEVI(pdip)->devi_ops->devo_bus_ops->bus_map)(pdip,
 148             dp, mp, offset, len, addrp));
 149 }
 150 
 151 /*
 152  * ddi_apply_range: (Called by nexi only.)
 153  * Apply ranges in parent node dp, to child regspec rp...
 154  */
 155 
 156 int
 157 ddi_apply_range(dev_info_t *dp, dev_info_t *rdip, struct regspec *rp)
 158 {
 159         return (i_ddi_apply_range(dp, rdip, rp));
 160 }
 161 
 162 int
 163 ddi_map_regs(dev_info_t *dip, uint_t rnumber, caddr_t *kaddrp, off_t offset,
 164     off_t len)
 165 {
 166         ddi_map_req_t mr;
 167 #if defined(__x86)
 168         struct {
 169                 int     bus;
 170                 int     addr;
 171                 int     size;
 172         } reg, *reglist;
 173         uint_t  length;
 174         int     rc;
 175 
 176         /*
 177          * get the 'registers' or the 'reg' property.
 178          * We look up the reg property as an array of
 179          * int's.
 180          */
 181         rc = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
 182             DDI_PROP_DONTPASS, "registers", (int **)&reglist, &length);
 183         if (rc != DDI_PROP_SUCCESS)
 184                 rc = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
 185                     DDI_PROP_DONTPASS, "reg", (int **)&reglist, &length);
 186         if (rc == DDI_PROP_SUCCESS) {
 187                 /*
 188                  * point to the required entry.
 189                  */
 190                 reg = reglist[rnumber];
 191                 reg.addr += offset;
 192                 if (len != 0)
 193                         reg.size = len;
 194                 /*
 195                  * make a new property containing ONLY the required tuple.
 196                  */
 197                 if (ddi_prop_update_int_array(DDI_DEV_T_NONE, dip,
 198                     chosen_reg, (int *)&reg, (sizeof (reg)/sizeof (int)))
 199                     != DDI_PROP_SUCCESS) {
 200                         cmn_err(CE_WARN, "%s%d: cannot create '%s' "
 201                             "property", DEVI(dip)->devi_name,
 202                             DEVI(dip)->devi_instance, chosen_reg);
 203                 }
 204                 /*
 205                  * free the memory allocated by
 206                  * ddi_prop_lookup_int_array ().
 207                  */
 208                 ddi_prop_free((void *)reglist);
 209         }
 210 #endif
 211         mr.map_op = DDI_MO_MAP_LOCKED;
 212         mr.map_type = DDI_MT_RNUMBER;
 213         mr.map_obj.rnumber = rnumber;
 214         mr.map_prot = PROT_READ | PROT_WRITE;
 215         mr.map_flags = DDI_MF_KERNEL_MAPPING;
 216         mr.map_handlep = NULL;
 217         mr.map_vers = DDI_MAP_VERSION;
 218 
 219         /*
 220          * Call my parent to map in my regs.
 221          */
 222 
 223         return (ddi_map(dip, &mr, offset, len, kaddrp));
 224 }
 225 
 226 void
 227 ddi_unmap_regs(dev_info_t *dip, uint_t rnumber, caddr_t *kaddrp, off_t offset,
 228     off_t len)
 229 {
 230         ddi_map_req_t mr;
 231 
 232         mr.map_op = DDI_MO_UNMAP;
 233         mr.map_type = DDI_MT_RNUMBER;
 234         mr.map_flags = DDI_MF_KERNEL_MAPPING;
 235         mr.map_prot = PROT_READ | PROT_WRITE;   /* who cares? */
 236         mr.map_obj.rnumber = rnumber;
 237         mr.map_handlep = NULL;
 238         mr.map_vers = DDI_MAP_VERSION;
 239 
 240         /*
 241          * Call my parent to unmap my regs.
 242          */
 243 
 244         (void) ddi_map(dip, &mr, offset, len, kaddrp);
 245         *kaddrp = (caddr_t)0;
 246 #if defined(__x86)
 247         (void) ddi_prop_remove(DDI_DEV_T_NONE, dip, chosen_reg);
 248 #endif
 249 }
 250 
 251 int
 252 ddi_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
 253         off_t offset, off_t len, caddr_t *vaddrp)
 254 {
 255         return (i_ddi_bus_map(dip, rdip, mp, offset, len, vaddrp));
 256 }
 257 
 258 /*
 259  * nullbusmap:  The/DDI default bus_map entry point for nexi
 260  *              not conforming to the reg/range paradigm (i.e. scsi, etc.)
 261  *              with no HAT/MMU layer to be programmed at this level.
 262  *
 263  *              If the call is to map by rnumber, return an error,
 264  *              otherwise pass anything else up the tree to my parent.
 265  */
 266 int
 267 nullbusmap(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
 268         off_t offset, off_t len, caddr_t *vaddrp)
 269 {
 270         _NOTE(ARGUNUSED(rdip))
 271         if (mp->map_type == DDI_MT_RNUMBER)
 272                 return (DDI_ME_UNSUPPORTED);
 273 
 274         return (ddi_map(dip, mp, offset, len, vaddrp));
 275 }
 276 
 277 /*
 278  * ddi_rnumber_to_regspec: Not for use by leaf drivers.
 279  *                         Only for use by nexi using the reg/range paradigm.
 280  */
 281 struct regspec *
 282 ddi_rnumber_to_regspec(dev_info_t *dip, int rnumber)
 283 {
 284         return (i_ddi_rnumber_to_regspec(dip, rnumber));
 285 }
 286 
 287 
 288 /*
 289  * Note that we allow the dip to be nil because we may be called
 290  * prior even to the instantiation of the devinfo tree itself - all
 291  * regular leaf and nexus drivers should always use a non-nil dip!
 292  *
 293  * We treat peek in a somewhat cavalier fashion .. assuming that we'll
 294  * simply get a synchronous fault as soon as we touch a missing address.
 295  *
 296  * Poke is rather more carefully handled because we might poke to a write
 297  * buffer, "succeed", then only find some time later that we got an
 298  * asynchronous fault that indicated that the address we were writing to
 299  * was not really backed by hardware.
 300  */
 301 
 302 static int
 303 i_ddi_peekpoke(dev_info_t *devi, ddi_ctl_enum_t cmd, size_t size,
 304     void *addr, void *value_p)
 305 {
 306         union {
 307                 uint64_t        u64;
 308                 uint32_t        u32;
 309                 uint16_t        u16;
 310                 uint8_t         u8;
 311         } peekpoke_value;
 312 
 313         peekpoke_ctlops_t peekpoke_args;
 314         uint64_t dummy_result;
 315         int rval;
 316 
 317         /* Note: size is assumed to be correct;  it is not checked. */
 318         peekpoke_args.size = size;
 319         peekpoke_args.dev_addr = (uintptr_t)addr;
 320         peekpoke_args.handle = NULL;
 321         peekpoke_args.repcount = 1;
 322         peekpoke_args.flags = 0;
 323 
 324         if (cmd == DDI_CTLOPS_POKE) {
 325                 switch (size) {
 326                 case sizeof (uint8_t):
 327                         peekpoke_value.u8 = *(uint8_t *)value_p;
 328                         break;
 329                 case sizeof (uint16_t):
 330                         peekpoke_value.u16 = *(uint16_t *)value_p;
 331                         break;
 332                 case sizeof (uint32_t):
 333                         peekpoke_value.u32 = *(uint32_t *)value_p;
 334                         break;
 335                 case sizeof (uint64_t):
 336                         peekpoke_value.u64 = *(uint64_t *)value_p;
 337                         break;
 338                 }
 339         }
 340 
 341         peekpoke_args.host_addr = (uintptr_t)&peekpoke_value.u64;
 342 
 343         if (devi != NULL)
 344                 rval = ddi_ctlops(devi, devi, cmd, &peekpoke_args,
 345                     &dummy_result);
 346         else
 347                 rval = peekpoke_mem(cmd, &peekpoke_args);
 348 
 349         /*
 350          * A NULL value_p is permitted by ddi_peek(9F); discard the result.
 351          */
 352         if ((cmd == DDI_CTLOPS_PEEK) & (value_p != NULL)) {
 353                 switch (size) {
 354                 case sizeof (uint8_t):
 355                         *(uint8_t *)value_p = peekpoke_value.u8;
 356                         break;
 357                 case sizeof (uint16_t):
 358                         *(uint16_t *)value_p = peekpoke_value.u16;
 359                         break;
 360                 case sizeof (uint32_t):
 361                         *(uint32_t *)value_p = peekpoke_value.u32;
 362                         break;
 363                 case sizeof (uint64_t):
 364                         *(uint64_t *)value_p = peekpoke_value.u64;
 365                         break;
 366                 }
 367         }
 368 
 369         return (rval);
 370 }
 371 
 372 /*
 373  * Keep ddi_peek() and ddi_poke() in case 3rd parties are calling this.
 374  * they shouldn't be, but the 9f manpage kind of pseudo exposes it.
 375  */
 376 int
 377 ddi_peek(dev_info_t *devi, size_t size, void *addr, void *value_p)
 378 {
 379         switch (size) {
 380         case sizeof (uint8_t):
 381         case sizeof (uint16_t):
 382         case sizeof (uint32_t):
 383         case sizeof (uint64_t):
 384                 break;
 385         default:
 386                 return (DDI_FAILURE);
 387         }
 388 
 389         return (i_ddi_peekpoke(devi, DDI_CTLOPS_PEEK, size, addr, value_p));
 390 }
 391 
 392 int
 393 ddi_poke(dev_info_t *devi, size_t size, void *addr, void *value_p)
 394 {
 395         switch (size) {
 396         case sizeof (uint8_t):
 397         case sizeof (uint16_t):
 398         case sizeof (uint32_t):
 399         case sizeof (uint64_t):
 400                 break;
 401         default:
 402                 return (DDI_FAILURE);
 403         }
 404 
 405         return (i_ddi_peekpoke(devi, DDI_CTLOPS_POKE, size, addr, value_p));
 406 }
 407 
 408 int
 409 ddi_peek8(dev_info_t *dip, int8_t *addr, int8_t *val_p)
 410 {
 411         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 412             val_p));
 413 }
 414 
 415 int
 416 ddi_peek16(dev_info_t *dip, int16_t *addr, int16_t *val_p)
 417 {
 418         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 419             val_p));
 420 }
 421 
 422 int
 423 ddi_peek32(dev_info_t *dip, int32_t *addr, int32_t *val_p)
 424 {
 425         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 426             val_p));
 427 }
 428 
 429 int
 430 ddi_peek64(dev_info_t *dip, int64_t *addr, int64_t *val_p)
 431 {
 432         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 433             val_p));
 434 }
 435 
 436 
 437 /*
 438  * We need to separate the old interfaces from the new ones and leave them
 439  * in here for a while. Previous versions of the OS defined the new interfaces
 440  * to the old interfaces. This way we can fix things up so that we can
 441  * eventually remove these interfaces.
 442  * e.g. A 3rd party module/driver using ddi_peek8 and built against S10
 443  * or earlier will actually have a reference to ddi_peekc in the binary.
 444  */
 445 #ifdef _ILP32
 446 int
 447 ddi_peekc(dev_info_t *dip, int8_t *addr, int8_t *val_p)
 448 {
 449         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 450             val_p));
 451 }
 452 
 453 int
 454 ddi_peeks(dev_info_t *dip, int16_t *addr, int16_t *val_p)
 455 {
 456         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 457             val_p));
 458 }
 459 
 460 int
 461 ddi_peekl(dev_info_t *dip, int32_t *addr, int32_t *val_p)
 462 {
 463         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 464             val_p));
 465 }
 466 
 467 int
 468 ddi_peekd(dev_info_t *dip, int64_t *addr, int64_t *val_p)
 469 {
 470         return (i_ddi_peekpoke(dip, DDI_CTLOPS_PEEK, sizeof (*val_p), addr,
 471             val_p));
 472 }
 473 #endif /* _ILP32 */
 474 
 475 int
 476 ddi_poke8(dev_info_t *dip, int8_t *addr, int8_t val)
 477 {
 478         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 479 }
 480 
 481 int
 482 ddi_poke16(dev_info_t *dip, int16_t *addr, int16_t val)
 483 {
 484         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 485 }
 486 
 487 int
 488 ddi_poke32(dev_info_t *dip, int32_t *addr, int32_t val)
 489 {
 490         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 491 }
 492 
 493 int
 494 ddi_poke64(dev_info_t *dip, int64_t *addr, int64_t val)
 495 {
 496         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 497 }
 498 
 499 /*
 500  * We need to separate the old interfaces from the new ones and leave them
 501  * in here for a while. Previous versions of the OS defined the new interfaces
 502  * to the old interfaces. This way we can fix things up so that we can
 503  * eventually remove these interfaces.
 504  * e.g. A 3rd party module/driver using ddi_poke8 and built against S10
 505  * or earlier will actually have a reference to ddi_pokec in the binary.
 506  */
 507 #ifdef _ILP32
 508 int
 509 ddi_pokec(dev_info_t *dip, int8_t *addr, int8_t val)
 510 {
 511         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 512 }
 513 
 514 int
 515 ddi_pokes(dev_info_t *dip, int16_t *addr, int16_t val)
 516 {
 517         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 518 }
 519 
 520 int
 521 ddi_pokel(dev_info_t *dip, int32_t *addr, int32_t val)
 522 {
 523         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 524 }
 525 
 526 int
 527 ddi_poked(dev_info_t *dip, int64_t *addr, int64_t val)
 528 {
 529         return (i_ddi_peekpoke(dip, DDI_CTLOPS_POKE, sizeof (val), addr, &val));
 530 }
 531 #endif /* _ILP32 */
 532 
 533 /*
 534  * ddi_peekpokeio() is used primarily by the mem drivers for moving
 535  * data to and from uio structures via peek and poke.  Note that we
 536  * use "internal" routines ddi_peek and ddi_poke to make this go
 537  * slightly faster, avoiding the call overhead ..
 538  */
 539 int
 540 ddi_peekpokeio(dev_info_t *devi, struct uio *uio, enum uio_rw rw,
 541     caddr_t addr, size_t len, uint_t xfersize)
 542 {
 543         int64_t ibuffer;
 544         int8_t w8;
 545         size_t sz;
 546         int o;
 547 
 548         if (xfersize > sizeof (long))
 549                 xfersize = sizeof (long);
 550 
 551         while (len != 0) {
 552                 if ((len | (uintptr_t)addr) & 1) {
 553                         sz = sizeof (int8_t);
 554                         if (rw == UIO_WRITE) {
 555                                 if ((o = uwritec(uio)) == -1)
 556                                         return (DDI_FAILURE);
 557                                 if (ddi_poke8(devi, (int8_t *)addr,
 558                                     (int8_t)o) != DDI_SUCCESS)
 559                                         return (DDI_FAILURE);
 560                         } else {
 561                                 if (i_ddi_peekpoke(devi, DDI_CTLOPS_PEEK, sz,
 562                                     (int8_t *)addr, &w8) != DDI_SUCCESS)
 563                                         return (DDI_FAILURE);
 564                                 if (ureadc(w8, uio))
 565                                         return (DDI_FAILURE);
 566                         }
 567                 } else {
 568                         switch (xfersize) {
 569                         case sizeof (int64_t):
 570                                 if (((len | (uintptr_t)addr) &
 571                                     (sizeof (int64_t) - 1)) == 0) {
 572                                         sz = xfersize;
 573                                         break;
 574                                 }
 575                                 /*FALLTHROUGH*/
 576                         case sizeof (int32_t):
 577                                 if (((len | (uintptr_t)addr) &
 578                                     (sizeof (int32_t) - 1)) == 0) {
 579                                         sz = xfersize;
 580                                         break;
 581                                 }
 582                                 /*FALLTHROUGH*/
 583                         default:
 584                                 /*
 585                                  * This still assumes that we might have an
 586                                  * I/O bus out there that permits 16-bit
 587                                  * transfers (and that it would be upset by
 588                                  * 32-bit transfers from such locations).
 589                                  */
 590                                 sz = sizeof (int16_t);
 591                                 break;
 592                         }
 593 
 594                         if (rw == UIO_READ) {
 595                                 if (i_ddi_peekpoke(devi, DDI_CTLOPS_PEEK, sz,
 596                                     addr, &ibuffer) != DDI_SUCCESS)
 597                                         return (DDI_FAILURE);
 598                         }
 599 
 600                         if (uiomove(&ibuffer, sz, rw, uio))
 601                                 return (DDI_FAILURE);
 602 
 603                         if (rw == UIO_WRITE) {
 604                                 if (i_ddi_peekpoke(devi, DDI_CTLOPS_POKE, sz,
 605                                     addr, &ibuffer) != DDI_SUCCESS)
 606                                         return (DDI_FAILURE);
 607                         }
 608                 }
 609                 addr += sz;
 610                 len -= sz;
 611         }
 612         return (DDI_SUCCESS);
 613 }
 614 
 615 /*
 616  * These routines are used by drivers that do layered ioctls
 617  * On sparc, they're implemented in assembler to avoid spilling
 618  * register windows in the common (copyin) case ..
 619  */
 620 #if !defined(__sparc)
 621 int
 622 ddi_copyin(const void *buf, void *kernbuf, size_t size, int flags)
 623 {
 624         if (flags & FKIOCTL)
 625                 return (kcopy(buf, kernbuf, size) ? -1 : 0);
 626         return (copyin(buf, kernbuf, size));
 627 }
 628 
 629 int
 630 ddi_copyout(const void *buf, void *kernbuf, size_t size, int flags)
 631 {
 632         if (flags & FKIOCTL)
 633                 return (kcopy(buf, kernbuf, size) ? -1 : 0);
 634         return (copyout(buf, kernbuf, size));
 635 }
 636 #endif  /* !__sparc */
 637 
 638 /*
 639  * Conversions in nexus pagesize units.  We don't duplicate the
 640  * 'nil dip' semantics of peek/poke because btopr/btop/ptob are DDI/DKI
 641  * routines anyway.
 642  */
 643 unsigned long
 644 ddi_btop(dev_info_t *dip, unsigned long bytes)
 645 {
 646         unsigned long pages;
 647 
 648         (void) ddi_ctlops(dip, dip, DDI_CTLOPS_BTOP, &bytes, &pages);
 649         return (pages);
 650 }
 651 
 652 unsigned long
 653 ddi_btopr(dev_info_t *dip, unsigned long bytes)
 654 {
 655         unsigned long pages;
 656 
 657         (void) ddi_ctlops(dip, dip, DDI_CTLOPS_BTOPR, &bytes, &pages);
 658         return (pages);
 659 }
 660 
 661 unsigned long
 662 ddi_ptob(dev_info_t *dip, unsigned long pages)
 663 {
 664         unsigned long bytes;
 665 
 666         (void) ddi_ctlops(dip, dip, DDI_CTLOPS_PTOB, &pages, &bytes);
 667         return (bytes);
 668 }
 669 
 670 unsigned int
 671 ddi_enter_critical(void)
 672 {
 673         return ((uint_t)spl7());
 674 }
 675 
 676 void
 677 ddi_exit_critical(unsigned int spl)
 678 {
 679         splx((int)spl);
 680 }
 681 
 682 /*
 683  * Nexus ctlops punter
 684  */
 685 
 686 #if !defined(__sparc)
 687 /*
 688  * Request bus_ctl parent to handle a bus_ctl request
 689  *
 690  * (The sparc version is in sparc_ddi.s)
 691  */
 692 int
 693 ddi_ctlops(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t op, void *a, void *v)
 694 {
 695         int (*fp)();
 696 
 697         if (!d || !r)
 698                 return (DDI_FAILURE);
 699 
 700         if ((d = (dev_info_t *)DEVI(d)->devi_bus_ctl) == NULL)
 701                 return (DDI_FAILURE);
 702 
 703         fp = DEVI(d)->devi_ops->devo_bus_ops->bus_ctl;
 704         return ((*fp)(d, r, op, a, v));
 705 }
 706 
 707 #endif
 708 
 709 /*
 710  * DMA/DVMA setup
 711  */
 712 
 713 #if !defined(__sparc)
 714 /*
 715  * Request bus_dma_ctl parent to fiddle with a dma request.
 716  *
 717  * (The sparc version is in sparc_subr.s)
 718  */
 719 int
 720 ddi_dma_mctl(dev_info_t *dip, dev_info_t *rdip,
 721     ddi_dma_handle_t handle, enum ddi_dma_ctlops request,
 722     off_t *offp, size_t *lenp, caddr_t *objp, uint_t flags)
 723 {
 724         int (*fp)();
 725 
 726         if (dip != ddi_root_node())
 727                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_ctl;
 728         fp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_ctl;
 729         return ((*fp) (dip, rdip, handle, request, offp, lenp, objp, flags));
 730 }
 731 #endif
 732 
 733 /*
 734  * For all DMA control functions, call the DMA control
 735  * routine and return status.
 736  *
 737  * Just plain assume that the parent is to be called.
 738  * If a nexus driver or a thread outside the framework
 739  * of a nexus driver or a leaf driver calls these functions,
 740  * it is up to them to deal with the fact that the parent's
 741  * bus_dma_ctl function will be the first one called.
 742  */
 743 
 744 #define HD      ((ddi_dma_impl_t *)h)->dmai_rdip
 745 
 746 /*
 747  * This routine is left in place to satisfy link dependencies
 748  * for any 3rd party nexus drivers that rely on it.  It is never
 749  * called, though.
 750  */
 751 /*ARGSUSED*/
 752 int
 753 ddi_dma_map(dev_info_t *dip, dev_info_t *rdip,
 754     struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep)
 755 {
 756         return (DDI_FAILURE);
 757 }
 758 
 759 #if !defined(__sparc)
 760 
 761 /*
 762  * The SPARC versions of these routines are done in assembler to
 763  * save register windows, so they're in sparc_subr.s.
 764  */
 765 
 766 int
 767 ddi_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
 768     int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep)
 769 {
 770         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_attr_t *,
 771             int (*)(caddr_t), caddr_t, ddi_dma_handle_t *);
 772 
 773         if (dip != ddi_root_node())
 774                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_allochdl;
 775 
 776         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_allochdl;
 777         return ((*funcp)(dip, rdip, attr, waitfp, arg, handlep));
 778 }
 779 
 780 int
 781 ddi_dma_freehdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_handle_t handlep)
 782 {
 783         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t);
 784 
 785         if (dip != ddi_root_node())
 786                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_allochdl;
 787 
 788         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_freehdl;
 789         return ((*funcp)(dip, rdip, handlep));
 790 }
 791 
 792 int
 793 ddi_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
 794     ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
 795     ddi_dma_cookie_t *cp, uint_t *ccountp)
 796 {
 797         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t,
 798             struct ddi_dma_req *, ddi_dma_cookie_t *, uint_t *);
 799 
 800         if (dip != ddi_root_node())
 801                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl;
 802 
 803         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_bindhdl;
 804         return ((*funcp)(dip, rdip, handle, dmareq, cp, ccountp));
 805 }
 806 
 807 int
 808 ddi_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
 809     ddi_dma_handle_t handle)
 810 {
 811         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t);
 812 
 813         if (dip != ddi_root_node())
 814                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_unbindhdl;
 815 
 816         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_unbindhdl;
 817         return ((*funcp)(dip, rdip, handle));
 818 }
 819 
 820 
 821 int
 822 ddi_dma_flush(dev_info_t *dip, dev_info_t *rdip,
 823     ddi_dma_handle_t handle, off_t off, size_t len,
 824     uint_t cache_flags)
 825 {
 826         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t,
 827             off_t, size_t, uint_t);
 828 
 829         if (dip != ddi_root_node())
 830                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_flush;
 831 
 832         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_flush;
 833         return ((*funcp)(dip, rdip, handle, off, len, cache_flags));
 834 }
 835 
 836 int
 837 ddi_dma_win(dev_info_t *dip, dev_info_t *rdip,
 838     ddi_dma_handle_t handle, uint_t win, off_t *offp,
 839     size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp)
 840 {
 841         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t,
 842             uint_t, off_t *, size_t *, ddi_dma_cookie_t *, uint_t *);
 843 
 844         if (dip != ddi_root_node())
 845                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_win;
 846 
 847         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_win;
 848         return ((*funcp)(dip, rdip, handle, win, offp, lenp,
 849             cookiep, ccountp));
 850 }
 851 
 852 int
 853 ddi_dma_sync(ddi_dma_handle_t h, off_t o, size_t l, uint_t whom)
 854 {
 855         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)h;
 856         dev_info_t *dip, *rdip;
 857         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t, off_t,
 858             size_t, uint_t);
 859 
 860         /*
 861          * the DMA nexus driver will set DMP_NOSYNC if the
 862          * platform does not require any sync operation. For
 863          * example if the memory is uncached or consistent
 864          * and without any I/O write buffers involved.
 865          */
 866         if ((hp->dmai_rflags & DMP_NOSYNC) == DMP_NOSYNC)
 867                 return (DDI_SUCCESS);
 868 
 869         dip = rdip = hp->dmai_rdip;
 870         if (dip != ddi_root_node())
 871                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_flush;
 872         funcp = DEVI(dip)->devi_ops->devo_bus_ops->bus_dma_flush;
 873         return ((*funcp)(dip, rdip, h, o, l, whom));
 874 }
 875 
 876 int
 877 ddi_dma_unbind_handle(ddi_dma_handle_t h)
 878 {
 879         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)h;
 880         dev_info_t *dip, *rdip;
 881         int (*funcp)(dev_info_t *, dev_info_t *, ddi_dma_handle_t);
 882 
 883         dip = rdip = hp->dmai_rdip;
 884         if (dip != ddi_root_node())
 885                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_unbindhdl;
 886         funcp = DEVI(rdip)->devi_bus_dma_unbindfunc;
 887         return ((*funcp)(dip, rdip, h));
 888 }
 889 
 890 #endif  /* !__sparc */
 891 
 892 /*
 893  * DMA burst sizes, and transfer minimums
 894  */
 895 
 896 int
 897 ddi_dma_burstsizes(ddi_dma_handle_t handle)
 898 {
 899         ddi_dma_impl_t *dimp = (ddi_dma_impl_t *)handle;
 900 
 901         if (!dimp)
 902                 return (0);
 903         else
 904                 return (dimp->dmai_burstsizes);
 905 }
 906 
 907 /*
 908  * Given two DMA attribute structures, apply the attributes
 909  * of one to the other, following the rules of attributes
 910  * and the wishes of the caller.
 911  *
 912  * The rules of DMA attribute structures are that you cannot
 913  * make things *less* restrictive as you apply one set
 914  * of attributes to another.
 915  *
 916  */
 917 void
 918 ddi_dma_attr_merge(ddi_dma_attr_t *attr, ddi_dma_attr_t *mod)
 919 {
 920         attr->dma_attr_addr_lo =
 921             MAX(attr->dma_attr_addr_lo, mod->dma_attr_addr_lo);
 922         attr->dma_attr_addr_hi =
 923             MIN(attr->dma_attr_addr_hi, mod->dma_attr_addr_hi);
 924         attr->dma_attr_count_max =
 925             MIN(attr->dma_attr_count_max, mod->dma_attr_count_max);
 926         attr->dma_attr_align =
 927             MAX(attr->dma_attr_align,  mod->dma_attr_align);
 928         attr->dma_attr_burstsizes =
 929             (uint_t)(attr->dma_attr_burstsizes & mod->dma_attr_burstsizes);
 930         attr->dma_attr_minxfer =
 931             maxbit(attr->dma_attr_minxfer, mod->dma_attr_minxfer);
 932         attr->dma_attr_maxxfer =
 933             MIN(attr->dma_attr_maxxfer, mod->dma_attr_maxxfer);
 934         attr->dma_attr_seg = MIN(attr->dma_attr_seg, mod->dma_attr_seg);
 935         attr->dma_attr_sgllen = MIN((uint_t)attr->dma_attr_sgllen,
 936             (uint_t)mod->dma_attr_sgllen);
 937         attr->dma_attr_granular =
 938             MAX(attr->dma_attr_granular, mod->dma_attr_granular);
 939 }
 940 
 941 /*
 942  * mmap/segmap interface:
 943  */
 944 
 945 /*
 946  * ddi_segmap:          setup the default segment driver. Calls the drivers
 947  *                      XXmmap routine to validate the range to be mapped.
 948  *                      Return ENXIO of the range is not valid.  Create
 949  *                      a seg_dev segment that contains all of the
 950  *                      necessary information and will reference the
 951  *                      default segment driver routines. It returns zero
 952  *                      on success or non-zero on failure.
 953  */
 954 int
 955 ddi_segmap(dev_t dev, off_t offset, struct as *asp, caddr_t *addrp, off_t len,
 956     uint_t prot, uint_t maxprot, uint_t flags, cred_t *credp)
 957 {
 958         extern int spec_segmap(dev_t, off_t, struct as *, caddr_t *,
 959             off_t, uint_t, uint_t, uint_t, struct cred *);
 960 
 961         return (spec_segmap(dev, offset, asp, addrp, len,
 962             prot, maxprot, flags, credp));
 963 }
 964 
 965 /*
 966  * ddi_map_fault:       Resolve mappings at fault time.  Used by segment
 967  *                      drivers. Allows each successive parent to resolve
 968  *                      address translations and add its mappings to the
 969  *                      mapping list supplied in the page structure. It
 970  *                      returns zero on success or non-zero on failure.
 971  */
 972 
 973 int
 974 ddi_map_fault(dev_info_t *dip, struct hat *hat, struct seg *seg,
 975     caddr_t addr, struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock)
 976 {
 977         return (i_ddi_map_fault(dip, dip, hat, seg, addr, dp, pfn, prot, lock));
 978 }
 979 
 980 /*
 981  * ddi_device_mapping_check:    Called from ddi_segmap_setup.
 982  *      Invokes platform specific DDI to determine whether attributes specified
 983  *      in attr(9s) are valid for the region of memory that will be made
 984  *      available for direct access to user process via the mmap(2) system call.
 985  */
 986 int
 987 ddi_device_mapping_check(dev_t dev, ddi_device_acc_attr_t *accattrp,
 988     uint_t rnumber, uint_t *hat_flags)
 989 {
 990         ddi_acc_handle_t handle;
 991         ddi_map_req_t mr;
 992         ddi_acc_hdl_t *hp;
 993         int result;
 994         dev_info_t *dip;
 995 
 996         /*
 997          * we use e_ddi_hold_devi_by_dev to search for the devi.  We
 998          * release it immediately since it should already be held by
 999          * a devfs vnode.
1000          */
1001         if ((dip =
1002             e_ddi_hold_devi_by_dev(dev, E_DDI_HOLD_DEVI_NOATTACH)) == NULL)
1003                 return (-1);
1004         ddi_release_devi(dip);          /* for e_ddi_hold_devi_by_dev() */
1005 
1006         /*
1007          * Allocate and initialize the common elements of data
1008          * access handle.
1009          */
1010         handle = impl_acc_hdl_alloc(KM_SLEEP, NULL);
1011         if (handle == NULL)
1012                 return (-1);
1013 
1014         hp = impl_acc_hdl_get(handle);
1015         hp->ah_vers = VERS_ACCHDL;
1016         hp->ah_dip = dip;
1017         hp->ah_rnumber = rnumber;
1018         hp->ah_offset = 0;
1019         hp->ah_len = 0;
1020         hp->ah_acc = *accattrp;
1021 
1022         /*
1023          * Set up the mapping request and call to parent.
1024          */
1025         mr.map_op = DDI_MO_MAP_HANDLE;
1026         mr.map_type = DDI_MT_RNUMBER;
1027         mr.map_obj.rnumber = rnumber;
1028         mr.map_prot = PROT_READ | PROT_WRITE;
1029         mr.map_flags = DDI_MF_KERNEL_MAPPING;
1030         mr.map_handlep = hp;
1031         mr.map_vers = DDI_MAP_VERSION;
1032         result = ddi_map(dip, &mr, 0, 0, NULL);
1033 
1034         /*
1035          * Region must be mappable, pick up flags from the framework.
1036          */
1037         *hat_flags = hp->ah_hat_flags;
1038 
1039         impl_acc_hdl_free(handle);
1040 
1041         /*
1042          * check for end result.
1043          */
1044         if (result != DDI_SUCCESS)
1045                 return (-1);
1046         return (0);
1047 }
1048 
1049 
1050 /*
1051  * Property functions:   See also, ddipropdefs.h.
1052  *
1053  * These functions are the framework for the property functions,
1054  * i.e. they support software defined properties.  All implementation
1055  * specific property handling (i.e.: self-identifying devices and
1056  * PROM defined properties are handled in the implementation specific
1057  * functions (defined in ddi_implfuncs.h).
1058  */
1059 
1060 /*
1061  * nopropop:    Shouldn't be called, right?
1062  */
1063 int
1064 nopropop(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
1065     char *name, caddr_t valuep, int *lengthp)
1066 {
1067         _NOTE(ARGUNUSED(dev, dip, prop_op, mod_flags, name, valuep, lengthp))
1068         return (DDI_PROP_NOT_FOUND);
1069 }
1070 
1071 #ifdef  DDI_PROP_DEBUG
1072 int ddi_prop_debug_flag = 0;
1073 
1074 int
1075 ddi_prop_debug(int enable)
1076 {
1077         int prev = ddi_prop_debug_flag;
1078 
1079         if ((enable != 0) || (prev != 0))
1080                 printf("ddi_prop_debug: debugging %s\n",
1081                     enable ? "enabled" : "disabled");
1082         ddi_prop_debug_flag = enable;
1083         return (prev);
1084 }
1085 
1086 #endif  /* DDI_PROP_DEBUG */
1087 
1088 /*
1089  * Search a property list for a match, if found return pointer
1090  * to matching prop struct, else return NULL.
1091  */
1092 
1093 ddi_prop_t *
1094 i_ddi_prop_search(dev_t dev, char *name, uint_t flags, ddi_prop_t **list_head)
1095 {
1096         ddi_prop_t      *propp;
1097 
1098         /*
1099          * find the property in child's devinfo:
1100          * Search order defined by this search function is first matching
1101          * property with input dev == DDI_DEV_T_ANY matching any dev or
1102          * dev == propp->prop_dev, name == propp->name, and the correct
1103          * data type as specified in the flags.  If a DDI_DEV_T_NONE dev
1104          * value made it this far then it implies a DDI_DEV_T_ANY search.
1105          */
1106         if (dev == DDI_DEV_T_NONE)
1107                 dev = DDI_DEV_T_ANY;
1108 
1109         for (propp = *list_head; propp != NULL; propp = propp->prop_next)  {
1110 
1111                 if (!DDI_STRSAME(propp->prop_name, name))
1112                         continue;
1113 
1114                 if ((dev != DDI_DEV_T_ANY) && (propp->prop_dev != dev))
1115                         continue;
1116 
1117                 if (((propp->prop_flags & flags) & DDI_PROP_TYPE_MASK) == 0)
1118                         continue;
1119 
1120                 return (propp);
1121         }
1122 
1123         return ((ddi_prop_t *)0);
1124 }
1125 
1126 /*
1127  * Search for property within devnames structures
1128  */
1129 ddi_prop_t *
1130 i_ddi_search_global_prop(dev_t dev, char *name, uint_t flags)
1131 {
1132         major_t         major;
1133         struct devnames *dnp;
1134         ddi_prop_t      *propp;
1135 
1136         /*
1137          * Valid dev_t value is needed to index into the
1138          * correct devnames entry, therefore a dev_t
1139          * value of DDI_DEV_T_ANY is not appropriate.
1140          */
1141         ASSERT(dev != DDI_DEV_T_ANY);
1142         if (dev == DDI_DEV_T_ANY) {
1143                 return ((ddi_prop_t *)0);
1144         }
1145 
1146         major = getmajor(dev);
1147         dnp = &(devnamesp[major]);
1148 
1149         if (dnp->dn_global_prop_ptr == NULL)
1150                 return ((ddi_prop_t *)0);
1151 
1152         LOCK_DEV_OPS(&dnp->dn_lock);
1153 
1154         for (propp = dnp->dn_global_prop_ptr->prop_list;
1155             propp != NULL;
1156             propp = (ddi_prop_t *)propp->prop_next) {
1157 
1158                 if (!DDI_STRSAME(propp->prop_name, name))
1159                         continue;
1160 
1161                 if ((!(flags & DDI_PROP_ROOTNEX_GLOBAL)) &&
1162                     (!(flags & LDI_DEV_T_ANY)) && (propp->prop_dev != dev))
1163                         continue;
1164 
1165                 if (((propp->prop_flags & flags) & DDI_PROP_TYPE_MASK) == 0)
1166                         continue;
1167 
1168                 /* Property found, return it */
1169                 UNLOCK_DEV_OPS(&dnp->dn_lock);
1170                 return (propp);
1171         }
1172 
1173         UNLOCK_DEV_OPS(&dnp->dn_lock);
1174         return ((ddi_prop_t *)0);
1175 }
1176 
1177 static char prop_no_mem_msg[] = "can't allocate memory for ddi property <%s>";
1178 
1179 /*
1180  * ddi_prop_search_global:
1181  *      Search the global property list within devnames
1182  *      for the named property.  Return the encoded value.
1183  */
1184 static int
1185 i_ddi_prop_search_global(dev_t dev, uint_t flags, char *name,
1186     void *valuep, uint_t *lengthp)
1187 {
1188         ddi_prop_t      *propp;
1189         caddr_t         buffer;
1190 
1191         propp =  i_ddi_search_global_prop(dev, name, flags);
1192 
1193         /* Property NOT found, bail */
1194         if (propp == (ddi_prop_t *)0)
1195                 return (DDI_PROP_NOT_FOUND);
1196 
1197         if (propp->prop_flags & DDI_PROP_UNDEF_IT)
1198                 return (DDI_PROP_UNDEFINED);
1199 
1200         if ((buffer = kmem_alloc(propp->prop_len,
1201             (flags & DDI_PROP_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP)) == NULL) {
1202                 cmn_err(CE_CONT, prop_no_mem_msg, name);
1203                 return (DDI_PROP_NO_MEMORY);
1204         }
1205 
1206         /*
1207          * Return the encoded data
1208          */
1209         *(caddr_t *)valuep = buffer;
1210         *lengthp = propp->prop_len;
1211         bcopy(propp->prop_val, buffer, propp->prop_len);
1212 
1213         return (DDI_PROP_SUCCESS);
1214 }
1215 
1216 /*
1217  * ddi_prop_search_common:      Lookup and return the encoded value
1218  */
1219 int
1220 ddi_prop_search_common(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1221     uint_t flags, char *name, void *valuep, uint_t *lengthp)
1222 {
1223         ddi_prop_t      *propp;
1224         int             i;
1225         caddr_t         buffer;
1226         caddr_t         prealloc = NULL;
1227         int             plength = 0;
1228         dev_info_t      *pdip;
1229         int             (*bop)();
1230 
1231         /*CONSTANTCONDITION*/
1232         while (1)  {
1233 
1234                 mutex_enter(&(DEVI(dip)->devi_lock));
1235 
1236 
1237                 /*
1238                  * find the property in child's devinfo:
1239                  * Search order is:
1240                  *      1. driver defined properties
1241                  *      2. system defined properties
1242                  *      3. driver global properties
1243                  *      4. boot defined properties
1244                  */
1245 
1246                 propp = i_ddi_prop_search(dev, name, flags,
1247                     &(DEVI(dip)->devi_drv_prop_ptr));
1248                 if (propp == NULL)  {
1249                         propp = i_ddi_prop_search(dev, name, flags,
1250                             &(DEVI(dip)->devi_sys_prop_ptr));
1251                 }
1252                 if ((propp == NULL) && DEVI(dip)->devi_global_prop_list) {
1253                         propp = i_ddi_prop_search(dev, name, flags,
1254                             &DEVI(dip)->devi_global_prop_list->prop_list);
1255                 }
1256 
1257                 if (propp == NULL)  {
1258                         propp = i_ddi_prop_search(dev, name, flags,
1259                             &(DEVI(dip)->devi_hw_prop_ptr));
1260                 }
1261 
1262                 /*
1263                  * Software property found?
1264                  */
1265                 if (propp != (ddi_prop_t *)0)   {
1266 
1267                         /*
1268                          * If explicit undefine, return now.
1269                          */
1270                         if (propp->prop_flags & DDI_PROP_UNDEF_IT) {
1271                                 mutex_exit(&(DEVI(dip)->devi_lock));
1272                                 if (prealloc)
1273                                         kmem_free(prealloc, plength);
1274                                 return (DDI_PROP_UNDEFINED);
1275                         }
1276 
1277                         /*
1278                          * If we only want to know if it exists, return now
1279                          */
1280                         if (prop_op == PROP_EXISTS) {
1281                                 mutex_exit(&(DEVI(dip)->devi_lock));
1282                                 ASSERT(prealloc == NULL);
1283                                 return (DDI_PROP_SUCCESS);
1284                         }
1285 
1286                         /*
1287                          * If length only request or prop length == 0,
1288                          * service request and return now.
1289                          */
1290                         if ((prop_op == PROP_LEN) ||(propp->prop_len == 0)) {
1291                                 *lengthp = propp->prop_len;
1292 
1293                                 /*
1294                                  * if prop_op is PROP_LEN_AND_VAL_ALLOC
1295                                  * that means prop_len is 0, so set valuep
1296                                  * also to NULL
1297                                  */
1298                                 if (prop_op == PROP_LEN_AND_VAL_ALLOC)
1299                                         *(caddr_t *)valuep = NULL;
1300 
1301                                 mutex_exit(&(DEVI(dip)->devi_lock));
1302                                 if (prealloc)
1303                                         kmem_free(prealloc, plength);
1304                                 return (DDI_PROP_SUCCESS);
1305                         }
1306 
1307                         /*
1308                          * If LEN_AND_VAL_ALLOC and the request can sleep,
1309                          * drop the mutex, allocate the buffer, and go
1310                          * through the loop again.  If we already allocated
1311                          * the buffer, and the size of the property changed,
1312                          * keep trying...
1313                          */
1314                         if ((prop_op == PROP_LEN_AND_VAL_ALLOC) &&
1315                             (flags & DDI_PROP_CANSLEEP))  {
1316                                 if (prealloc && (propp->prop_len != plength)) {
1317                                         kmem_free(prealloc, plength);
1318                                         prealloc = NULL;
1319                                 }
1320                                 if (prealloc == NULL)  {
1321                                         plength = propp->prop_len;
1322                                         mutex_exit(&(DEVI(dip)->devi_lock));
1323                                         prealloc = kmem_alloc(plength,
1324                                             KM_SLEEP);
1325                                         continue;
1326                                 }
1327                         }
1328 
1329                         /*
1330                          * Allocate buffer, if required.  Either way,
1331                          * set `buffer' variable.
1332                          */
1333                         i = *lengthp;                   /* Get callers length */
1334                         *lengthp = propp->prop_len;  /* Set callers length */
1335 
1336                         switch (prop_op) {
1337 
1338                         case PROP_LEN_AND_VAL_ALLOC:
1339 
1340                                 if (prealloc == NULL) {
1341                                         buffer = kmem_alloc(propp->prop_len,
1342                                             KM_NOSLEEP);
1343                                 } else {
1344                                         buffer = prealloc;
1345                                 }
1346 
1347                                 if (buffer == NULL)  {
1348                                         mutex_exit(&(DEVI(dip)->devi_lock));
1349                                         cmn_err(CE_CONT, prop_no_mem_msg, name);
1350                                         return (DDI_PROP_NO_MEMORY);
1351                                 }
1352                                 /* Set callers buf ptr */
1353                                 *(caddr_t *)valuep = buffer;
1354                                 break;
1355 
1356                         case PROP_LEN_AND_VAL_BUF:
1357 
1358                                 if (propp->prop_len > (i)) {
1359                                         mutex_exit(&(DEVI(dip)->devi_lock));
1360                                         return (DDI_PROP_BUF_TOO_SMALL);
1361                                 }
1362 
1363                                 buffer = valuep;  /* Get callers buf ptr */
1364                                 break;
1365 
1366                         default:
1367                                 break;
1368                         }
1369 
1370                         /*
1371                          * Do the copy.
1372                          */
1373                         bcopy(propp->prop_val, buffer, propp->prop_len);
1374                         mutex_exit(&(DEVI(dip)->devi_lock));
1375                         return (DDI_PROP_SUCCESS);
1376                 }
1377 
1378                 mutex_exit(&(DEVI(dip)->devi_lock));
1379                 if (prealloc)
1380                         kmem_free(prealloc, plength);
1381                 prealloc = NULL;
1382 
1383                 /*
1384                  * Prop not found, call parent bus_ops to deal with possible
1385                  * h/w layer (possible PROM defined props, etc.) and to
1386                  * possibly ascend the hierarchy, if allowed by flags.
1387                  */
1388                 pdip = (dev_info_t *)DEVI(dip)->devi_parent;
1389 
1390                 /*
1391                  * One last call for the root driver PROM props?
1392                  */
1393                 if (dip == ddi_root_node())  {
1394                         return (ddi_bus_prop_op(dev, dip, dip, prop_op,
1395                             flags, name, valuep, (int *)lengthp));
1396                 }
1397 
1398                 /*
1399                  * We may have been called to check for properties
1400                  * within a single devinfo node that has no parent -
1401                  * see make_prop()
1402                  */
1403                 if (pdip == NULL) {
1404                         ASSERT((flags &
1405                             (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM)) ==
1406                             (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM));
1407                         return (DDI_PROP_NOT_FOUND);
1408                 }
1409 
1410                 /*
1411                  * Instead of recursing, we do iterative calls up the tree.
1412                  * As a bit of optimization, skip the bus_op level if the
1413                  * node is a s/w node and if the parent's bus_prop_op function
1414                  * is `ddi_bus_prop_op', because we know that in this case,
1415                  * this function does nothing.
1416                  *
1417                  * 4225415: If the parent isn't attached, or the child
1418                  * hasn't been named by the parent yet, use the default
1419                  * ddi_bus_prop_op as a proxy for the parent.  This
1420                  * allows property lookups in any child/parent state to
1421                  * include 'prom' and inherited properties, even when
1422                  * there are no drivers attached to the child or parent.
1423                  */
1424 
1425                 bop = ddi_bus_prop_op;
1426                 if (i_ddi_devi_attached(pdip) &&
1427                     (i_ddi_node_state(dip) >= DS_INITIALIZED))
1428                         bop = DEVI(pdip)->devi_ops->devo_bus_ops->bus_prop_op;
1429 
1430                 i = DDI_PROP_NOT_FOUND;
1431 
1432                 if ((bop != ddi_bus_prop_op) || ndi_dev_is_prom_node(dip)) {
1433                         i = (*bop)(dev, pdip, dip, prop_op,
1434                             flags | DDI_PROP_DONTPASS,
1435                             name, valuep, lengthp);
1436                 }
1437 
1438                 if ((flags & DDI_PROP_DONTPASS) ||
1439                     (i != DDI_PROP_NOT_FOUND))
1440                         return (i);
1441 
1442                 dip = pdip;
1443         }
1444         /*NOTREACHED*/
1445 }
1446 
1447 
1448 /*
1449  * ddi_prop_op: The basic property operator for drivers.
1450  *
1451  * In ddi_prop_op, the type of valuep is interpreted based on prop_op:
1452  *
1453  *      prop_op                 valuep
1454  *      ------                  ------
1455  *
1456  *      PROP_LEN                <unused>
1457  *
1458  *      PROP_LEN_AND_VAL_BUF    Pointer to callers buffer
1459  *
1460  *      PROP_LEN_AND_VAL_ALLOC  Address of callers pointer (will be set to
1461  *                              address of allocated buffer, if successful)
1462  */
1463 int
1464 ddi_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
1465     char *name, caddr_t valuep, int *lengthp)
1466 {
1467         int     i;
1468 
1469         ASSERT((mod_flags & DDI_PROP_TYPE_MASK) == 0);
1470 
1471         /*
1472          * If this was originally an LDI prop lookup then we bail here.
1473          * The reason is that the LDI property lookup interfaces first call
1474          * a drivers prop_op() entry point to allow it to override
1475          * properties.  But if we've made it here, then the driver hasn't
1476          * overriden any properties.  We don't want to continue with the
1477          * property search here because we don't have any type inforamtion.
1478          * When we return failure, the LDI interfaces will then proceed to
1479          * call the typed property interfaces to look up the property.
1480          */
1481         if (mod_flags & DDI_PROP_DYNAMIC)
1482                 return (DDI_PROP_NOT_FOUND);
1483 
1484         /*
1485          * check for pre-typed property consumer asking for typed property:
1486          * see e_ddi_getprop_int64.
1487          */
1488         if (mod_flags & DDI_PROP_CONSUMER_TYPED)
1489                 mod_flags |= DDI_PROP_TYPE_INT64;
1490         mod_flags |= DDI_PROP_TYPE_ANY;
1491 
1492         i = ddi_prop_search_common(dev, dip, prop_op,
1493             mod_flags, name, valuep, (uint_t *)lengthp);
1494         if (i == DDI_PROP_FOUND_1275)
1495                 return (DDI_PROP_SUCCESS);
1496         return (i);
1497 }
1498 
1499 /*
1500  * ddi_prop_op_nblocks_blksize: The basic property operator for drivers that
1501  * maintain size in number of blksize blocks.  Provides a dynamic property
1502  * implementation for size oriented properties based on nblocks64 and blksize
1503  * values passed in by the driver.  Fallback to ddi_prop_op if the nblocks64
1504  * is too large.  This interface should not be used with a nblocks64 that
1505  * represents the driver's idea of how to represent unknown, if nblocks is
1506  * unknown use ddi_prop_op.
1507  */
1508 int
1509 ddi_prop_op_nblocks_blksize(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1510     int mod_flags, char *name, caddr_t valuep, int *lengthp,
1511     uint64_t nblocks64, uint_t blksize)
1512 {
1513         uint64_t size64;
1514         int     blkshift;
1515 
1516         /* convert block size to shift value */
1517         ASSERT(BIT_ONLYONESET(blksize));
1518         blkshift = highbit(blksize) - 1;
1519 
1520         /*
1521          * There is no point in supporting nblocks64 values that don't have
1522          * an accurate uint64_t byte count representation.
1523          */
1524         if (nblocks64 >= (UINT64_MAX >> blkshift))
1525                 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
1526                     name, valuep, lengthp));
1527 
1528         size64 = nblocks64 << blkshift;
1529         return (ddi_prop_op_size_blksize(dev, dip, prop_op, mod_flags,
1530             name, valuep, lengthp, size64, blksize));
1531 }
1532 
1533 /*
1534  * ddi_prop_op_nblocks: ddi_prop_op_nblocks_blksize with DEV_BSIZE blksize.
1535  */
1536 int
1537 ddi_prop_op_nblocks(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1538     int mod_flags, char *name, caddr_t valuep, int *lengthp, uint64_t nblocks64)
1539 {
1540         return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op,
1541             mod_flags, name, valuep, lengthp, nblocks64, DEV_BSIZE));
1542 }
1543 
1544 /*
1545  * ddi_prop_op_size_blksize: The basic property operator for block drivers that
1546  * maintain size in bytes. Provides a of dynamic property implementation for
1547  * size oriented properties based on size64 value and blksize passed in by the
1548  * driver.  Fallback to ddi_prop_op if the size64 is too large. This interface
1549  * should not be used with a size64 that represents the driver's idea of how
1550  * to represent unknown, if size is unknown use ddi_prop_op.
1551  *
1552  * NOTE: the legacy "nblocks"/"size" properties are treated as 32-bit unsigned
1553  * integers. While the most likely interface to request them ([bc]devi_size)
1554  * is declared int (signed) there is no enforcement of this, which means we
1555  * can't enforce limitations here without risking regression.
1556  */
1557 int
1558 ddi_prop_op_size_blksize(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1559     int mod_flags, char *name, caddr_t valuep, int *lengthp, uint64_t size64,
1560     uint_t blksize)
1561 {
1562         uint64_t nblocks64;
1563         int     callers_length;
1564         caddr_t buffer;
1565         int     blkshift;
1566 
1567         /*
1568          * This is a kludge to support capture of size(9P) pure dynamic
1569          * properties in snapshots for non-cmlb code (without exposing
1570          * i_ddi_prop_dyn changes). When everyone uses cmlb, this code
1571          * should be removed.
1572          */
1573         if (i_ddi_prop_dyn_driver_get(dip) == NULL) {
1574                 static i_ddi_prop_dyn_t prop_dyn_size[] = {
1575                     {"Size",            DDI_PROP_TYPE_INT64,    S_IFCHR},
1576                     {"Nblocks",         DDI_PROP_TYPE_INT64,    S_IFBLK},
1577                     {NULL}
1578                 };
1579                 i_ddi_prop_dyn_driver_set(dip, prop_dyn_size);
1580         }
1581 
1582         /* convert block size to shift value */
1583         ASSERT(BIT_ONLYONESET(blksize));
1584         blkshift = highbit(blksize) - 1;
1585 
1586         /* compute DEV_BSIZE nblocks value */
1587         nblocks64 = size64 >> blkshift;
1588 
1589         /* get callers length, establish length of our dynamic properties */
1590         callers_length = *lengthp;
1591 
1592         if (strcmp(name, "Nblocks") == 0)
1593                 *lengthp = sizeof (uint64_t);
1594         else if (strcmp(name, "Size") == 0)
1595                 *lengthp = sizeof (uint64_t);
1596         else if ((strcmp(name, "nblocks") == 0) && (nblocks64 < UINT_MAX))
1597                 *lengthp = sizeof (uint32_t);
1598         else if ((strcmp(name, "size") == 0) && (size64 < UINT_MAX))
1599                 *lengthp = sizeof (uint32_t);
1600         else if ((strcmp(name, "blksize") == 0) && (blksize < UINT_MAX))
1601                 *lengthp = sizeof (uint32_t);
1602         else {
1603                 /* fallback to ddi_prop_op */
1604                 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
1605                     name, valuep, lengthp));
1606         }
1607 
1608         /* service request for the length of the property */
1609         if (prop_op == PROP_LEN)
1610                 return (DDI_PROP_SUCCESS);
1611 
1612         switch (prop_op) {
1613         case PROP_LEN_AND_VAL_ALLOC:
1614                 if ((buffer = kmem_alloc(*lengthp,
1615                     (mod_flags & DDI_PROP_CANSLEEP) ?
1616                     KM_SLEEP : KM_NOSLEEP)) == NULL)
1617                         return (DDI_PROP_NO_MEMORY);
1618 
1619                 *(caddr_t *)valuep = buffer;    /* set callers buf ptr */
1620                 break;
1621 
1622         case PROP_LEN_AND_VAL_BUF:
1623                 /* the length of the property and the request must match */
1624                 if (callers_length != *lengthp)
1625                         return (DDI_PROP_INVAL_ARG);
1626 
1627                 buffer = valuep;                /* get callers buf ptr */
1628                 break;
1629 
1630         default:
1631                 return (DDI_PROP_INVAL_ARG);
1632         }
1633 
1634         /* transfer the value into the buffer */
1635         if (strcmp(name, "Nblocks") == 0)
1636                 *((uint64_t *)buffer) = nblocks64;
1637         else if (strcmp(name, "Size") == 0)
1638                 *((uint64_t *)buffer) = size64;
1639         else if (strcmp(name, "nblocks") == 0)
1640                 *((uint32_t *)buffer) = (uint32_t)nblocks64;
1641         else if (strcmp(name, "size") == 0)
1642                 *((uint32_t *)buffer) = (uint32_t)size64;
1643         else if (strcmp(name, "blksize") == 0)
1644                 *((uint32_t *)buffer) = (uint32_t)blksize;
1645         return (DDI_PROP_SUCCESS);
1646 }
1647 
1648 /*
1649  * ddi_prop_op_size: ddi_prop_op_size_blksize with DEV_BSIZE block size.
1650  */
1651 int
1652 ddi_prop_op_size(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1653     int mod_flags, char *name, caddr_t valuep, int *lengthp, uint64_t size64)
1654 {
1655         return (ddi_prop_op_size_blksize(dev, dip, prop_op,
1656             mod_flags, name, valuep, lengthp, size64, DEV_BSIZE));
1657 }
1658 
1659 /*
1660  * Variable length props...
1661  */
1662 
1663 /*
1664  * ddi_getlongprop:     Get variable length property len+val into a buffer
1665  *              allocated by property provider via kmem_alloc. Requester
1666  *              is responsible for freeing returned property via kmem_free.
1667  *
1668  *      Arguments:
1669  *
1670  *      dev_t:  Input:  dev_t of property.
1671  *      dip:    Input:  dev_info_t pointer of child.
1672  *      flags:  Input:  Possible flag modifiers are:
1673  *              DDI_PROP_DONTPASS:      Don't pass to parent if prop not found.
1674  *              DDI_PROP_CANSLEEP:      Memory allocation may sleep.
1675  *      name:   Input:  name of property.
1676  *      valuep: Output: Addr of callers buffer pointer.
1677  *      lengthp:Output: *lengthp will contain prop length on exit.
1678  *
1679  *      Possible Returns:
1680  *
1681  *              DDI_PROP_SUCCESS:       Prop found and returned.
1682  *              DDI_PROP_NOT_FOUND:     Prop not found
1683  *              DDI_PROP_UNDEFINED:     Prop explicitly undefined.
1684  *              DDI_PROP_NO_MEMORY:     Prop found, but unable to alloc mem.
1685  */
1686 
1687 int
1688 ddi_getlongprop(dev_t dev, dev_info_t *dip, int flags,
1689     char *name, caddr_t valuep, int *lengthp)
1690 {
1691         return (ddi_prop_op(dev, dip, PROP_LEN_AND_VAL_ALLOC,
1692             flags, name, valuep, lengthp));
1693 }
1694 
1695 /*
1696  *
1697  * ddi_getlongprop_buf:         Get long prop into pre-allocated callers
1698  *                              buffer. (no memory allocation by provider).
1699  *
1700  *      dev_t:  Input:  dev_t of property.
1701  *      dip:    Input:  dev_info_t pointer of child.
1702  *      flags:  Input:  DDI_PROP_DONTPASS or NULL
1703  *      name:   Input:  name of property
1704  *      valuep: Input:  ptr to callers buffer.
1705  *      lengthp:I/O:    ptr to length of callers buffer on entry,
1706  *                      actual length of property on exit.
1707  *
1708  *      Possible returns:
1709  *
1710  *              DDI_PROP_SUCCESS        Prop found and returned
1711  *              DDI_PROP_NOT_FOUND      Prop not found
1712  *              DDI_PROP_UNDEFINED      Prop explicitly undefined.
1713  *              DDI_PROP_BUF_TOO_SMALL  Prop found, callers buf too small,
1714  *                                      no value returned, but actual prop
1715  *                                      length returned in *lengthp
1716  *
1717  */
1718 
1719 int
1720 ddi_getlongprop_buf(dev_t dev, dev_info_t *dip, int flags,
1721     char *name, caddr_t valuep, int *lengthp)
1722 {
1723         return (ddi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
1724             flags, name, valuep, lengthp));
1725 }
1726 
1727 /*
1728  * Integer/boolean sized props.
1729  *
1730  * Call is value only... returns found boolean or int sized prop value or
1731  * defvalue if prop not found or is wrong length or is explicitly undefined.
1732  * Only flag is DDI_PROP_DONTPASS...
1733  *
1734  * By convention, this interface returns boolean (0) sized properties
1735  * as value (int)1.
1736  *
1737  * This never returns an error, if property not found or specifically
1738  * undefined, the input `defvalue' is returned.
1739  */
1740 
1741 int
1742 ddi_getprop(dev_t dev, dev_info_t *dip, int flags, char *name, int defvalue)
1743 {
1744         int     propvalue = defvalue;
1745         int     proplength = sizeof (int);
1746         int     error;
1747 
1748         error = ddi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
1749             flags, name, (caddr_t)&propvalue, &proplength);
1750 
1751         if ((error == DDI_PROP_SUCCESS) && (proplength == 0))
1752                 propvalue = 1;
1753 
1754         return (propvalue);
1755 }
1756 
1757 /*
1758  * Get prop length interface: flags are 0 or DDI_PROP_DONTPASS
1759  * if returns DDI_PROP_SUCCESS, length returned in *lengthp.
1760  */
1761 
1762 int
1763 ddi_getproplen(dev_t dev, dev_info_t *dip, int flags, char *name, int *lengthp)
1764 {
1765         return (ddi_prop_op(dev, dip, PROP_LEN, flags, name, NULL, lengthp));
1766 }
1767 
1768 /*
1769  * Allocate a struct prop_driver_data, along with 'size' bytes
1770  * for decoded property data.  This structure is freed by
1771  * calling ddi_prop_free(9F).
1772  */
1773 static void *
1774 ddi_prop_decode_alloc(size_t size, void (*prop_free)(struct prop_driver_data *))
1775 {
1776         struct prop_driver_data *pdd;
1777 
1778         /*
1779          * Allocate a structure with enough memory to store the decoded data.
1780          */
1781         pdd = kmem_zalloc(sizeof (struct prop_driver_data) + size, KM_SLEEP);
1782         pdd->pdd_size = (sizeof (struct prop_driver_data) + size);
1783         pdd->pdd_prop_free = prop_free;
1784 
1785         /*
1786          * Return a pointer to the location to put the decoded data.
1787          */
1788         return ((void *)((caddr_t)pdd + sizeof (struct prop_driver_data)));
1789 }
1790 
1791 /*
1792  * Allocated the memory needed to store the encoded data in the property
1793  * handle.
1794  */
1795 static int
1796 ddi_prop_encode_alloc(prop_handle_t *ph, size_t size)
1797 {
1798         /*
1799          * If size is zero, then set data to NULL and size to 0.  This
1800          * is a boolean property.
1801          */
1802         if (size == 0) {
1803                 ph->ph_size = 0;
1804                 ph->ph_data = NULL;
1805                 ph->ph_cur_pos = NULL;
1806                 ph->ph_save_pos = NULL;
1807         } else {
1808                 if (ph->ph_flags == DDI_PROP_DONTSLEEP) {
1809                         ph->ph_data = kmem_zalloc(size, KM_NOSLEEP);
1810                         if (ph->ph_data == NULL)
1811                                 return (DDI_PROP_NO_MEMORY);
1812                 } else
1813                         ph->ph_data = kmem_zalloc(size, KM_SLEEP);
1814                 ph->ph_size = size;
1815                 ph->ph_cur_pos = ph->ph_data;
1816                 ph->ph_save_pos = ph->ph_data;
1817         }
1818         return (DDI_PROP_SUCCESS);
1819 }
1820 
1821 /*
1822  * Free the space allocated by the lookup routines.  Each lookup routine
1823  * returns a pointer to the decoded data to the driver.  The driver then
1824  * passes this pointer back to us.  This data actually lives in a struct
1825  * prop_driver_data.  We use negative indexing to find the beginning of
1826  * the structure and then free the entire structure using the size and
1827  * the free routine stored in the structure.
1828  */
1829 void
1830 ddi_prop_free(void *datap)
1831 {
1832         struct prop_driver_data *pdd;
1833 
1834         /*
1835          * Get the structure
1836          */
1837         pdd = (struct prop_driver_data *)
1838             ((caddr_t)datap - sizeof (struct prop_driver_data));
1839         /*
1840          * Call the free routine to free it
1841          */
1842         (*pdd->pdd_prop_free)(pdd);
1843 }
1844 
1845 /*
1846  * Free the data associated with an array of ints,
1847  * allocated with ddi_prop_decode_alloc().
1848  */
1849 static void
1850 ddi_prop_free_ints(struct prop_driver_data *pdd)
1851 {
1852         kmem_free(pdd, pdd->pdd_size);
1853 }
1854 
1855 /*
1856  * Free a single string property or a single string contained within
1857  * the argv style return value of an array of strings.
1858  */
1859 static void
1860 ddi_prop_free_string(struct prop_driver_data *pdd)
1861 {
1862         kmem_free(pdd, pdd->pdd_size);
1863 
1864 }
1865 
1866 /*
1867  * Free an array of strings.
1868  */
1869 static void
1870 ddi_prop_free_strings(struct prop_driver_data *pdd)
1871 {
1872         kmem_free(pdd, pdd->pdd_size);
1873 }
1874 
1875 /*
1876  * Free the data associated with an array of bytes.
1877  */
1878 static void
1879 ddi_prop_free_bytes(struct prop_driver_data *pdd)
1880 {
1881         kmem_free(pdd, pdd->pdd_size);
1882 }
1883 
1884 /*
1885  * Reset the current location pointer in the property handle to the
1886  * beginning of the data.
1887  */
1888 void
1889 ddi_prop_reset_pos(prop_handle_t *ph)
1890 {
1891         ph->ph_cur_pos = ph->ph_data;
1892         ph->ph_save_pos = ph->ph_data;
1893 }
1894 
1895 /*
1896  * Restore the current location pointer in the property handle to the
1897  * saved position.
1898  */
1899 void
1900 ddi_prop_save_pos(prop_handle_t *ph)
1901 {
1902         ph->ph_save_pos = ph->ph_cur_pos;
1903 }
1904 
1905 /*
1906  * Save the location that the current location pointer is pointing to..
1907  */
1908 void
1909 ddi_prop_restore_pos(prop_handle_t *ph)
1910 {
1911         ph->ph_cur_pos = ph->ph_save_pos;
1912 }
1913 
1914 /*
1915  * Property encode/decode functions
1916  */
1917 
1918 /*
1919  * Decode a single integer property
1920  */
1921 static int
1922 ddi_prop_fm_decode_int(prop_handle_t *ph, void *data, uint_t *nelements)
1923 {
1924         int     i;
1925         int     tmp;
1926 
1927         /*
1928          * If there is nothing to decode return an error
1929          */
1930         if (ph->ph_size == 0)
1931                 return (DDI_PROP_END_OF_DATA);
1932 
1933         /*
1934          * Decode the property as a single integer and return it
1935          * in data if we were able to decode it.
1936          */
1937         i = DDI_PROP_INT(ph, DDI_PROP_CMD_DECODE, &tmp);
1938         if (i < DDI_PROP_RESULT_OK) {
1939                 switch (i) {
1940                 case DDI_PROP_RESULT_EOF:
1941                         return (DDI_PROP_END_OF_DATA);
1942 
1943                 case DDI_PROP_RESULT_ERROR:
1944                         return (DDI_PROP_CANNOT_DECODE);
1945                 }
1946         }
1947 
1948         *(int *)data = tmp;
1949         *nelements = 1;
1950         return (DDI_PROP_SUCCESS);
1951 }
1952 
1953 /*
1954  * Decode a single 64 bit integer property
1955  */
1956 static int
1957 ddi_prop_fm_decode_int64(prop_handle_t *ph, void *data, uint_t *nelements)
1958 {
1959         int     i;
1960         int64_t tmp;
1961 
1962         /*
1963          * If there is nothing to decode return an error
1964          */
1965         if (ph->ph_size == 0)
1966                 return (DDI_PROP_END_OF_DATA);
1967 
1968         /*
1969          * Decode the property as a single integer and return it
1970          * in data if we were able to decode it.
1971          */
1972         i = DDI_PROP_INT64(ph, DDI_PROP_CMD_DECODE, &tmp);
1973         if (i < DDI_PROP_RESULT_OK) {
1974                 switch (i) {
1975                 case DDI_PROP_RESULT_EOF:
1976                         return (DDI_PROP_END_OF_DATA);
1977 
1978                 case DDI_PROP_RESULT_ERROR:
1979                         return (DDI_PROP_CANNOT_DECODE);
1980                 }
1981         }
1982 
1983         *(int64_t *)data = tmp;
1984         *nelements = 1;
1985         return (DDI_PROP_SUCCESS);
1986 }
1987 
1988 /*
1989  * Decode an array of integers property
1990  */
1991 static int
1992 ddi_prop_fm_decode_ints(prop_handle_t *ph, void *data, uint_t *nelements)
1993 {
1994         int     i;
1995         int     cnt = 0;
1996         int     *tmp;
1997         int     *intp;
1998         int     n;
1999 
2000         /*
2001          * Figure out how many array elements there are by going through the
2002          * data without decoding it first and counting.
2003          */
2004         for (;;) {
2005                 i = DDI_PROP_INT(ph, DDI_PROP_CMD_SKIP, NULL);
2006                 if (i < 0)
2007                         break;
2008                 cnt++;
2009         }
2010 
2011         /*
2012          * If there are no elements return an error
2013          */
2014         if (cnt == 0)
2015                 return (DDI_PROP_END_OF_DATA);
2016 
2017         /*
2018          * If we cannot skip through the data, we cannot decode it
2019          */
2020         if (i == DDI_PROP_RESULT_ERROR)
2021                 return (DDI_PROP_CANNOT_DECODE);
2022 
2023         /*
2024          * Reset the data pointer to the beginning of the encoded data
2025          */
2026         ddi_prop_reset_pos(ph);
2027 
2028         /*
2029          * Allocated memory to store the decoded value in.
2030          */
2031         intp = ddi_prop_decode_alloc((cnt * sizeof (int)),
2032             ddi_prop_free_ints);
2033 
2034         /*
2035          * Decode each element and place it in the space we just allocated
2036          */
2037         tmp = intp;
2038         for (n = 0; n < cnt; n++, tmp++) {
2039                 i = DDI_PROP_INT(ph, DDI_PROP_CMD_DECODE, tmp);
2040                 if (i < DDI_PROP_RESULT_OK) {
2041                         /*
2042                          * Free the space we just allocated
2043                          * and return an error.
2044                          */
2045                         ddi_prop_free(intp);
2046                         switch (i) {
2047                         case DDI_PROP_RESULT_EOF:
2048                                 return (DDI_PROP_END_OF_DATA);
2049 
2050                         case DDI_PROP_RESULT_ERROR:
2051                                 return (DDI_PROP_CANNOT_DECODE);
2052                         }
2053                 }
2054         }
2055 
2056         *nelements = cnt;
2057         *(int **)data = intp;
2058 
2059         return (DDI_PROP_SUCCESS);
2060 }
2061 
2062 /*
2063  * Decode a 64 bit integer array property
2064  */
2065 static int
2066 ddi_prop_fm_decode_int64_array(prop_handle_t *ph, void *data, uint_t *nelements)
2067 {
2068         int     i;
2069         int     n;
2070         int     cnt = 0;
2071         int64_t *tmp;
2072         int64_t *intp;
2073 
2074         /*
2075          * Count the number of array elements by going
2076          * through the data without decoding it.
2077          */
2078         for (;;) {
2079                 i = DDI_PROP_INT64(ph, DDI_PROP_CMD_SKIP, NULL);
2080                 if (i < 0)
2081                         break;
2082                 cnt++;
2083         }
2084 
2085         /*
2086          * If there are no elements return an error
2087          */
2088         if (cnt == 0)
2089                 return (DDI_PROP_END_OF_DATA);
2090 
2091         /*
2092          * If we cannot skip through the data, we cannot decode it
2093          */
2094         if (i == DDI_PROP_RESULT_ERROR)
2095                 return (DDI_PROP_CANNOT_DECODE);
2096 
2097         /*
2098          * Reset the data pointer to the beginning of the encoded data
2099          */
2100         ddi_prop_reset_pos(ph);
2101 
2102         /*
2103          * Allocate memory to store the decoded value.
2104          */
2105         intp = ddi_prop_decode_alloc((cnt * sizeof (int64_t)),
2106             ddi_prop_free_ints);
2107 
2108         /*
2109          * Decode each element and place it in the space allocated
2110          */
2111         tmp = intp;
2112         for (n = 0; n < cnt; n++, tmp++) {
2113                 i = DDI_PROP_INT64(ph, DDI_PROP_CMD_DECODE, tmp);
2114                 if (i < DDI_PROP_RESULT_OK) {
2115                         /*
2116                          * Free the space we just allocated
2117                          * and return an error.
2118                          */
2119                         ddi_prop_free(intp);
2120                         switch (i) {
2121                         case DDI_PROP_RESULT_EOF:
2122                                 return (DDI_PROP_END_OF_DATA);
2123 
2124                         case DDI_PROP_RESULT_ERROR:
2125                                 return (DDI_PROP_CANNOT_DECODE);
2126                         }
2127                 }
2128         }
2129 
2130         *nelements = cnt;
2131         *(int64_t **)data = intp;
2132 
2133         return (DDI_PROP_SUCCESS);
2134 }
2135 
2136 /*
2137  * Encode an array of integers property (Can be one element)
2138  */
2139 int
2140 ddi_prop_fm_encode_ints(prop_handle_t *ph, void *data, uint_t nelements)
2141 {
2142         int     i;
2143         int     *tmp;
2144         int     cnt;
2145         int     size;
2146 
2147         /*
2148          * If there is no data, we cannot do anything
2149          */
2150         if (nelements == 0)
2151                 return (DDI_PROP_CANNOT_ENCODE);
2152 
2153         /*
2154          * Get the size of an encoded int.
2155          */
2156         size = DDI_PROP_INT(ph, DDI_PROP_CMD_GET_ESIZE, NULL);
2157 
2158         if (size < DDI_PROP_RESULT_OK) {
2159                 switch (size) {
2160                 case DDI_PROP_RESULT_EOF:
2161                         return (DDI_PROP_END_OF_DATA);
2162 
2163                 case DDI_PROP_RESULT_ERROR:
2164                         return (DDI_PROP_CANNOT_ENCODE);
2165                 }
2166         }
2167 
2168         /*
2169          * Allocate space in the handle to store the encoded int.
2170          */
2171         if (ddi_prop_encode_alloc(ph, size * nelements) !=
2172             DDI_PROP_SUCCESS)
2173                 return (DDI_PROP_NO_MEMORY);
2174 
2175         /*
2176          * Encode the array of ints.
2177          */
2178         tmp = (int *)data;
2179         for (cnt = 0; cnt < nelements; cnt++, tmp++) {
2180                 i = DDI_PROP_INT(ph, DDI_PROP_CMD_ENCODE, tmp);
2181                 if (i < DDI_PROP_RESULT_OK) {
2182                         switch (i) {
2183                         case DDI_PROP_RESULT_EOF:
2184                                 return (DDI_PROP_END_OF_DATA);
2185 
2186                         case DDI_PROP_RESULT_ERROR:
2187                                 return (DDI_PROP_CANNOT_ENCODE);
2188                         }
2189                 }
2190         }
2191 
2192         return (DDI_PROP_SUCCESS);
2193 }
2194 
2195 
2196 /*
2197  * Encode a 64 bit integer array property
2198  */
2199 int
2200 ddi_prop_fm_encode_int64(prop_handle_t *ph, void *data, uint_t nelements)
2201 {
2202         int i;
2203         int cnt;
2204         int size;
2205         int64_t *tmp;
2206 
2207         /*
2208          * If there is no data, we cannot do anything
2209          */
2210         if (nelements == 0)
2211                 return (DDI_PROP_CANNOT_ENCODE);
2212 
2213         /*
2214          * Get the size of an encoded 64 bit int.
2215          */
2216         size = DDI_PROP_INT64(ph, DDI_PROP_CMD_GET_ESIZE, NULL);
2217 
2218         if (size < DDI_PROP_RESULT_OK) {
2219                 switch (size) {
2220                 case DDI_PROP_RESULT_EOF:
2221                         return (DDI_PROP_END_OF_DATA);
2222 
2223                 case DDI_PROP_RESULT_ERROR:
2224                         return (DDI_PROP_CANNOT_ENCODE);
2225                 }
2226         }
2227 
2228         /*
2229          * Allocate space in the handle to store the encoded int.
2230          */
2231         if (ddi_prop_encode_alloc(ph, size * nelements) !=
2232             DDI_PROP_SUCCESS)
2233                 return (DDI_PROP_NO_MEMORY);
2234 
2235         /*
2236          * Encode the array of ints.
2237          */
2238         tmp = (int64_t *)data;
2239         for (cnt = 0; cnt < nelements; cnt++, tmp++) {
2240                 i = DDI_PROP_INT64(ph, DDI_PROP_CMD_ENCODE, tmp);
2241                 if (i < DDI_PROP_RESULT_OK) {
2242                         switch (i) {
2243                         case DDI_PROP_RESULT_EOF:
2244                                 return (DDI_PROP_END_OF_DATA);
2245 
2246                         case DDI_PROP_RESULT_ERROR:
2247                                 return (DDI_PROP_CANNOT_ENCODE);
2248                         }
2249                 }
2250         }
2251 
2252         return (DDI_PROP_SUCCESS);
2253 }
2254 
2255 /*
2256  * Decode a single string property
2257  */
2258 static int
2259 ddi_prop_fm_decode_string(prop_handle_t *ph, void *data, uint_t *nelements)
2260 {
2261         char            *tmp;
2262         char            *str;
2263         int             i;
2264         int             size;
2265 
2266         /*
2267          * If there is nothing to decode return an error
2268          */
2269         if (ph->ph_size == 0)
2270                 return (DDI_PROP_END_OF_DATA);
2271 
2272         /*
2273          * Get the decoded size of the encoded string.
2274          */
2275         size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_DSIZE, NULL);
2276         if (size < DDI_PROP_RESULT_OK) {
2277                 switch (size) {
2278                 case DDI_PROP_RESULT_EOF:
2279                         return (DDI_PROP_END_OF_DATA);
2280 
2281                 case DDI_PROP_RESULT_ERROR:
2282                         return (DDI_PROP_CANNOT_DECODE);
2283                 }
2284         }
2285 
2286         /*
2287          * Allocated memory to store the decoded value in.
2288          */
2289         str = ddi_prop_decode_alloc((size_t)size, ddi_prop_free_string);
2290 
2291         ddi_prop_reset_pos(ph);
2292 
2293         /*
2294          * Decode the str and place it in the space we just allocated
2295          */
2296         tmp = str;
2297         i = DDI_PROP_STR(ph, DDI_PROP_CMD_DECODE, tmp);
2298         if (i < DDI_PROP_RESULT_OK) {
2299                 /*
2300                  * Free the space we just allocated
2301                  * and return an error.
2302                  */
2303                 ddi_prop_free(str);
2304                 switch (i) {
2305                 case DDI_PROP_RESULT_EOF:
2306                         return (DDI_PROP_END_OF_DATA);
2307 
2308                 case DDI_PROP_RESULT_ERROR:
2309                         return (DDI_PROP_CANNOT_DECODE);
2310                 }
2311         }
2312 
2313         *(char **)data = str;
2314         *nelements = 1;
2315 
2316         return (DDI_PROP_SUCCESS);
2317 }
2318 
2319 /*
2320  * Decode an array of strings.
2321  */
2322 int
2323 ddi_prop_fm_decode_strings(prop_handle_t *ph, void *data, uint_t *nelements)
2324 {
2325         int             cnt = 0;
2326         char            **strs;
2327         char            **tmp;
2328         char            *ptr;
2329         int             i;
2330         int             n;
2331         int             size;
2332         size_t          nbytes;
2333 
2334         /*
2335          * Figure out how many array elements there are by going through the
2336          * data without decoding it first and counting.
2337          */
2338         for (;;) {
2339                 i = DDI_PROP_STR(ph, DDI_PROP_CMD_SKIP, NULL);
2340                 if (i < 0)
2341                         break;
2342                 cnt++;
2343         }
2344 
2345         /*
2346          * If there are no elements return an error
2347          */
2348         if (cnt == 0)
2349                 return (DDI_PROP_END_OF_DATA);
2350 
2351         /*
2352          * If we cannot skip through the data, we cannot decode it
2353          */
2354         if (i == DDI_PROP_RESULT_ERROR)
2355                 return (DDI_PROP_CANNOT_DECODE);
2356 
2357         /*
2358          * Reset the data pointer to the beginning of the encoded data
2359          */
2360         ddi_prop_reset_pos(ph);
2361 
2362         /*
2363          * Figure out how much memory we need for the sum total
2364          */
2365         nbytes = (cnt + 1) * sizeof (char *);
2366 
2367         for (n = 0; n < cnt; n++) {
2368                 /*
2369                  * Get the decoded size of the current encoded string.
2370                  */
2371                 size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_DSIZE, NULL);
2372                 if (size < DDI_PROP_RESULT_OK) {
2373                         switch (size) {
2374                         case DDI_PROP_RESULT_EOF:
2375                                 return (DDI_PROP_END_OF_DATA);
2376 
2377                         case DDI_PROP_RESULT_ERROR:
2378                                 return (DDI_PROP_CANNOT_DECODE);
2379                         }
2380                 }
2381 
2382                 nbytes += size;
2383         }
2384 
2385         /*
2386          * Allocate memory in which to store the decoded strings.
2387          */
2388         strs = ddi_prop_decode_alloc(nbytes, ddi_prop_free_strings);
2389 
2390         /*
2391          * Set up pointers for each string by figuring out yet
2392          * again how long each string is.
2393          */
2394         ddi_prop_reset_pos(ph);
2395         ptr = (caddr_t)strs + ((cnt + 1) * sizeof (char *));
2396         for (tmp = strs, n = 0; n < cnt; n++, tmp++) {
2397                 /*
2398                  * Get the decoded size of the current encoded string.
2399                  */
2400                 size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_DSIZE, NULL);
2401                 if (size < DDI_PROP_RESULT_OK) {
2402                         ddi_prop_free(strs);
2403                         switch (size) {
2404                         case DDI_PROP_RESULT_EOF:
2405                                 return (DDI_PROP_END_OF_DATA);
2406 
2407                         case DDI_PROP_RESULT_ERROR:
2408                                 return (DDI_PROP_CANNOT_DECODE);
2409                         }
2410                 }
2411 
2412                 *tmp = ptr;
2413                 ptr += size;
2414         }
2415 
2416         /*
2417          * String array is terminated by a NULL
2418          */
2419         *tmp = NULL;
2420 
2421         /*
2422          * Finally, we can decode each string
2423          */
2424         ddi_prop_reset_pos(ph);
2425         for (tmp = strs, n = 0; n < cnt; n++, tmp++) {
2426                 i = DDI_PROP_STR(ph, DDI_PROP_CMD_DECODE, *tmp);
2427                 if (i < DDI_PROP_RESULT_OK) {
2428                         /*
2429                          * Free the space we just allocated
2430                          * and return an error
2431                          */
2432                         ddi_prop_free(strs);
2433                         switch (i) {
2434                         case DDI_PROP_RESULT_EOF:
2435                                 return (DDI_PROP_END_OF_DATA);
2436 
2437                         case DDI_PROP_RESULT_ERROR:
2438                                 return (DDI_PROP_CANNOT_DECODE);
2439                         }
2440                 }
2441         }
2442 
2443         *(char ***)data = strs;
2444         *nelements = cnt;
2445 
2446         return (DDI_PROP_SUCCESS);
2447 }
2448 
2449 /*
2450  * Encode a string.
2451  */
2452 int
2453 ddi_prop_fm_encode_string(prop_handle_t *ph, void *data, uint_t nelements)
2454 {
2455         char            **tmp;
2456         int             size;
2457         int             i;
2458 
2459         /*
2460          * If there is no data, we cannot do anything
2461          */
2462         if (nelements == 0)
2463                 return (DDI_PROP_CANNOT_ENCODE);
2464 
2465         /*
2466          * Get the size of the encoded string.
2467          */
2468         tmp = (char **)data;
2469         size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_ESIZE, *tmp);
2470         if (size < DDI_PROP_RESULT_OK) {
2471                 switch (size) {
2472                 case DDI_PROP_RESULT_EOF:
2473                         return (DDI_PROP_END_OF_DATA);
2474 
2475                 case DDI_PROP_RESULT_ERROR:
2476                         return (DDI_PROP_CANNOT_ENCODE);
2477                 }
2478         }
2479 
2480         /*
2481          * Allocate space in the handle to store the encoded string.
2482          */
2483         if (ddi_prop_encode_alloc(ph, size) != DDI_PROP_SUCCESS)
2484                 return (DDI_PROP_NO_MEMORY);
2485 
2486         ddi_prop_reset_pos(ph);
2487 
2488         /*
2489          * Encode the string.
2490          */
2491         tmp = (char **)data;
2492         i = DDI_PROP_STR(ph, DDI_PROP_CMD_ENCODE, *tmp);
2493         if (i < DDI_PROP_RESULT_OK) {
2494                 switch (i) {
2495                 case DDI_PROP_RESULT_EOF:
2496                         return (DDI_PROP_END_OF_DATA);
2497 
2498                 case DDI_PROP_RESULT_ERROR:
2499                         return (DDI_PROP_CANNOT_ENCODE);
2500                 }
2501         }
2502 
2503         return (DDI_PROP_SUCCESS);
2504 }
2505 
2506 
2507 /*
2508  * Encode an array of strings.
2509  */
2510 int
2511 ddi_prop_fm_encode_strings(prop_handle_t *ph, void *data, uint_t nelements)
2512 {
2513         int             cnt = 0;
2514         char            **tmp;
2515         int             size;
2516         uint_t          total_size;
2517         int             i;
2518 
2519         /*
2520          * If there is no data, we cannot do anything
2521          */
2522         if (nelements == 0)
2523                 return (DDI_PROP_CANNOT_ENCODE);
2524 
2525         /*
2526          * Get the total size required to encode all the strings.
2527          */
2528         total_size = 0;
2529         tmp = (char **)data;
2530         for (cnt = 0; cnt < nelements; cnt++, tmp++) {
2531                 size = DDI_PROP_STR(ph, DDI_PROP_CMD_GET_ESIZE, *tmp);
2532                 if (size < DDI_PROP_RESULT_OK) {
2533                         switch (size) {
2534                         case DDI_PROP_RESULT_EOF:
2535                                 return (DDI_PROP_END_OF_DATA);
2536 
2537                         case DDI_PROP_RESULT_ERROR:
2538                                 return (DDI_PROP_CANNOT_ENCODE);
2539                         }
2540                 }
2541                 total_size += (uint_t)size;
2542         }
2543 
2544         /*
2545          * Allocate space in the handle to store the encoded strings.
2546          */
2547         if (ddi_prop_encode_alloc(ph, total_size) != DDI_PROP_SUCCESS)
2548                 return (DDI_PROP_NO_MEMORY);
2549 
2550         ddi_prop_reset_pos(ph);
2551 
2552         /*
2553          * Encode the array of strings.
2554          */
2555         tmp = (char **)data;
2556         for (cnt = 0; cnt < nelements; cnt++, tmp++) {
2557                 i = DDI_PROP_STR(ph, DDI_PROP_CMD_ENCODE, *tmp);
2558                 if (i < DDI_PROP_RESULT_OK) {
2559                         switch (i) {
2560                         case DDI_PROP_RESULT_EOF:
2561                                 return (DDI_PROP_END_OF_DATA);
2562 
2563                         case DDI_PROP_RESULT_ERROR:
2564                                 return (DDI_PROP_CANNOT_ENCODE);
2565                         }
2566                 }
2567         }
2568 
2569         return (DDI_PROP_SUCCESS);
2570 }
2571 
2572 
2573 /*
2574  * Decode an array of bytes.
2575  */
2576 static int
2577 ddi_prop_fm_decode_bytes(prop_handle_t *ph, void *data, uint_t *nelements)
2578 {
2579         uchar_t         *tmp;
2580         int             nbytes;
2581         int             i;
2582 
2583         /*
2584          * If there are no elements return an error
2585          */
2586         if (ph->ph_size == 0)
2587                 return (DDI_PROP_END_OF_DATA);
2588 
2589         /*
2590          * Get the size of the encoded array of bytes.
2591          */
2592         nbytes = DDI_PROP_BYTES(ph, DDI_PROP_CMD_GET_DSIZE,
2593             data, ph->ph_size);
2594         if (nbytes < DDI_PROP_RESULT_OK) {
2595                 switch (nbytes) {
2596                 case DDI_PROP_RESULT_EOF:
2597                         return (DDI_PROP_END_OF_DATA);
2598 
2599                 case DDI_PROP_RESULT_ERROR:
2600                         return (DDI_PROP_CANNOT_DECODE);
2601                 }
2602         }
2603 
2604         /*
2605          * Allocated memory to store the decoded value in.
2606          */
2607         tmp = ddi_prop_decode_alloc(nbytes, ddi_prop_free_bytes);
2608 
2609         /*
2610          * Decode each element and place it in the space we just allocated
2611          */
2612         i = DDI_PROP_BYTES(ph, DDI_PROP_CMD_DECODE, tmp, nbytes);
2613         if (i < DDI_PROP_RESULT_OK) {
2614                 /*
2615                  * Free the space we just allocated
2616                  * and return an error
2617                  */
2618                 ddi_prop_free(tmp);
2619                 switch (i) {
2620                 case DDI_PROP_RESULT_EOF:
2621                         return (DDI_PROP_END_OF_DATA);
2622 
2623                 case DDI_PROP_RESULT_ERROR:
2624                         return (DDI_PROP_CANNOT_DECODE);
2625                 }
2626         }
2627 
2628         *(uchar_t **)data = tmp;
2629         *nelements = nbytes;
2630 
2631         return (DDI_PROP_SUCCESS);
2632 }
2633 
2634 /*
2635  * Encode an array of bytes.
2636  */
2637 int
2638 ddi_prop_fm_encode_bytes(prop_handle_t *ph, void *data, uint_t nelements)
2639 {
2640         int             size;
2641         int             i;
2642 
2643         /*
2644          * If there are no elements, then this is a boolean property,
2645          * so just create a property handle with no data and return.
2646          */
2647         if (nelements == 0) {
2648                 (void) ddi_prop_encode_alloc(ph, 0);
2649                 return (DDI_PROP_SUCCESS);
2650         }
2651 
2652         /*
2653          * Get the size of the encoded array of bytes.
2654          */
2655         size = DDI_PROP_BYTES(ph, DDI_PROP_CMD_GET_ESIZE, (uchar_t *)data,
2656             nelements);
2657         if (size < DDI_PROP_RESULT_OK) {
2658                 switch (size) {
2659                 case DDI_PROP_RESULT_EOF:
2660                         return (DDI_PROP_END_OF_DATA);
2661 
2662                 case DDI_PROP_RESULT_ERROR:
2663                         return (DDI_PROP_CANNOT_DECODE);
2664                 }
2665         }
2666 
2667         /*
2668          * Allocate space in the handle to store the encoded bytes.
2669          */
2670         if (ddi_prop_encode_alloc(ph, (uint_t)size) != DDI_PROP_SUCCESS)
2671                 return (DDI_PROP_NO_MEMORY);
2672 
2673         /*
2674          * Encode the array of bytes.
2675          */
2676         i = DDI_PROP_BYTES(ph, DDI_PROP_CMD_ENCODE, (uchar_t *)data,
2677             nelements);
2678         if (i < DDI_PROP_RESULT_OK) {
2679                 switch (i) {
2680                 case DDI_PROP_RESULT_EOF:
2681                         return (DDI_PROP_END_OF_DATA);
2682 
2683                 case DDI_PROP_RESULT_ERROR:
2684                         return (DDI_PROP_CANNOT_ENCODE);
2685                 }
2686         }
2687 
2688         return (DDI_PROP_SUCCESS);
2689 }
2690 
2691 /*
2692  * OBP 1275 integer, string and byte operators.
2693  *
2694  * DDI_PROP_CMD_DECODE:
2695  *
2696  *      DDI_PROP_RESULT_ERROR:          cannot decode the data
2697  *      DDI_PROP_RESULT_EOF:            end of data
2698  *      DDI_PROP_OK:                    data was decoded
2699  *
2700  * DDI_PROP_CMD_ENCODE:
2701  *
2702  *      DDI_PROP_RESULT_ERROR:          cannot encode the data
2703  *      DDI_PROP_RESULT_EOF:            end of data
2704  *      DDI_PROP_OK:                    data was encoded
2705  *
2706  * DDI_PROP_CMD_SKIP:
2707  *
2708  *      DDI_PROP_RESULT_ERROR:          cannot skip the data
2709  *      DDI_PROP_RESULT_EOF:            end of data
2710  *      DDI_PROP_OK:                    data was skipped
2711  *
2712  * DDI_PROP_CMD_GET_ESIZE:
2713  *
2714  *      DDI_PROP_RESULT_ERROR:          cannot get encoded size
2715  *      DDI_PROP_RESULT_EOF:            end of data
2716  *      > 0:                         the encoded size
2717  *
2718  * DDI_PROP_CMD_GET_DSIZE:
2719  *
2720  *      DDI_PROP_RESULT_ERROR:          cannot get decoded size
2721  *      DDI_PROP_RESULT_EOF:            end of data
2722  *      > 0:                         the decoded size
2723  */
2724 
2725 /*
2726  * OBP 1275 integer operator
2727  *
2728  * OBP properties are a byte stream of data, so integers may not be
2729  * properly aligned.  Therefore we need to copy them one byte at a time.
2730  */
2731 int
2732 ddi_prop_1275_int(prop_handle_t *ph, uint_t cmd, int *data)
2733 {
2734         int     i;
2735 
2736         switch (cmd) {
2737         case DDI_PROP_CMD_DECODE:
2738                 /*
2739                  * Check that there is encoded data
2740                  */
2741                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0)
2742                         return (DDI_PROP_RESULT_ERROR);
2743                 if (ph->ph_flags & PH_FROM_PROM) {
2744                         i = MIN(ph->ph_size, PROP_1275_INT_SIZE);
2745                         if ((int *)ph->ph_cur_pos > ((int *)ph->ph_data +
2746                             ph->ph_size - i))
2747                                 return (DDI_PROP_RESULT_ERROR);
2748                 } else {
2749                         if (ph->ph_size < sizeof (int) ||
2750                             ((int *)ph->ph_cur_pos > ((int *)ph->ph_data +
2751                             ph->ph_size - sizeof (int))))
2752                                 return (DDI_PROP_RESULT_ERROR);
2753                 }
2754 
2755                 /*
2756                  * Copy the integer, using the implementation-specific
2757                  * copy function if the property is coming from the PROM.
2758                  */
2759                 if (ph->ph_flags & PH_FROM_PROM) {
2760                         *data = impl_ddi_prop_int_from_prom(
2761                             (uchar_t *)ph->ph_cur_pos,
2762                             (ph->ph_size < PROP_1275_INT_SIZE) ?
2763                             ph->ph_size : PROP_1275_INT_SIZE);
2764                 } else {
2765                         bcopy(ph->ph_cur_pos, data, sizeof (int));
2766                 }
2767 
2768                 /*
2769                  * Move the current location to the start of the next
2770                  * bit of undecoded data.
2771                  */
2772                 ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos +
2773                     PROP_1275_INT_SIZE;
2774                 return (DDI_PROP_RESULT_OK);
2775 
2776         case DDI_PROP_CMD_ENCODE:
2777                 /*
2778                  * Check that there is room to encoded the data
2779                  */
2780                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
2781                     ph->ph_size < PROP_1275_INT_SIZE ||
2782                     ((int *)ph->ph_cur_pos > ((int *)ph->ph_data +
2783                     ph->ph_size - sizeof (int))))
2784                         return (DDI_PROP_RESULT_ERROR);
2785 
2786                 /*
2787                  * Encode the integer into the byte stream one byte at a
2788                  * time.
2789                  */
2790                 bcopy(data, ph->ph_cur_pos, sizeof (int));
2791 
2792                 /*
2793                  * Move the current location to the start of the next bit of
2794                  * space where we can store encoded data.
2795                  */
2796                 ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + PROP_1275_INT_SIZE;
2797                 return (DDI_PROP_RESULT_OK);
2798 
2799         case DDI_PROP_CMD_SKIP:
2800                 /*
2801                  * Check that there is encoded data
2802                  */
2803                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
2804                     ph->ph_size < PROP_1275_INT_SIZE)
2805                         return (DDI_PROP_RESULT_ERROR);
2806 
2807 
2808                 if ((caddr_t)ph->ph_cur_pos ==
2809                     (caddr_t)ph->ph_data + ph->ph_size) {
2810                         return (DDI_PROP_RESULT_EOF);
2811                 } else if ((caddr_t)ph->ph_cur_pos >
2812                     (caddr_t)ph->ph_data + ph->ph_size) {
2813                         return (DDI_PROP_RESULT_EOF);
2814                 }
2815 
2816                 /*
2817                  * Move the current location to the start of the next bit of
2818                  * undecoded data.
2819                  */
2820                 ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos + PROP_1275_INT_SIZE;
2821                 return (DDI_PROP_RESULT_OK);
2822 
2823         case DDI_PROP_CMD_GET_ESIZE:
2824                 /*
2825                  * Return the size of an encoded integer on OBP
2826                  */
2827                 return (PROP_1275_INT_SIZE);
2828 
2829         case DDI_PROP_CMD_GET_DSIZE:
2830                 /*
2831                  * Return the size of a decoded integer on the system.
2832                  */
2833                 return (sizeof (int));
2834 
2835         default:
2836 #ifdef DEBUG
2837                 panic("ddi_prop_1275_int: %x impossible", cmd);
2838                 /*NOTREACHED*/
2839 #else
2840                 return (DDI_PROP_RESULT_ERROR);
2841 #endif  /* DEBUG */
2842         }
2843 }
2844 
2845 /*
2846  * 64 bit integer operator.
2847  *
2848  * This is an extension, defined by Sun, to the 1275 integer
2849  * operator.  This routine handles the encoding/decoding of
2850  * 64 bit integer properties.
2851  */
2852 int
2853 ddi_prop_int64_op(prop_handle_t *ph, uint_t cmd, int64_t *data)
2854 {
2855 
2856         switch (cmd) {
2857         case DDI_PROP_CMD_DECODE:
2858                 /*
2859                  * Check that there is encoded data
2860                  */
2861                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0)
2862                         return (DDI_PROP_RESULT_ERROR);
2863                 if (ph->ph_flags & PH_FROM_PROM) {
2864                         return (DDI_PROP_RESULT_ERROR);
2865                 } else {
2866                         if (ph->ph_size < sizeof (int64_t) ||
2867                             ((int64_t *)ph->ph_cur_pos >
2868                             ((int64_t *)ph->ph_data +
2869                             ph->ph_size - sizeof (int64_t))))
2870                                 return (DDI_PROP_RESULT_ERROR);
2871                 }
2872                 /*
2873                  * Copy the integer, using the implementation-specific
2874                  * copy function if the property is coming from the PROM.
2875                  */
2876                 if (ph->ph_flags & PH_FROM_PROM) {
2877                         return (DDI_PROP_RESULT_ERROR);
2878                 } else {
2879                         bcopy(ph->ph_cur_pos, data, sizeof (int64_t));
2880                 }
2881 
2882                 /*
2883                  * Move the current location to the start of the next
2884                  * bit of undecoded data.
2885                  */
2886                 ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos +
2887                     sizeof (int64_t);
2888                         return (DDI_PROP_RESULT_OK);
2889 
2890         case DDI_PROP_CMD_ENCODE:
2891                 /*
2892                  * Check that there is room to encoded the data
2893                  */
2894                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
2895                     ph->ph_size < sizeof (int64_t) ||
2896                     ((int64_t *)ph->ph_cur_pos > ((int64_t *)ph->ph_data +
2897                     ph->ph_size - sizeof (int64_t))))
2898                         return (DDI_PROP_RESULT_ERROR);
2899 
2900                 /*
2901                  * Encode the integer into the byte stream one byte at a
2902                  * time.
2903                  */
2904                 bcopy(data, ph->ph_cur_pos, sizeof (int64_t));
2905 
2906                 /*
2907                  * Move the current location to the start of the next bit of
2908                  * space where we can store encoded data.
2909                  */
2910                 ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos +
2911                     sizeof (int64_t);
2912                 return (DDI_PROP_RESULT_OK);
2913 
2914         case DDI_PROP_CMD_SKIP:
2915                 /*
2916                  * Check that there is encoded data
2917                  */
2918                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
2919                     ph->ph_size < sizeof (int64_t))
2920                         return (DDI_PROP_RESULT_ERROR);
2921 
2922                 if ((caddr_t)ph->ph_cur_pos ==
2923                     (caddr_t)ph->ph_data + ph->ph_size) {
2924                         return (DDI_PROP_RESULT_EOF);
2925                 } else if ((caddr_t)ph->ph_cur_pos >
2926                     (caddr_t)ph->ph_data + ph->ph_size) {
2927                         return (DDI_PROP_RESULT_EOF);
2928                 }
2929 
2930                 /*
2931                  * Move the current location to the start of
2932                  * the next bit of undecoded data.
2933                  */
2934                 ph->ph_cur_pos = (uchar_t *)ph->ph_cur_pos +
2935                     sizeof (int64_t);
2936                         return (DDI_PROP_RESULT_OK);
2937 
2938         case DDI_PROP_CMD_GET_ESIZE:
2939                 /*
2940                  * Return the size of an encoded integer on OBP
2941                  */
2942                 return (sizeof (int64_t));
2943 
2944         case DDI_PROP_CMD_GET_DSIZE:
2945                 /*
2946                  * Return the size of a decoded integer on the system.
2947                  */
2948                 return (sizeof (int64_t));
2949 
2950         default:
2951 #ifdef DEBUG
2952                 panic("ddi_prop_int64_op: %x impossible", cmd);
2953                 /*NOTREACHED*/
2954 #else
2955                 return (DDI_PROP_RESULT_ERROR);
2956 #endif  /* DEBUG */
2957         }
2958 }
2959 
2960 /*
2961  * OBP 1275 string operator.
2962  *
2963  * OBP strings are NULL terminated.
2964  */
2965 int
2966 ddi_prop_1275_string(prop_handle_t *ph, uint_t cmd, char *data)
2967 {
2968         int     n;
2969         char    *p;
2970         char    *end;
2971 
2972         switch (cmd) {
2973         case DDI_PROP_CMD_DECODE:
2974                 /*
2975                  * Check that there is encoded data
2976                  */
2977                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0) {
2978                         return (DDI_PROP_RESULT_ERROR);
2979                 }
2980 
2981                 /*
2982                  * Match DDI_PROP_CMD_GET_DSIZE logic for when to stop and
2983                  * how to NULL terminate result.
2984                  */
2985                 p = (char *)ph->ph_cur_pos;
2986                 end = (char *)ph->ph_data + ph->ph_size;
2987                 if (p >= end)
2988                         return (DDI_PROP_RESULT_EOF);
2989 
2990                 while (p < end) {
2991                         *data++ = *p;
2992                         if (*p++ == 0) {        /* NULL from OBP */
2993                                 ph->ph_cur_pos = p;
2994                                 return (DDI_PROP_RESULT_OK);
2995                         }
2996                 }
2997 
2998                 /*
2999                  * If OBP did not NULL terminate string, which happens
3000                  * (at least) for 'true'/'false' boolean values, account for
3001                  * the space and store null termination on decode.
3002                  */
3003                 ph->ph_cur_pos = p;
3004                 *data = 0;
3005                 return (DDI_PROP_RESULT_OK);
3006 
3007         case DDI_PROP_CMD_ENCODE:
3008                 /*
3009                  * Check that there is room to encoded the data
3010                  */
3011                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0) {
3012                         return (DDI_PROP_RESULT_ERROR);
3013                 }
3014 
3015                 n = strlen(data) + 1;
3016                 if ((char *)ph->ph_cur_pos > ((char *)ph->ph_data +
3017                     ph->ph_size - n)) {
3018                         return (DDI_PROP_RESULT_ERROR);
3019                 }
3020 
3021                 /*
3022                  * Copy the NULL terminated string
3023                  */
3024                 bcopy(data, ph->ph_cur_pos, n);
3025 
3026                 /*
3027                  * Move the current location to the start of the next bit of
3028                  * space where we can store encoded data.
3029                  */
3030                 ph->ph_cur_pos = (char *)ph->ph_cur_pos + n;
3031                 return (DDI_PROP_RESULT_OK);
3032 
3033         case DDI_PROP_CMD_SKIP:
3034                 /*
3035                  * Check that there is encoded data
3036                  */
3037                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0) {
3038                         return (DDI_PROP_RESULT_ERROR);
3039                 }
3040 
3041                 /*
3042                  * Return the string length plus one for the NULL
3043                  * We know the size of the property, we need to
3044                  * ensure that the string is properly formatted,
3045                  * since we may be looking up random OBP data.
3046                  */
3047                 p = (char *)ph->ph_cur_pos;
3048                 end = (char *)ph->ph_data + ph->ph_size;
3049                 if (p >= end)
3050                         return (DDI_PROP_RESULT_EOF);
3051 
3052                 while (p < end) {
3053                         if (*p++ == 0) {        /* NULL from OBP */
3054                                 ph->ph_cur_pos = p;
3055                                 return (DDI_PROP_RESULT_OK);
3056                         }
3057                 }
3058 
3059                 /*
3060                  * Accommodate the fact that OBP does not always NULL
3061                  * terminate strings.
3062                  */
3063                 ph->ph_cur_pos = p;
3064                 return (DDI_PROP_RESULT_OK);
3065 
3066         case DDI_PROP_CMD_GET_ESIZE:
3067                 /*
3068                  * Return the size of the encoded string on OBP.
3069                  */
3070                 return (strlen(data) + 1);
3071 
3072         case DDI_PROP_CMD_GET_DSIZE:
3073                 /*
3074                  * Return the string length plus one for the NULL.
3075                  * We know the size of the property, we need to
3076                  * ensure that the string is properly formatted,
3077                  * since we may be looking up random OBP data.
3078                  */
3079                 p = (char *)ph->ph_cur_pos;
3080                 end = (char *)ph->ph_data + ph->ph_size;
3081                 if (p >= end)
3082                         return (DDI_PROP_RESULT_EOF);
3083 
3084                 for (n = 0; p < end; n++) {
3085                         if (*p++ == 0) {        /* NULL from OBP */
3086                                 ph->ph_cur_pos = p;
3087                                 return (n + 1);
3088                         }
3089                 }
3090 
3091                 /*
3092                  * If OBP did not NULL terminate string, which happens for
3093                  * 'true'/'false' boolean values, account for the space
3094                  * to store null termination here.
3095                  */
3096                 ph->ph_cur_pos = p;
3097                 return (n + 1);
3098 
3099         default:
3100 #ifdef DEBUG
3101                 panic("ddi_prop_1275_string: %x impossible", cmd);
3102                 /*NOTREACHED*/
3103 #else
3104                 return (DDI_PROP_RESULT_ERROR);
3105 #endif  /* DEBUG */
3106         }
3107 }
3108 
3109 /*
3110  * OBP 1275 byte operator
3111  *
3112  * Caller must specify the number of bytes to get.  OBP encodes bytes
3113  * as a byte so there is a 1-to-1 translation.
3114  */
3115 int
3116 ddi_prop_1275_bytes(prop_handle_t *ph, uint_t cmd, uchar_t *data,
3117         uint_t nelements)
3118 {
3119         switch (cmd) {
3120         case DDI_PROP_CMD_DECODE:
3121                 /*
3122                  * Check that there is encoded data
3123                  */
3124                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
3125                     ph->ph_size < nelements ||
3126                     ((char *)ph->ph_cur_pos > ((char *)ph->ph_data +
3127                     ph->ph_size - nelements)))
3128                         return (DDI_PROP_RESULT_ERROR);
3129 
3130                 /*
3131                  * Copy out the bytes
3132                  */
3133                 bcopy(ph->ph_cur_pos, data, nelements);
3134 
3135                 /*
3136                  * Move the current location
3137                  */
3138                 ph->ph_cur_pos = (char *)ph->ph_cur_pos + nelements;
3139                 return (DDI_PROP_RESULT_OK);
3140 
3141         case DDI_PROP_CMD_ENCODE:
3142                 /*
3143                  * Check that there is room to encode the data
3144                  */
3145                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
3146                     ph->ph_size < nelements ||
3147                     ((char *)ph->ph_cur_pos > ((char *)ph->ph_data +
3148                     ph->ph_size - nelements)))
3149                         return (DDI_PROP_RESULT_ERROR);
3150 
3151                 /*
3152                  * Copy in the bytes
3153                  */
3154                 bcopy(data, ph->ph_cur_pos, nelements);
3155 
3156                 /*
3157                  * Move the current location to the start of the next bit of
3158                  * space where we can store encoded data.
3159                  */
3160                 ph->ph_cur_pos = (char *)ph->ph_cur_pos + nelements;
3161                 return (DDI_PROP_RESULT_OK);
3162 
3163         case DDI_PROP_CMD_SKIP:
3164                 /*
3165                  * Check that there is encoded data
3166                  */
3167                 if (ph->ph_cur_pos == NULL || ph->ph_size == 0 ||
3168                     ph->ph_size < nelements)
3169                         return (DDI_PROP_RESULT_ERROR);
3170 
3171                 if ((char *)ph->ph_cur_pos > ((char *)ph->ph_data +
3172                     ph->ph_size - nelements))
3173                         return (DDI_PROP_RESULT_EOF);
3174 
3175                 /*
3176                  * Move the current location
3177                  */
3178                 ph->ph_cur_pos = (char *)ph->ph_cur_pos + nelements;
3179                 return (DDI_PROP_RESULT_OK);
3180 
3181         case DDI_PROP_CMD_GET_ESIZE:
3182                 /*
3183                  * The size in bytes of the encoded size is the
3184                  * same as the decoded size provided by the caller.
3185                  */
3186                 return (nelements);
3187 
3188         case DDI_PROP_CMD_GET_DSIZE:
3189                 /*
3190                  * Just return the number of bytes specified by the caller.
3191                  */
3192                 return (nelements);
3193 
3194         default:
3195 #ifdef DEBUG
3196                 panic("ddi_prop_1275_bytes: %x impossible", cmd);
3197                 /*NOTREACHED*/
3198 #else
3199                 return (DDI_PROP_RESULT_ERROR);
3200 #endif  /* DEBUG */
3201         }
3202 }
3203 
3204 /*
3205  * Used for properties that come from the OBP, hardware configuration files,
3206  * or that are created by calls to ddi_prop_update(9F).
3207  */
3208 static struct prop_handle_ops prop_1275_ops = {
3209         ddi_prop_1275_int,
3210         ddi_prop_1275_string,
3211         ddi_prop_1275_bytes,
3212         ddi_prop_int64_op
3213 };
3214 
3215 
3216 /*
3217  * Interface to create/modify a managed property on child's behalf...
3218  * Flags interpreted are:
3219  *      DDI_PROP_CANSLEEP:      Allow memory allocation to sleep.
3220  *      DDI_PROP_SYSTEM_DEF:    Manipulate system list rather than driver list.
3221  *
3222  * Use same dev_t when modifying or undefining a property.
3223  * Search for properties with DDI_DEV_T_ANY to match first named
3224  * property on the list.
3225  *
3226  * Properties are stored LIFO and subsequently will match the first
3227  * `matching' instance.
3228  */
3229 
3230 /*
3231  * ddi_prop_add:        Add a software defined property
3232  */
3233 
3234 /*
3235  * define to get a new ddi_prop_t.
3236  * km_flags are KM_SLEEP or KM_NOSLEEP.
3237  */
3238 
3239 #define DDI_NEW_PROP_T(km_flags)        \
3240         (kmem_zalloc(sizeof (ddi_prop_t), km_flags))
3241 
3242 static int
3243 ddi_prop_add(dev_t dev, dev_info_t *dip, int flags,
3244     char *name, caddr_t value, int length)
3245 {
3246         ddi_prop_t      *new_propp, *propp;
3247         ddi_prop_t      **list_head = &(DEVI(dip)->devi_drv_prop_ptr);
3248         int             km_flags = KM_NOSLEEP;
3249         int             name_buf_len;
3250 
3251         /*
3252          * If dev_t is DDI_DEV_T_ANY or name's length is zero return error.
3253          */
3254 
3255         if (dev == DDI_DEV_T_ANY || name == (char *)0 || strlen(name) == 0)
3256                 return (DDI_PROP_INVAL_ARG);
3257 
3258         if (flags & DDI_PROP_CANSLEEP)
3259                 km_flags = KM_SLEEP;
3260 
3261         if (flags & DDI_PROP_SYSTEM_DEF)
3262                 list_head = &(DEVI(dip)->devi_sys_prop_ptr);
3263         else if (flags & DDI_PROP_HW_DEF)
3264                 list_head = &(DEVI(dip)->devi_hw_prop_ptr);
3265 
3266         if ((new_propp = DDI_NEW_PROP_T(km_flags)) == NULL)  {
3267                 cmn_err(CE_CONT, prop_no_mem_msg, name);
3268                 return (DDI_PROP_NO_MEMORY);
3269         }
3270 
3271         /*
3272          * If dev is major number 0, then we need to do a ddi_name_to_major
3273          * to get the real major number for the device.  This needs to be
3274          * done because some drivers need to call ddi_prop_create in their
3275          * attach routines but they don't have a dev.  By creating the dev
3276          * ourself if the major number is 0, drivers will not have to know what
3277          * their major number.  They can just create a dev with major number
3278          * 0 and pass it in.  For device 0, we will be doing a little extra
3279          * work by recreating the same dev that we already have, but its the
3280          * price you pay :-).
3281          *
3282          * This fixes bug #1098060.
3283          */
3284         if (getmajor(dev) == DDI_MAJOR_T_UNKNOWN) {
3285                 new_propp->prop_dev =
3286                     makedevice(ddi_name_to_major(DEVI(dip)->devi_binding_name),
3287                     getminor(dev));
3288         } else
3289                 new_propp->prop_dev = dev;
3290 
3291         /*
3292          * Allocate space for property name and copy it in...
3293          */
3294 
3295         name_buf_len = strlen(name) + 1;
3296         new_propp->prop_name = kmem_alloc(name_buf_len, km_flags);
3297         if (new_propp->prop_name == 0)       {
3298                 kmem_free(new_propp, sizeof (ddi_prop_t));
3299                 cmn_err(CE_CONT, prop_no_mem_msg, name);
3300                 return (DDI_PROP_NO_MEMORY);
3301         }
3302         bcopy(name, new_propp->prop_name, name_buf_len);
3303 
3304         /*
3305          * Set the property type
3306          */
3307         new_propp->prop_flags = flags & DDI_PROP_TYPE_MASK;
3308 
3309         /*
3310          * Set length and value ONLY if not an explicit property undefine:
3311          * NOTE: value and length are zero for explicit undefines.
3312          */
3313 
3314         if (flags & DDI_PROP_UNDEF_IT) {
3315                 new_propp->prop_flags |= DDI_PROP_UNDEF_IT;
3316         } else {
3317                 if ((new_propp->prop_len = length) != 0) {
3318                         new_propp->prop_val = kmem_alloc(length, km_flags);
3319                         if (new_propp->prop_val == 0)  {
3320                                 kmem_free(new_propp->prop_name, name_buf_len);
3321                                 kmem_free(new_propp, sizeof (ddi_prop_t));
3322                                 cmn_err(CE_CONT, prop_no_mem_msg, name);
3323                                 return (DDI_PROP_NO_MEMORY);
3324                         }
3325                         bcopy(value, new_propp->prop_val, length);
3326                 }
3327         }
3328 
3329         /*
3330          * Link property into beginning of list. (Properties are LIFO order.)
3331          */
3332 
3333         mutex_enter(&(DEVI(dip)->devi_lock));
3334         propp = *list_head;
3335         new_propp->prop_next = propp;
3336         *list_head = new_propp;
3337         mutex_exit(&(DEVI(dip)->devi_lock));
3338         return (DDI_PROP_SUCCESS);
3339 }
3340 
3341 
3342 /*
3343  * ddi_prop_change:     Modify a software managed property value
3344  *
3345  *                      Set new length and value if found.
3346  *                      returns DDI_PROP_INVAL_ARG if dev is DDI_DEV_T_ANY or
3347  *                      input name is the NULL string.
3348  *                      returns DDI_PROP_NO_MEMORY if unable to allocate memory
3349  *
3350  *                      Note: an undef can be modified to be a define,
3351  *                      (you can't go the other way.)
3352  */
3353 
3354 static int
3355 ddi_prop_change(dev_t dev, dev_info_t *dip, int flags,
3356     char *name, caddr_t value, int length)
3357 {
3358         ddi_prop_t      *propp;
3359         ddi_prop_t      **ppropp;
3360         caddr_t         p = NULL;
3361 
3362         if ((dev == DDI_DEV_T_ANY) || (name == NULL) || (strlen(name) == 0))
3363                 return (DDI_PROP_INVAL_ARG);
3364 
3365         /*
3366          * Preallocate buffer, even if we don't need it...
3367          */
3368         if (length != 0)  {
3369                 p = kmem_alloc(length, (flags & DDI_PROP_CANSLEEP) ?
3370                     KM_SLEEP : KM_NOSLEEP);
3371                 if (p == NULL)  {
3372                         cmn_err(CE_CONT, prop_no_mem_msg, name);
3373                         return (DDI_PROP_NO_MEMORY);
3374                 }
3375         }
3376 
3377         /*
3378          * If the dev_t value contains DDI_MAJOR_T_UNKNOWN for the major
3379          * number, a real dev_t value should be created based upon the dip's
3380          * binding driver.  See ddi_prop_add...
3381          */
3382         if (getmajor(dev) == DDI_MAJOR_T_UNKNOWN)
3383                 dev = makedevice(
3384                     ddi_name_to_major(DEVI(dip)->devi_binding_name),
3385                     getminor(dev));
3386 
3387         /*
3388          * Check to see if the property exists.  If so we modify it.
3389          * Else we create it by calling ddi_prop_add().
3390          */
3391         mutex_enter(&(DEVI(dip)->devi_lock));
3392         ppropp = &DEVI(dip)->devi_drv_prop_ptr;
3393         if (flags & DDI_PROP_SYSTEM_DEF)
3394                 ppropp = &DEVI(dip)->devi_sys_prop_ptr;
3395         else if (flags & DDI_PROP_HW_DEF)
3396                 ppropp = &DEVI(dip)->devi_hw_prop_ptr;
3397 
3398         if ((propp = i_ddi_prop_search(dev, name, flags, ppropp)) != NULL) {
3399                 /*
3400                  * Need to reallocate buffer?  If so, do it
3401                  * carefully (reuse same space if new prop
3402                  * is same size and non-NULL sized).
3403                  */
3404                 if (length != 0)
3405                         bcopy(value, p, length);
3406 
3407                 if (propp->prop_len != 0)
3408                         kmem_free(propp->prop_val, propp->prop_len);
3409 
3410                 propp->prop_len = length;
3411                 propp->prop_val = p;
3412                 propp->prop_flags &= ~DDI_PROP_UNDEF_IT;
3413                 mutex_exit(&(DEVI(dip)->devi_lock));
3414                 return (DDI_PROP_SUCCESS);
3415         }
3416 
3417         mutex_exit(&(DEVI(dip)->devi_lock));
3418         if (length != 0)
3419                 kmem_free(p, length);
3420 
3421         return (ddi_prop_add(dev, dip, flags, name, value, length));
3422 }
3423 
3424 /*
3425  * Common update routine used to update and encode a property.  Creates
3426  * a property handle, calls the property encode routine, figures out if
3427  * the property already exists and updates if it does.  Otherwise it
3428  * creates if it does not exist.
3429  */
3430 int
3431 ddi_prop_update_common(dev_t match_dev, dev_info_t *dip, int flags,
3432     char *name, void *data, uint_t nelements,
3433     int (*prop_create)(prop_handle_t *, void *data, uint_t nelements))
3434 {
3435         prop_handle_t   ph;
3436         int             rval;
3437         uint_t          ourflags;
3438 
3439         /*
3440          * If dev_t is DDI_DEV_T_ANY or name's length is zero,
3441          * return error.
3442          */
3443         if (match_dev == DDI_DEV_T_ANY || name == NULL || strlen(name) == 0)
3444                 return (DDI_PROP_INVAL_ARG);
3445 
3446         /*
3447          * Create the handle
3448          */
3449         ph.ph_data = NULL;
3450         ph.ph_cur_pos = NULL;
3451         ph.ph_save_pos = NULL;
3452         ph.ph_size = 0;
3453         ph.ph_ops = &prop_1275_ops;
3454 
3455         /*
3456          * ourflags:
3457          * For compatibility with the old interfaces.  The old interfaces
3458          * didn't sleep by default and slept when the flag was set.  These
3459          * interfaces to the opposite.  So the old interfaces now set the
3460          * DDI_PROP_DONTSLEEP flag by default which tells us not to sleep.
3461          *
3462          * ph.ph_flags:
3463          * Blocked data or unblocked data allocation
3464          * for ph.ph_data in ddi_prop_encode_alloc()
3465          */
3466         if (flags & DDI_PROP_DONTSLEEP) {
3467                 ourflags = flags;
3468                 ph.ph_flags = DDI_PROP_DONTSLEEP;
3469         } else {
3470                 ourflags = flags | DDI_PROP_CANSLEEP;
3471                 ph.ph_flags = DDI_PROP_CANSLEEP;
3472         }
3473 
3474         /*
3475          * Encode the data and store it in the property handle by
3476          * calling the prop_encode routine.
3477          */
3478         if ((rval = (*prop_create)(&ph, data, nelements)) !=
3479             DDI_PROP_SUCCESS) {
3480                 if (rval == DDI_PROP_NO_MEMORY)
3481                         cmn_err(CE_CONT, prop_no_mem_msg, name);
3482                 if (ph.ph_size != 0)
3483                         kmem_free(ph.ph_data, ph.ph_size);
3484                 return (rval);
3485         }
3486 
3487         /*
3488          * The old interfaces use a stacking approach to creating
3489          * properties.  If we are being called from the old interfaces,
3490          * the DDI_PROP_STACK_CREATE flag will be set, so we just do a
3491          * create without checking.
3492          */
3493         if (flags & DDI_PROP_STACK_CREATE) {
3494                 rval = ddi_prop_add(match_dev, dip,
3495                     ourflags, name, ph.ph_data, ph.ph_size);
3496         } else {
3497                 rval = ddi_prop_change(match_dev, dip,
3498                     ourflags, name, ph.ph_data, ph.ph_size);
3499         }
3500 
3501         /*
3502          * Free the encoded data allocated in the prop_encode routine.
3503          */
3504         if (ph.ph_size != 0)
3505                 kmem_free(ph.ph_data, ph.ph_size);
3506 
3507         return (rval);
3508 }
3509 
3510 
3511 /*
3512  * ddi_prop_create:     Define a managed property:
3513  *                      See above for details.
3514  */
3515 
3516 int
3517 ddi_prop_create(dev_t dev, dev_info_t *dip, int flag,
3518     char *name, caddr_t value, int length)
3519 {
3520         if (!(flag & DDI_PROP_CANSLEEP)) {
3521                 flag |= DDI_PROP_DONTSLEEP;
3522 #ifdef DDI_PROP_DEBUG
3523                 if (length != 0)
3524                         cmn_err(CE_NOTE, "!ddi_prop_create: interface obsolete,"
3525                             "use ddi_prop_update (prop = %s, node = %s%d)",
3526                             name, ddi_driver_name(dip), ddi_get_instance(dip));
3527 #endif /* DDI_PROP_DEBUG */
3528         }
3529         flag &= ~DDI_PROP_SYSTEM_DEF;
3530         flag |= DDI_PROP_STACK_CREATE | DDI_PROP_TYPE_ANY;
3531         return (ddi_prop_update_common(dev, dip, flag, name,
3532             value, length, ddi_prop_fm_encode_bytes));
3533 }
3534 
3535 int
3536 e_ddi_prop_create(dev_t dev, dev_info_t *dip, int flag,
3537     char *name, caddr_t value, int length)
3538 {
3539         if (!(flag & DDI_PROP_CANSLEEP))
3540                 flag |= DDI_PROP_DONTSLEEP;
3541         flag |= DDI_PROP_SYSTEM_DEF | DDI_PROP_STACK_CREATE | DDI_PROP_TYPE_ANY;
3542         return (ddi_prop_update_common(dev, dip, flag,
3543             name, value, length, ddi_prop_fm_encode_bytes));
3544 }
3545 
3546 int
3547 ddi_prop_modify(dev_t dev, dev_info_t *dip, int flag,
3548     char *name, caddr_t value, int length)
3549 {
3550         ASSERT((flag & DDI_PROP_TYPE_MASK) == 0);
3551 
3552         /*
3553          * If dev_t is DDI_DEV_T_ANY or name's length is zero,
3554          * return error.
3555          */
3556         if (dev == DDI_DEV_T_ANY || name == NULL || strlen(name) == 0)
3557                 return (DDI_PROP_INVAL_ARG);
3558 
3559         if (!(flag & DDI_PROP_CANSLEEP))
3560                 flag |= DDI_PROP_DONTSLEEP;
3561         flag &= ~DDI_PROP_SYSTEM_DEF;
3562         if (ddi_prop_exists(dev, dip, (flag | DDI_PROP_NOTPROM), name) == 0)
3563                 return (DDI_PROP_NOT_FOUND);
3564 
3565         return (ddi_prop_update_common(dev, dip,
3566             (flag | DDI_PROP_TYPE_BYTE), name,
3567             value, length, ddi_prop_fm_encode_bytes));
3568 }
3569 
3570 int
3571 e_ddi_prop_modify(dev_t dev, dev_info_t *dip, int flag,
3572     char *name, caddr_t value, int length)
3573 {
3574         ASSERT((flag & DDI_PROP_TYPE_MASK) == 0);
3575 
3576         /*
3577          * If dev_t is DDI_DEV_T_ANY or name's length is zero,
3578          * return error.
3579          */
3580         if (dev == DDI_DEV_T_ANY || name == NULL || strlen(name) == 0)
3581                 return (DDI_PROP_INVAL_ARG);
3582 
3583         if (ddi_prop_exists(dev, dip, (flag | DDI_PROP_SYSTEM_DEF), name) == 0)
3584                 return (DDI_PROP_NOT_FOUND);
3585 
3586         if (!(flag & DDI_PROP_CANSLEEP))
3587                 flag |= DDI_PROP_DONTSLEEP;
3588         return (ddi_prop_update_common(dev, dip,
3589             (flag | DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_BYTE),
3590             name, value, length, ddi_prop_fm_encode_bytes));
3591 }
3592 
3593 
3594 /*
3595  * Common lookup routine used to lookup and decode a property.
3596  * Creates a property handle, searches for the raw encoded data,
3597  * fills in the handle, and calls the property decode functions
3598  * passed in.
3599  *
3600  * This routine is not static because ddi_bus_prop_op() which lives in
3601  * ddi_impl.c calls it.  No driver should be calling this routine.
3602  */
3603 int
3604 ddi_prop_lookup_common(dev_t match_dev, dev_info_t *dip,
3605     uint_t flags, char *name, void *data, uint_t *nelements,
3606     int (*prop_decoder)(prop_handle_t *, void *data, uint_t *nelements))
3607 {
3608         int             rval;
3609         uint_t          ourflags;
3610         prop_handle_t   ph;
3611 
3612         if ((match_dev == DDI_DEV_T_NONE) ||
3613             (name == NULL) || (strlen(name) == 0))
3614                 return (DDI_PROP_INVAL_ARG);
3615 
3616         ourflags = (flags & DDI_PROP_DONTSLEEP) ? flags :
3617             flags | DDI_PROP_CANSLEEP;
3618 
3619         /*
3620          * Get the encoded data
3621          */
3622         bzero(&ph, sizeof (prop_handle_t));
3623 
3624         if ((flags & DDI_UNBND_DLPI2) || (flags & DDI_PROP_ROOTNEX_GLOBAL)) {
3625                 /*
3626                  * For rootnex and unbound dlpi style-2 devices, index into
3627                  * the devnames' array and search the global
3628                  * property list.
3629                  */
3630                 ourflags &= ~DDI_UNBND_DLPI2;
3631                 rval = i_ddi_prop_search_global(match_dev,
3632                     ourflags, name, &ph.ph_data, &ph.ph_size);
3633         } else {
3634                 rval = ddi_prop_search_common(match_dev, dip,
3635                     PROP_LEN_AND_VAL_ALLOC, ourflags, name,
3636                     &ph.ph_data, &ph.ph_size);
3637 
3638         }
3639 
3640         if (rval != DDI_PROP_SUCCESS && rval != DDI_PROP_FOUND_1275) {
3641                 ASSERT(ph.ph_data == NULL);
3642                 ASSERT(ph.ph_size == 0);
3643                 return (rval);
3644         }
3645 
3646         /*
3647          * If the encoded data came from a OBP or software
3648          * use the 1275 OBP decode/encode routines.
3649          */
3650         ph.ph_cur_pos = ph.ph_data;
3651         ph.ph_save_pos = ph.ph_data;
3652         ph.ph_ops = &prop_1275_ops;
3653         ph.ph_flags = (rval == DDI_PROP_FOUND_1275) ? PH_FROM_PROM : 0;
3654 
3655         rval = (*prop_decoder)(&ph, data, nelements);
3656 
3657         /*
3658          * Free the encoded data
3659          */
3660         if (ph.ph_size != 0)
3661                 kmem_free(ph.ph_data, ph.ph_size);
3662 
3663         return (rval);
3664 }
3665 
3666 /*
3667  * Lookup and return an array of composite properties.  The driver must
3668  * provide the decode routine.
3669  */
3670 int
3671 ddi_prop_lookup(dev_t match_dev, dev_info_t *dip,
3672     uint_t flags, char *name, void *data, uint_t *nelements,
3673     int (*prop_decoder)(prop_handle_t *, void *data, uint_t *nelements))
3674 {
3675         return (ddi_prop_lookup_common(match_dev, dip,
3676             (flags | DDI_PROP_TYPE_COMPOSITE), name,
3677             data, nelements, prop_decoder));
3678 }
3679 
3680 /*
3681  * Return 1 if a property exists (no type checking done).
3682  * Return 0 if it does not exist.
3683  */
3684 int
3685 ddi_prop_exists(dev_t match_dev, dev_info_t *dip, uint_t flags, char *name)
3686 {
3687         int     i;
3688         uint_t  x = 0;
3689 
3690         i = ddi_prop_search_common(match_dev, dip, PROP_EXISTS,
3691             flags | DDI_PROP_TYPE_MASK, name, NULL, &x);
3692         return (i == DDI_PROP_SUCCESS || i == DDI_PROP_FOUND_1275);
3693 }
3694 
3695 
3696 /*
3697  * Update an array of composite properties.  The driver must
3698  * provide the encode routine.
3699  */
3700 int
3701 ddi_prop_update(dev_t match_dev, dev_info_t *dip,
3702     char *name, void *data, uint_t nelements,
3703     int (*prop_create)(prop_handle_t *, void *data, uint_t nelements))
3704 {
3705         return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_COMPOSITE,
3706             name, data, nelements, prop_create));
3707 }
3708 
3709 /*
3710  * Get a single integer or boolean property and return it.
3711  * If the property does not exists, or cannot be decoded,
3712  * then return the defvalue passed in.
3713  *
3714  * This routine always succeeds.
3715  */
3716 int
3717 ddi_prop_get_int(dev_t match_dev, dev_info_t *dip, uint_t flags,
3718     char *name, int defvalue)
3719 {
3720         int     data;
3721         uint_t  nelements;
3722         int     rval;
3723 
3724         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3725             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
3726 #ifdef DEBUG
3727                 if (dip != NULL) {
3728                         cmn_err(CE_WARN, "ddi_prop_get_int: invalid flag"
3729                             " 0x%x (prop = %s, node = %s%d)", flags,
3730                             name, ddi_driver_name(dip), ddi_get_instance(dip));
3731                 }
3732 #endif /* DEBUG */
3733                 flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3734                     LDI_DEV_T_ANY | DDI_UNBND_DLPI2;
3735         }
3736 
3737         if ((rval = ddi_prop_lookup_common(match_dev, dip,
3738             (flags | DDI_PROP_TYPE_INT), name, &data, &nelements,
3739             ddi_prop_fm_decode_int)) != DDI_PROP_SUCCESS) {
3740                 if (rval == DDI_PROP_END_OF_DATA)
3741                         data = 1;
3742                 else
3743                         data = defvalue;
3744         }
3745         return (data);
3746 }
3747 
3748 /*
3749  * Get a single 64 bit integer or boolean property and return it.
3750  * If the property does not exists, or cannot be decoded,
3751  * then return the defvalue passed in.
3752  *
3753  * This routine always succeeds.
3754  */
3755 int64_t
3756 ddi_prop_get_int64(dev_t match_dev, dev_info_t *dip, uint_t flags,
3757     char *name, int64_t defvalue)
3758 {
3759         int64_t data;
3760         uint_t  nelements;
3761         int     rval;
3762 
3763         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3764             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
3765 #ifdef DEBUG
3766                 if (dip != NULL) {
3767                         cmn_err(CE_WARN, "ddi_prop_get_int64: invalid flag"
3768                             " 0x%x (prop = %s, node = %s%d)", flags,
3769                             name, ddi_driver_name(dip), ddi_get_instance(dip));
3770                 }
3771 #endif /* DEBUG */
3772                 return (DDI_PROP_INVAL_ARG);
3773         }
3774 
3775         if ((rval = ddi_prop_lookup_common(match_dev, dip,
3776             (flags | DDI_PROP_TYPE_INT64 | DDI_PROP_NOTPROM),
3777             name, &data, &nelements, ddi_prop_fm_decode_int64))
3778             != DDI_PROP_SUCCESS) {
3779                 if (rval == DDI_PROP_END_OF_DATA)
3780                         data = 1;
3781                 else
3782                         data = defvalue;
3783         }
3784         return (data);
3785 }
3786 
3787 /*
3788  * Get an array of integer property
3789  */
3790 int
3791 ddi_prop_lookup_int_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
3792     char *name, int **data, uint_t *nelements)
3793 {
3794         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3795             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
3796 #ifdef DEBUG
3797                 if (dip != NULL) {
3798                         cmn_err(CE_WARN, "ddi_prop_lookup_int_array: "
3799                             "invalid flag 0x%x (prop = %s, node = %s%d)",
3800                             flags, name, ddi_driver_name(dip),
3801                             ddi_get_instance(dip));
3802                 }
3803 #endif /* DEBUG */
3804                 flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3805                     LDI_DEV_T_ANY | DDI_UNBND_DLPI2;
3806         }
3807 
3808         return (ddi_prop_lookup_common(match_dev, dip,
3809             (flags | DDI_PROP_TYPE_INT), name, data,
3810             nelements, ddi_prop_fm_decode_ints));
3811 }
3812 
3813 /*
3814  * Get an array of 64 bit integer properties
3815  */
3816 int
3817 ddi_prop_lookup_int64_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
3818     char *name, int64_t **data, uint_t *nelements)
3819 {
3820         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3821             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
3822 #ifdef DEBUG
3823                 if (dip != NULL) {
3824                         cmn_err(CE_WARN, "ddi_prop_lookup_int64_array: "
3825                             "invalid flag 0x%x (prop = %s, node = %s%d)",
3826                             flags, name, ddi_driver_name(dip),
3827                             ddi_get_instance(dip));
3828                 }
3829 #endif /* DEBUG */
3830                 return (DDI_PROP_INVAL_ARG);
3831         }
3832 
3833         return (ddi_prop_lookup_common(match_dev, dip,
3834             (flags | DDI_PROP_TYPE_INT64 | DDI_PROP_NOTPROM),
3835             name, data, nelements, ddi_prop_fm_decode_int64_array));
3836 }
3837 
3838 /*
3839  * Update a single integer property.  If the property exists on the drivers
3840  * property list it updates, else it creates it.
3841  */
3842 int
3843 ddi_prop_update_int(dev_t match_dev, dev_info_t *dip,
3844     char *name, int data)
3845 {
3846         return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT,
3847             name, &data, 1, ddi_prop_fm_encode_ints));
3848 }
3849 
3850 /*
3851  * Update a single 64 bit integer property.
3852  * Update the driver property list if it exists, else create it.
3853  */
3854 int
3855 ddi_prop_update_int64(dev_t match_dev, dev_info_t *dip,
3856     char *name, int64_t data)
3857 {
3858         return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT64,
3859             name, &data, 1, ddi_prop_fm_encode_int64));
3860 }
3861 
3862 int
3863 e_ddi_prop_update_int(dev_t match_dev, dev_info_t *dip,
3864     char *name, int data)
3865 {
3866         return (ddi_prop_update_common(match_dev, dip,
3867             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT,
3868             name, &data, 1, ddi_prop_fm_encode_ints));
3869 }
3870 
3871 int
3872 e_ddi_prop_update_int64(dev_t match_dev, dev_info_t *dip,
3873     char *name, int64_t data)
3874 {
3875         return (ddi_prop_update_common(match_dev, dip,
3876             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT64,
3877             name, &data, 1, ddi_prop_fm_encode_int64));
3878 }
3879 
3880 /*
3881  * Update an array of integer property.  If the property exists on the drivers
3882  * property list it updates, else it creates it.
3883  */
3884 int
3885 ddi_prop_update_int_array(dev_t match_dev, dev_info_t *dip,
3886     char *name, int *data, uint_t nelements)
3887 {
3888         return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT,
3889             name, data, nelements, ddi_prop_fm_encode_ints));
3890 }
3891 
3892 /*
3893  * Update an array of 64 bit integer properties.
3894  * Update the driver property list if it exists, else create it.
3895  */
3896 int
3897 ddi_prop_update_int64_array(dev_t match_dev, dev_info_t *dip,
3898     char *name, int64_t *data, uint_t nelements)
3899 {
3900         return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_INT64,
3901             name, data, nelements, ddi_prop_fm_encode_int64));
3902 }
3903 
3904 int
3905 e_ddi_prop_update_int64_array(dev_t match_dev, dev_info_t *dip,
3906     char *name, int64_t *data, uint_t nelements)
3907 {
3908         return (ddi_prop_update_common(match_dev, dip,
3909             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT64,
3910             name, data, nelements, ddi_prop_fm_encode_int64));
3911 }
3912 
3913 int
3914 e_ddi_prop_update_int_array(dev_t match_dev, dev_info_t *dip,
3915     char *name, int *data, uint_t nelements)
3916 {
3917         return (ddi_prop_update_common(match_dev, dip,
3918             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_INT,
3919             name, data, nelements, ddi_prop_fm_encode_ints));
3920 }
3921 
3922 /*
3923  * Get a single string property.
3924  */
3925 int
3926 ddi_prop_lookup_string(dev_t match_dev, dev_info_t *dip, uint_t flags,
3927     char *name, char **data)
3928 {
3929         uint_t x;
3930 
3931         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3932             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
3933 #ifdef DEBUG
3934                 if (dip != NULL) {
3935                         cmn_err(CE_WARN, "%s: invalid flag 0x%x "
3936                             "(prop = %s, node = %s%d); invalid bits ignored",
3937                             "ddi_prop_lookup_string", flags, name,
3938                             ddi_driver_name(dip), ddi_get_instance(dip));
3939                 }
3940 #endif /* DEBUG */
3941                 flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3942                     LDI_DEV_T_ANY | DDI_UNBND_DLPI2;
3943         }
3944 
3945         return (ddi_prop_lookup_common(match_dev, dip,
3946             (flags | DDI_PROP_TYPE_STRING), name, data,
3947             &x, ddi_prop_fm_decode_string));
3948 }
3949 
3950 /*
3951  * Get an array of strings property.
3952  */
3953 int
3954 ddi_prop_lookup_string_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
3955     char *name, char ***data, uint_t *nelements)
3956 {
3957         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3958             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
3959 #ifdef DEBUG
3960                 if (dip != NULL) {
3961                         cmn_err(CE_WARN, "ddi_prop_lookup_string_array: "
3962                             "invalid flag 0x%x (prop = %s, node = %s%d)",
3963                             flags, name, ddi_driver_name(dip),
3964                             ddi_get_instance(dip));
3965                 }
3966 #endif /* DEBUG */
3967                 flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
3968                     LDI_DEV_T_ANY | DDI_UNBND_DLPI2;
3969         }
3970 
3971         return (ddi_prop_lookup_common(match_dev, dip,
3972             (flags | DDI_PROP_TYPE_STRING), name, data,
3973             nelements, ddi_prop_fm_decode_strings));
3974 }
3975 
3976 /*
3977  * Update a single string property.
3978  */
3979 int
3980 ddi_prop_update_string(dev_t match_dev, dev_info_t *dip,
3981     char *name, char *data)
3982 {
3983         return (ddi_prop_update_common(match_dev, dip,
3984             DDI_PROP_TYPE_STRING, name, &data, 1,
3985             ddi_prop_fm_encode_string));
3986 }
3987 
3988 int
3989 e_ddi_prop_update_string(dev_t match_dev, dev_info_t *dip,
3990     char *name, char *data)
3991 {
3992         return (ddi_prop_update_common(match_dev, dip,
3993             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_STRING,
3994             name, &data, 1, ddi_prop_fm_encode_string));
3995 }
3996 
3997 
3998 /*
3999  * Update an array of strings property.
4000  */
4001 int
4002 ddi_prop_update_string_array(dev_t match_dev, dev_info_t *dip,
4003     char *name, char **data, uint_t nelements)
4004 {
4005         return (ddi_prop_update_common(match_dev, dip,
4006             DDI_PROP_TYPE_STRING, name, data, nelements,
4007             ddi_prop_fm_encode_strings));
4008 }
4009 
4010 int
4011 e_ddi_prop_update_string_array(dev_t match_dev, dev_info_t *dip,
4012     char *name, char **data, uint_t nelements)
4013 {
4014         return (ddi_prop_update_common(match_dev, dip,
4015             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_STRING,
4016             name, data, nelements,
4017             ddi_prop_fm_encode_strings));
4018 }
4019 
4020 
4021 /*
4022  * Get an array of bytes property.
4023  */
4024 int
4025 ddi_prop_lookup_byte_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
4026     char *name, uchar_t **data, uint_t *nelements)
4027 {
4028         if (flags & ~(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
4029             LDI_DEV_T_ANY | DDI_UNBND_DLPI2 | DDI_PROP_ROOTNEX_GLOBAL)) {
4030 #ifdef DEBUG
4031                 if (dip != NULL) {
4032                         cmn_err(CE_WARN, "ddi_prop_lookup_byte_array: "
4033                             " invalid flag 0x%x (prop = %s, node = %s%d)",
4034                             flags, name, ddi_driver_name(dip),
4035                             ddi_get_instance(dip));
4036                 }
4037 #endif /* DEBUG */
4038                 flags &= DDI_PROP_DONTPASS | DDI_PROP_NOTPROM |
4039                     LDI_DEV_T_ANY | DDI_UNBND_DLPI2;
4040         }
4041 
4042         return (ddi_prop_lookup_common(match_dev, dip,
4043             (flags | DDI_PROP_TYPE_BYTE), name, data,
4044             nelements, ddi_prop_fm_decode_bytes));
4045 }
4046 
4047 /*
4048  * Update an array of bytes property.
4049  */
4050 int
4051 ddi_prop_update_byte_array(dev_t match_dev, dev_info_t *dip,
4052     char *name, uchar_t *data, uint_t nelements)
4053 {
4054         if (nelements == 0)
4055                 return (DDI_PROP_INVAL_ARG);
4056 
4057         return (ddi_prop_update_common(match_dev, dip, DDI_PROP_TYPE_BYTE,
4058             name, data, nelements, ddi_prop_fm_encode_bytes));
4059 }
4060 
4061 
4062 int
4063 e_ddi_prop_update_byte_array(dev_t match_dev, dev_info_t *dip,
4064     char *name, uchar_t *data, uint_t nelements)
4065 {
4066         if (nelements == 0)
4067                 return (DDI_PROP_INVAL_ARG);
4068 
4069         return (ddi_prop_update_common(match_dev, dip,
4070             DDI_PROP_SYSTEM_DEF | DDI_PROP_TYPE_BYTE,
4071             name, data, nelements, ddi_prop_fm_encode_bytes));
4072 }
4073 
4074 
4075 /*
4076  * ddi_prop_remove_common:      Undefine a managed property:
4077  *                      Input dev_t must match dev_t when defined.
4078  *                      Returns DDI_PROP_NOT_FOUND, possibly.
4079  *                      DDI_PROP_INVAL_ARG is also possible if dev is
4080  *                      DDI_DEV_T_ANY or incoming name is the NULL string.
4081  */
4082 int
4083 ddi_prop_remove_common(dev_t dev, dev_info_t *dip, char *name, int flag)
4084 {
4085         ddi_prop_t      **list_head = &(DEVI(dip)->devi_drv_prop_ptr);
4086         ddi_prop_t      *propp;
4087         ddi_prop_t      *lastpropp = NULL;
4088 
4089         if ((dev == DDI_DEV_T_ANY) || (name == (char *)0) ||
4090             (strlen(name) == 0)) {
4091                 return (DDI_PROP_INVAL_ARG);
4092         }
4093 
4094         if (flag & DDI_PROP_SYSTEM_DEF)
4095                 list_head = &(DEVI(dip)->devi_sys_prop_ptr);
4096         else if (flag & DDI_PROP_HW_DEF)
4097                 list_head = &(DEVI(dip)->devi_hw_prop_ptr);
4098 
4099         mutex_enter(&(DEVI(dip)->devi_lock));
4100 
4101         for (propp = *list_head; propp != NULL; propp = propp->prop_next)  {
4102                 if (DDI_STRSAME(propp->prop_name, name) &&
4103                     (dev == propp->prop_dev)) {
4104                         /*
4105                          * Unlink this propp allowing for it to
4106                          * be first in the list:
4107                          */
4108 
4109                         if (lastpropp == NULL)
4110                                 *list_head = propp->prop_next;
4111                         else
4112                                 lastpropp->prop_next = propp->prop_next;
4113 
4114                         mutex_exit(&(DEVI(dip)->devi_lock));
4115 
4116                         /*
4117                          * Free memory and return...
4118                          */
4119                         kmem_free(propp->prop_name,
4120                             strlen(propp->prop_name) + 1);
4121                         if (propp->prop_len != 0)
4122                                 kmem_free(propp->prop_val, propp->prop_len);
4123                         kmem_free(propp, sizeof (ddi_prop_t));
4124                         return (DDI_PROP_SUCCESS);
4125                 }
4126                 lastpropp = propp;
4127         }
4128         mutex_exit(&(DEVI(dip)->devi_lock));
4129         return (DDI_PROP_NOT_FOUND);
4130 }
4131 
4132 int
4133 ddi_prop_remove(dev_t dev, dev_info_t *dip, char *name)
4134 {
4135         return (ddi_prop_remove_common(dev, dip, name, 0));
4136 }
4137 
4138 int
4139 e_ddi_prop_remove(dev_t dev, dev_info_t *dip, char *name)
4140 {
4141         return (ddi_prop_remove_common(dev, dip, name, DDI_PROP_SYSTEM_DEF));
4142 }
4143 
4144 /*
4145  * e_ddi_prop_list_delete: remove a list of properties
4146  *      Note that the caller needs to provide the required protection
4147  *      (eg. devi_lock if these properties are still attached to a devi)
4148  */
4149 void
4150 e_ddi_prop_list_delete(ddi_prop_t *props)
4151 {
4152         i_ddi_prop_list_delete(props);
4153 }
4154 
4155 /*
4156  * ddi_prop_remove_all_common:
4157  *      Used before unloading a driver to remove
4158  *      all properties. (undefines all dev_t's props.)
4159  *      Also removes `explicitly undefined' props.
4160  *      No errors possible.
4161  */
4162 void
4163 ddi_prop_remove_all_common(dev_info_t *dip, int flag)
4164 {
4165         ddi_prop_t      **list_head;
4166 
4167         mutex_enter(&(DEVI(dip)->devi_lock));
4168         if (flag & DDI_PROP_SYSTEM_DEF) {
4169                 list_head = &(DEVI(dip)->devi_sys_prop_ptr);
4170         } else if (flag & DDI_PROP_HW_DEF) {
4171                 list_head = &(DEVI(dip)->devi_hw_prop_ptr);
4172         } else {
4173                 list_head = &(DEVI(dip)->devi_drv_prop_ptr);
4174         }
4175         i_ddi_prop_list_delete(*list_head);
4176         *list_head = NULL;
4177         mutex_exit(&(DEVI(dip)->devi_lock));
4178 }
4179 
4180 
4181 /*
4182  * ddi_prop_remove_all:         Remove all driver prop definitions.
4183  */
4184 
4185 void
4186 ddi_prop_remove_all(dev_info_t *dip)
4187 {
4188         i_ddi_prop_dyn_driver_set(dip, NULL);
4189         ddi_prop_remove_all_common(dip, 0);
4190 }
4191 
4192 /*
4193  * e_ddi_prop_remove_all:       Remove all system prop definitions.
4194  */
4195 
4196 void
4197 e_ddi_prop_remove_all(dev_info_t *dip)
4198 {
4199         ddi_prop_remove_all_common(dip, (int)DDI_PROP_SYSTEM_DEF);
4200 }
4201 
4202 
4203 /*
4204  * ddi_prop_undefine:   Explicitly undefine a property.  Property
4205  *                      searches which match this property return
4206  *                      the error code DDI_PROP_UNDEFINED.
4207  *
4208  *                      Use ddi_prop_remove to negate effect of
4209  *                      ddi_prop_undefine
4210  *
4211  *                      See above for error returns.
4212  */
4213 
4214 int
4215 ddi_prop_undefine(dev_t dev, dev_info_t *dip, int flag, char *name)
4216 {
4217         if (!(flag & DDI_PROP_CANSLEEP))
4218                 flag |= DDI_PROP_DONTSLEEP;
4219         flag |= DDI_PROP_STACK_CREATE | DDI_PROP_UNDEF_IT | DDI_PROP_TYPE_ANY;
4220         return (ddi_prop_update_common(dev, dip, flag,
4221             name, NULL, 0, ddi_prop_fm_encode_bytes));
4222 }
4223 
4224 int
4225 e_ddi_prop_undefine(dev_t dev, dev_info_t *dip, int flag, char *name)
4226 {
4227         if (!(flag & DDI_PROP_CANSLEEP))
4228                 flag |= DDI_PROP_DONTSLEEP;
4229         flag |= DDI_PROP_SYSTEM_DEF | DDI_PROP_STACK_CREATE |
4230             DDI_PROP_UNDEF_IT | DDI_PROP_TYPE_ANY;
4231         return (ddi_prop_update_common(dev, dip, flag,
4232             name, NULL, 0, ddi_prop_fm_encode_bytes));
4233 }
4234 
4235 /*
4236  * Support for gathering dynamic properties in devinfo snapshot.
4237  */
4238 void
4239 i_ddi_prop_dyn_driver_set(dev_info_t *dip, i_ddi_prop_dyn_t *dp)
4240 {
4241         DEVI(dip)->devi_prop_dyn_driver = dp;
4242 }
4243 
4244 i_ddi_prop_dyn_t *
4245 i_ddi_prop_dyn_driver_get(dev_info_t *dip)
4246 {
4247         return (DEVI(dip)->devi_prop_dyn_driver);
4248 }
4249 
4250 void
4251 i_ddi_prop_dyn_parent_set(dev_info_t *dip, i_ddi_prop_dyn_t *dp)
4252 {
4253         DEVI(dip)->devi_prop_dyn_parent = dp;
4254 }
4255 
4256 i_ddi_prop_dyn_t *
4257 i_ddi_prop_dyn_parent_get(dev_info_t *dip)
4258 {
4259         return (DEVI(dip)->devi_prop_dyn_parent);
4260 }
4261 
4262 void
4263 i_ddi_prop_dyn_cache_invalidate(dev_info_t *dip, i_ddi_prop_dyn_t *dp)
4264 {
4265         /* for now we invalidate the entire cached snapshot */
4266         if (dip && dp)
4267                 i_ddi_di_cache_invalidate();
4268 }
4269 
4270 /* ARGSUSED */
4271 void
4272 ddi_prop_cache_invalidate(dev_t dev, dev_info_t *dip, char *name, int flags)
4273 {
4274         /* for now we invalidate the entire cached snapshot */
4275         i_ddi_di_cache_invalidate();
4276 }
4277 
4278 
4279 /*
4280  * Code to search hardware layer (PROM), if it exists, on behalf of child.
4281  *
4282  * if input dip != child_dip, then call is on behalf of child
4283  * to search PROM, do it via ddi_prop_search_common() and ascend only
4284  * if allowed.
4285  *
4286  * if input dip == ch_dip (child_dip), call is on behalf of root driver,
4287  * to search for PROM defined props only.
4288  *
4289  * Note that the PROM search is done only if the requested dev
4290  * is either DDI_DEV_T_ANY or DDI_DEV_T_NONE. PROM properties
4291  * have no associated dev, thus are automatically associated with
4292  * DDI_DEV_T_NONE.
4293  *
4294  * Modifying flag DDI_PROP_NOTPROM inhibits the search in the h/w layer.
4295  *
4296  * Returns DDI_PROP_FOUND_1275 if found to indicate to framework
4297  * that the property resides in the prom.
4298  */
4299 int
4300 impl_ddi_bus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
4301     ddi_prop_op_t prop_op, int mod_flags,
4302     char *name, caddr_t valuep, int *lengthp)
4303 {
4304         int     len;
4305         caddr_t buffer;
4306 
4307         /*
4308          * If requested dev is DDI_DEV_T_NONE or DDI_DEV_T_ANY, then
4309          * look in caller's PROM if it's a self identifying device...
4310          *
4311          * Note that this is very similar to ddi_prop_op, but we
4312          * search the PROM instead of the s/w defined properties,
4313          * and we are called on by the parent driver to do this for
4314          * the child.
4315          */
4316 
4317         if (((dev == DDI_DEV_T_NONE) || (dev == DDI_DEV_T_ANY)) &&
4318             ndi_dev_is_prom_node(ch_dip) &&
4319             ((mod_flags & DDI_PROP_NOTPROM) == 0)) {
4320                 len = prom_getproplen((pnode_t)DEVI(ch_dip)->devi_nodeid, name);
4321                 if (len == -1) {
4322                         return (DDI_PROP_NOT_FOUND);
4323                 }
4324 
4325                 /*
4326                  * If exists only request, we're done
4327                  */
4328                 if (prop_op == PROP_EXISTS) {
4329                         return (DDI_PROP_FOUND_1275);
4330                 }
4331 
4332                 /*
4333                  * If length only request or prop length == 0, get out
4334                  */
4335                 if ((prop_op == PROP_LEN) || (len == 0)) {
4336                         *lengthp = len;
4337                         return (DDI_PROP_FOUND_1275);
4338                 }
4339 
4340                 /*
4341                  * Allocate buffer if required... (either way `buffer'
4342                  * is receiving address).
4343                  */
4344 
4345                 switch (prop_op) {
4346 
4347                 case PROP_LEN_AND_VAL_ALLOC:
4348 
4349                         buffer = kmem_alloc((size_t)len,
4350                             mod_flags & DDI_PROP_CANSLEEP ?
4351                             KM_SLEEP : KM_NOSLEEP);
4352                         if (buffer == NULL) {
4353                                 return (DDI_PROP_NO_MEMORY);
4354                         }
4355                         *(caddr_t *)valuep = buffer;
4356                         break;
4357 
4358                 case PROP_LEN_AND_VAL_BUF:
4359 
4360                         if (len > (*lengthp)) {
4361                                 *lengthp = len;
4362                                 return (DDI_PROP_BUF_TOO_SMALL);
4363                         }
4364 
4365                         buffer = valuep;
4366                         break;
4367 
4368                 default:
4369                         break;
4370                 }
4371 
4372                 /*
4373                  * Call the PROM function to do the copy.
4374                  */
4375                 (void) prom_getprop((pnode_t)DEVI(ch_dip)->devi_nodeid,
4376                     name, buffer);
4377 
4378                 *lengthp = len; /* return the actual length to the caller */
4379                 (void) impl_fix_props(dip, ch_dip, name, len, buffer);
4380                 return (DDI_PROP_FOUND_1275);
4381         }
4382 
4383         return (DDI_PROP_NOT_FOUND);
4384 }
4385 
4386 /*
4387  * The ddi_bus_prop_op default bus nexus prop op function.
4388  *
4389  * Code to search hardware layer (PROM), if it exists,
4390  * on behalf of child, then, if appropriate, ascend and check
4391  * my own software defined properties...
4392  */
4393 int
4394 ddi_bus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
4395     ddi_prop_op_t prop_op, int mod_flags,
4396     char *name, caddr_t valuep, int *lengthp)
4397 {
4398         int     error;
4399 
4400         error = impl_ddi_bus_prop_op(dev, dip, ch_dip, prop_op, mod_flags,
4401             name, valuep, lengthp);
4402 
4403         if (error == DDI_PROP_SUCCESS || error == DDI_PROP_FOUND_1275 ||
4404             error == DDI_PROP_BUF_TOO_SMALL)
4405                 return (error);
4406 
4407         if (error == DDI_PROP_NO_MEMORY) {
4408                 cmn_err(CE_CONT, prop_no_mem_msg, name);
4409                 return (DDI_PROP_NO_MEMORY);
4410         }
4411 
4412         /*
4413          * Check the 'options' node as a last resort
4414          */
4415         if ((mod_flags & DDI_PROP_DONTPASS) != 0)
4416                 return (DDI_PROP_NOT_FOUND);
4417 
4418         if (ch_dip == ddi_root_node())  {
4419                 /*
4420                  * As a last resort, when we've reached
4421                  * the top and still haven't found the
4422                  * property, see if the desired property
4423                  * is attached to the options node.
4424                  *
4425                  * The options dip is attached right after boot.
4426                  */
4427                 ASSERT(options_dip != NULL);
4428                 /*
4429                  * Force the "don't pass" flag to *just* see
4430                  * what the options node has to offer.
4431                  */
4432                 return (ddi_prop_search_common(dev, options_dip, prop_op,
4433                     mod_flags|DDI_PROP_DONTPASS, name, valuep,
4434                     (uint_t *)lengthp));
4435         }
4436 
4437         /*
4438          * Otherwise, continue search with parent's s/w defined properties...
4439          * NOTE: Using `dip' in following call increments the level.
4440          */
4441 
4442         return (ddi_prop_search_common(dev, dip, prop_op, mod_flags,
4443             name, valuep, (uint_t *)lengthp));
4444 }
4445 
4446 /*
4447  * External property functions used by other parts of the kernel...
4448  */
4449 
4450 /*
4451  * e_ddi_getlongprop: See comments for ddi_get_longprop.
4452  */
4453 
4454 int
4455 e_ddi_getlongprop(dev_t dev, vtype_t type, char *name, int flags,
4456     caddr_t valuep, int *lengthp)
4457 {
4458         _NOTE(ARGUNUSED(type))
4459         dev_info_t *devi;
4460         ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_ALLOC;
4461         int error;
4462 
4463         if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
4464                 return (DDI_PROP_NOT_FOUND);
4465 
4466         error = cdev_prop_op(dev, devi, prop_op, flags, name, valuep, lengthp);
4467         ddi_release_devi(devi);
4468         return (error);
4469 }
4470 
4471 /*
4472  * e_ddi_getlongprop_buf:       See comments for ddi_getlongprop_buf.
4473  */
4474 
4475 int
4476 e_ddi_getlongprop_buf(dev_t dev, vtype_t type, char *name, int flags,
4477     caddr_t valuep, int *lengthp)
4478 {
4479         _NOTE(ARGUNUSED(type))
4480         dev_info_t *devi;
4481         ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_BUF;
4482         int error;
4483 
4484         if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
4485                 return (DDI_PROP_NOT_FOUND);
4486 
4487         error = cdev_prop_op(dev, devi, prop_op, flags, name, valuep, lengthp);
4488         ddi_release_devi(devi);
4489         return (error);
4490 }
4491 
4492 /*
4493  * e_ddi_getprop:       See comments for ddi_getprop.
4494  */
4495 int
4496 e_ddi_getprop(dev_t dev, vtype_t type, char *name, int flags, int defvalue)
4497 {
4498         _NOTE(ARGUNUSED(type))
4499         dev_info_t *devi;
4500         ddi_prop_op_t prop_op = PROP_LEN_AND_VAL_BUF;
4501         int     propvalue = defvalue;
4502         int     proplength = sizeof (int);
4503         int     error;
4504 
4505         if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
4506                 return (defvalue);
4507 
4508         error = cdev_prop_op(dev, devi, prop_op,
4509             flags, name, (caddr_t)&propvalue, &proplength);
4510         ddi_release_devi(devi);
4511 
4512         if ((error == DDI_PROP_SUCCESS) && (proplength == 0))
4513                 propvalue = 1;
4514 
4515         return (propvalue);
4516 }
4517 
4518 /*
4519  * e_ddi_getprop_int64:
4520  *
4521  * This is a typed interfaces, but predates typed properties. With the
4522  * introduction of typed properties the framework tries to ensure
4523  * consistent use of typed interfaces. This is why TYPE_INT64 is not
4524  * part of TYPE_ANY.  E_ddi_getprop_int64 is a special case where a
4525  * typed interface invokes legacy (non-typed) interfaces:
4526  * cdev_prop_op(), prop_op(9E), ddi_prop_op(9F)).  In this case the
4527  * fact that TYPE_INT64 is not part of TYPE_ANY matters.  To support
4528  * this type of lookup as a single operation we invoke the legacy
4529  * non-typed interfaces with the special CONSUMER_TYPED bit set. The
4530  * framework ddi_prop_op(9F) implementation is expected to check for
4531  * CONSUMER_TYPED and, if set, expand type bits beyond TYPE_ANY
4532  * (currently TYPE_INT64).
4533  */
4534 int64_t
4535 e_ddi_getprop_int64(dev_t dev, vtype_t type, char *name,
4536     int flags, int64_t defvalue)
4537 {
4538         _NOTE(ARGUNUSED(type))
4539         dev_info_t      *devi;
4540         ddi_prop_op_t   prop_op = PROP_LEN_AND_VAL_BUF;
4541         int64_t         propvalue = defvalue;
4542         int             proplength = sizeof (propvalue);
4543         int             error;
4544 
4545         if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
4546                 return (defvalue);
4547 
4548         error = cdev_prop_op(dev, devi, prop_op, flags |
4549             DDI_PROP_CONSUMER_TYPED, name, (caddr_t)&propvalue, &proplength);
4550         ddi_release_devi(devi);
4551 
4552         if ((error == DDI_PROP_SUCCESS) && (proplength == 0))
4553                 propvalue = 1;
4554 
4555         return (propvalue);
4556 }
4557 
4558 /*
4559  * e_ddi_getproplen:    See comments for ddi_getproplen.
4560  */
4561 int
4562 e_ddi_getproplen(dev_t dev, vtype_t type, char *name, int flags, int *lengthp)
4563 {
4564         _NOTE(ARGUNUSED(type))
4565         dev_info_t *devi;
4566         ddi_prop_op_t prop_op = PROP_LEN;
4567         int error;
4568 
4569         if ((devi = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
4570                 return (DDI_PROP_NOT_FOUND);
4571 
4572         error = cdev_prop_op(dev, devi, prop_op, flags, name, NULL, lengthp);
4573         ddi_release_devi(devi);
4574         return (error);
4575 }
4576 
4577 /*
4578  * Routines to get at elements of the dev_info structure
4579  */
4580 
4581 /*
4582  * ddi_binding_name: Return the driver binding name of the devinfo node
4583  *              This is the name the OS used to bind the node to a driver.
4584  */
4585 char *
4586 ddi_binding_name(dev_info_t *dip)
4587 {
4588         return (DEVI(dip)->devi_binding_name);
4589 }
4590 
4591 /*
4592  * ddi_driver_major: Return the major number of the driver that
4593  *      the supplied devinfo is bound to.  If not yet bound,
4594  *      DDI_MAJOR_T_NONE.
4595  *
4596  * When used by the driver bound to 'devi', this
4597  * function will reliably return the driver major number.
4598  * Other ways of determining the driver major number, such as
4599  *      major = ddi_name_to_major(ddi_get_name(devi));
4600  *      major = ddi_name_to_major(ddi_binding_name(devi));
4601  * can return a different result as the driver/alias binding
4602  * can change dynamically, and thus should be avoided.
4603  */
4604 major_t
4605 ddi_driver_major(dev_info_t *devi)
4606 {
4607         return (DEVI(devi)->devi_major);
4608 }
4609 
4610 /*
4611  * ddi_driver_name: Return the normalized driver name. this is the
4612  *              actual driver name
4613  */
4614 const char *
4615 ddi_driver_name(dev_info_t *devi)
4616 {
4617         major_t major;
4618 
4619         if ((major = ddi_driver_major(devi)) != DDI_MAJOR_T_NONE)
4620                 return (ddi_major_to_name(major));
4621 
4622         return (ddi_node_name(devi));
4623 }
4624 
4625 /*
4626  * i_ddi_set_binding_name:      Set binding name.
4627  *
4628  *      Set the binding name to the given name.
4629  *      This routine is for use by the ddi implementation, not by drivers.
4630  */
4631 void
4632 i_ddi_set_binding_name(dev_info_t *dip, char *name)
4633 {
4634         DEVI(dip)->devi_binding_name = name;
4635 
4636 }
4637 
4638 /*
4639  * ddi_get_name: A synonym of ddi_binding_name() ... returns a name
4640  * the implementation has used to bind the node to a driver.
4641  */
4642 char *
4643 ddi_get_name(dev_info_t *dip)
4644 {
4645         return (DEVI(dip)->devi_binding_name);
4646 }
4647 
4648 /*
4649  * ddi_node_name: Return the name property of the devinfo node
4650  *              This may differ from ddi_binding_name if the node name
4651  *              does not define a binding to a driver (i.e. generic names).
4652  */
4653 char *
4654 ddi_node_name(dev_info_t *dip)
4655 {
4656         return (DEVI(dip)->devi_node_name);
4657 }
4658 
4659 
4660 /*
4661  * ddi_get_nodeid:      Get nodeid stored in dev_info structure.
4662  */
4663 int
4664 ddi_get_nodeid(dev_info_t *dip)
4665 {
4666         return (DEVI(dip)->devi_nodeid);
4667 }
4668 
4669 int
4670 ddi_get_instance(dev_info_t *dip)
4671 {
4672         return (DEVI(dip)->devi_instance);
4673 }
4674 
4675 struct dev_ops *
4676 ddi_get_driver(dev_info_t *dip)
4677 {
4678         return (DEVI(dip)->devi_ops);
4679 }
4680 
4681 void
4682 ddi_set_driver(dev_info_t *dip, struct dev_ops *devo)
4683 {
4684         DEVI(dip)->devi_ops = devo;
4685 }
4686 
4687 /*
4688  * ddi_set_driver_private/ddi_get_driver_private:
4689  * Get/set device driver private data in devinfo.
4690  */
4691 void
4692 ddi_set_driver_private(dev_info_t *dip, void *data)
4693 {
4694         DEVI(dip)->devi_driver_data = data;
4695 }
4696 
4697 void *
4698 ddi_get_driver_private(dev_info_t *dip)
4699 {
4700         return (DEVI(dip)->devi_driver_data);
4701 }
4702 
4703 /*
4704  * ddi_get_parent, ddi_get_child, ddi_get_next_sibling
4705  */
4706 
4707 dev_info_t *
4708 ddi_get_parent(dev_info_t *dip)
4709 {
4710         return ((dev_info_t *)DEVI(dip)->devi_parent);
4711 }
4712 
4713 dev_info_t *
4714 ddi_get_child(dev_info_t *dip)
4715 {
4716         return ((dev_info_t *)DEVI(dip)->devi_child);
4717 }
4718 
4719 dev_info_t *
4720 ddi_get_next_sibling(dev_info_t *dip)
4721 {
4722         return ((dev_info_t *)DEVI(dip)->devi_sibling);
4723 }
4724 
4725 dev_info_t *
4726 ddi_get_next(dev_info_t *dip)
4727 {
4728         return ((dev_info_t *)DEVI(dip)->devi_next);
4729 }
4730 
4731 void
4732 ddi_set_next(dev_info_t *dip, dev_info_t *nextdip)
4733 {
4734         DEVI(dip)->devi_next = DEVI(nextdip);
4735 }
4736 
4737 /*
4738  * ddi_root_node:               Return root node of devinfo tree
4739  */
4740 
4741 dev_info_t *
4742 ddi_root_node(void)
4743 {
4744         extern dev_info_t *top_devinfo;
4745 
4746         return (top_devinfo);
4747 }
4748 
4749 /*
4750  * Miscellaneous functions:
4751  */
4752 
4753 /*
4754  * Implementation specific hooks
4755  */
4756 
4757 void
4758 ddi_report_dev(dev_info_t *d)
4759 {
4760         char *b;
4761 
4762         (void) ddi_ctlops(d, d, DDI_CTLOPS_REPORTDEV, (void *)0, (void *)0);
4763 
4764         /*
4765          * If this devinfo node has cb_ops, it's implicitly accessible from
4766          * userland, so we print its full name together with the instance
4767          * number 'abbreviation' that the driver may use internally.
4768          */
4769         if (DEVI(d)->devi_ops->devo_cb_ops != (struct cb_ops *)0 &&
4770             (b = kmem_zalloc(MAXPATHLEN, KM_NOSLEEP))) {
4771                 cmn_err(CE_CONT, "?%s%d is %s\n",
4772                     ddi_driver_name(d), ddi_get_instance(d),
4773                     ddi_pathname(d, b));
4774                 kmem_free(b, MAXPATHLEN);
4775         }
4776 }
4777 
4778 /*
4779  * ddi_ctlops() is described in the assembler not to buy a new register
4780  * window when it's called and can reduce cost in climbing the device tree
4781  * without using the tail call optimization.
4782  */
4783 int
4784 ddi_dev_regsize(dev_info_t *dev, uint_t rnumber, off_t *result)
4785 {
4786         int ret;
4787 
4788         ret = ddi_ctlops(dev, dev, DDI_CTLOPS_REGSIZE,
4789             (void *)&rnumber, (void *)result);
4790 
4791         return (ret == DDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
4792 }
4793 
4794 int
4795 ddi_dev_nregs(dev_info_t *dev, int *result)
4796 {
4797         return (ddi_ctlops(dev, dev, DDI_CTLOPS_NREGS, 0, (void *)result));
4798 }
4799 
4800 int
4801 ddi_dev_is_sid(dev_info_t *d)
4802 {
4803         return (ddi_ctlops(d, d, DDI_CTLOPS_SIDDEV, (void *)0, (void *)0));
4804 }
4805 
4806 int
4807 ddi_slaveonly(dev_info_t *d)
4808 {
4809         return (ddi_ctlops(d, d, DDI_CTLOPS_SLAVEONLY, (void *)0, (void *)0));
4810 }
4811 
4812 int
4813 ddi_dev_affinity(dev_info_t *a, dev_info_t *b)
4814 {
4815         return (ddi_ctlops(a, a, DDI_CTLOPS_AFFINITY, (void *)b, (void *)0));
4816 }
4817 
4818 int
4819 ddi_streams_driver(dev_info_t *dip)
4820 {
4821         if (i_ddi_devi_attached(dip) &&
4822             (DEVI(dip)->devi_ops->devo_cb_ops != NULL) &&
4823             (DEVI(dip)->devi_ops->devo_cb_ops->cb_str != NULL))
4824                 return (DDI_SUCCESS);
4825         return (DDI_FAILURE);
4826 }
4827 
4828 /*
4829  * callback free list
4830  */
4831 
4832 static int ncallbacks;
4833 static int nc_low = 170;
4834 static int nc_med = 512;
4835 static int nc_high = 2048;
4836 static struct ddi_callback *callbackq;
4837 static struct ddi_callback *callbackqfree;
4838 
4839 /*
4840  * set/run callback lists
4841  */
4842 struct  cbstats {
4843         kstat_named_t   cb_asked;
4844         kstat_named_t   cb_new;
4845         kstat_named_t   cb_run;
4846         kstat_named_t   cb_delete;
4847         kstat_named_t   cb_maxreq;
4848         kstat_named_t   cb_maxlist;
4849         kstat_named_t   cb_alloc;
4850         kstat_named_t   cb_runouts;
4851         kstat_named_t   cb_L2;
4852         kstat_named_t   cb_grow;
4853 } cbstats = {
4854         {"asked",       KSTAT_DATA_UINT32},
4855         {"new",         KSTAT_DATA_UINT32},
4856         {"run",         KSTAT_DATA_UINT32},
4857         {"delete",      KSTAT_DATA_UINT32},
4858         {"maxreq",      KSTAT_DATA_UINT32},
4859         {"maxlist",     KSTAT_DATA_UINT32},
4860         {"alloc",       KSTAT_DATA_UINT32},
4861         {"runouts",     KSTAT_DATA_UINT32},
4862         {"L2",          KSTAT_DATA_UINT32},
4863         {"grow",        KSTAT_DATA_UINT32},
4864 };
4865 
4866 #define nc_asked        cb_asked.value.ui32
4867 #define nc_new          cb_new.value.ui32
4868 #define nc_run          cb_run.value.ui32
4869 #define nc_delete       cb_delete.value.ui32
4870 #define nc_maxreq       cb_maxreq.value.ui32
4871 #define nc_maxlist      cb_maxlist.value.ui32
4872 #define nc_alloc        cb_alloc.value.ui32
4873 #define nc_runouts      cb_runouts.value.ui32
4874 #define nc_L2           cb_L2.value.ui32
4875 #define nc_grow         cb_grow.value.ui32
4876 
4877 static kmutex_t ddi_callback_mutex;
4878 
4879 /*
4880  * callbacks are handled using a L1/L2 cache. The L1 cache
4881  * comes out of kmem_cache_alloc and can expand/shrink dynamically. If
4882  * we can't get callbacks from the L1 cache [because pageout is doing
4883  * I/O at the time freemem is 0], we allocate callbacks out of the
4884  * L2 cache. The L2 cache is static and depends on the memory size.
4885  * [We might also count the number of devices at probe time and
4886  * allocate one structure per device and adjust for deferred attach]
4887  */
4888 void
4889 impl_ddi_callback_init(void)
4890 {
4891         int     i;
4892         uint_t  physmegs;
4893         kstat_t *ksp;
4894 
4895         physmegs = physmem >> (20 - PAGESHIFT);
4896         if (physmegs < 48) {
4897                 ncallbacks = nc_low;
4898         } else if (physmegs < 128) {
4899                 ncallbacks = nc_med;
4900         } else {
4901                 ncallbacks = nc_high;
4902         }
4903 
4904         /*
4905          * init free list
4906          */
4907         callbackq = kmem_zalloc(
4908             ncallbacks * sizeof (struct ddi_callback), KM_SLEEP);
4909         for (i = 0; i < ncallbacks-1; i++)
4910                 callbackq[i].c_nfree = &callbackq[i+1];
4911         callbackqfree = callbackq;
4912 
4913         /* init kstats */
4914         if (ksp = kstat_create("unix", 0, "cbstats", "misc", KSTAT_TYPE_NAMED,
4915             sizeof (cbstats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL)) {
4916                 ksp->ks_data = (void *) &cbstats;
4917                 kstat_install(ksp);
4918         }
4919 
4920 }
4921 
4922 static void
4923 callback_insert(int (*funcp)(caddr_t), caddr_t arg, uintptr_t *listid,
4924         int count)
4925 {
4926         struct ddi_callback *list, *marker, *new;
4927         size_t size = sizeof (struct ddi_callback);
4928 
4929         list = marker = (struct ddi_callback *)*listid;
4930         while (list != NULL) {
4931                 if (list->c_call == funcp && list->c_arg == arg) {
4932                         list->c_count += count;
4933                         return;
4934                 }
4935                 marker = list;
4936                 list = list->c_nlist;
4937         }
4938         new = kmem_alloc(size, KM_NOSLEEP);
4939         if (new == NULL) {
4940                 new = callbackqfree;
4941                 if (new == NULL) {
4942                         new = kmem_alloc_tryhard(sizeof (struct ddi_callback),
4943                             &size, KM_NOSLEEP | KM_PANIC);
4944                         cbstats.nc_grow++;
4945                 } else {
4946                         callbackqfree = new->c_nfree;
4947                         cbstats.nc_L2++;
4948                 }
4949         }
4950         if (marker != NULL) {
4951                 marker->c_nlist = new;
4952         } else {
4953                 *listid = (uintptr_t)new;
4954         }
4955         new->c_size = size;
4956         new->c_nlist = NULL;
4957         new->c_call = funcp;
4958         new->c_arg = arg;
4959         new->c_count = count;
4960         cbstats.nc_new++;
4961         cbstats.nc_alloc++;
4962         if (cbstats.nc_alloc > cbstats.nc_maxlist)
4963                 cbstats.nc_maxlist = cbstats.nc_alloc;
4964 }
4965 
4966 void
4967 ddi_set_callback(int (*funcp)(caddr_t), caddr_t arg, uintptr_t *listid)
4968 {
4969         mutex_enter(&ddi_callback_mutex);
4970         cbstats.nc_asked++;
4971         if ((cbstats.nc_asked - cbstats.nc_run) > cbstats.nc_maxreq)
4972                 cbstats.nc_maxreq = (cbstats.nc_asked - cbstats.nc_run);
4973         (void) callback_insert(funcp, arg, listid, 1);
4974         mutex_exit(&ddi_callback_mutex);
4975 }
4976 
4977 static void
4978 real_callback_run(void *Queue)
4979 {
4980         int (*funcp)(caddr_t);
4981         caddr_t arg;
4982         int count, rval;
4983         uintptr_t *listid;
4984         struct ddi_callback *list, *marker;
4985         int check_pending = 1;
4986         int pending = 0;
4987 
4988         do {
4989                 mutex_enter(&ddi_callback_mutex);
4990                 listid = Queue;
4991                 list = (struct ddi_callback *)*listid;
4992                 if (list == NULL) {
4993                         mutex_exit(&ddi_callback_mutex);
4994                         return;
4995                 }
4996                 if (check_pending) {
4997                         marker = list;
4998                         while (marker != NULL) {
4999                                 pending += marker->c_count;
5000                                 marker = marker->c_nlist;
5001                         }
5002                         check_pending = 0;
5003                 }
5004                 ASSERT(pending > 0);
5005                 ASSERT(list->c_count > 0);
5006                 funcp = list->c_call;
5007                 arg = list->c_arg;
5008                 count = list->c_count;
5009                 *(uintptr_t *)Queue = (uintptr_t)list->c_nlist;
5010                 if (list >= &callbackq[0] &&
5011                     list <= &callbackq[ncallbacks-1]) {
5012                         list->c_nfree = callbackqfree;
5013                         callbackqfree = list;
5014                 } else
5015                         kmem_free(list, list->c_size);
5016 
5017                 cbstats.nc_delete++;
5018                 cbstats.nc_alloc--;
5019                 mutex_exit(&ddi_callback_mutex);
5020 
5021                 do {
5022                         if ((rval = (*funcp)(arg)) == 0) {
5023                                 pending -= count;
5024                                 mutex_enter(&ddi_callback_mutex);
5025                                 (void) callback_insert(funcp, arg, listid,
5026                                     count);
5027                                 cbstats.nc_runouts++;
5028                         } else {
5029                                 pending--;
5030                                 mutex_enter(&ddi_callback_mutex);
5031                                 cbstats.nc_run++;
5032                         }
5033                         mutex_exit(&ddi_callback_mutex);
5034                 } while (rval != 0 && (--count > 0));
5035         } while (pending > 0);
5036 }
5037 
5038 void
5039 ddi_run_callback(uintptr_t *listid)
5040 {
5041         softcall(real_callback_run, listid);
5042 }
5043 
5044 /*
5045  * ddi_periodic_t
5046  * ddi_periodic_add(void (*func)(void *), void *arg, hrtime_t interval,
5047  *     int level)
5048  *
5049  * INTERFACE LEVEL
5050  *      Solaris DDI specific (Solaris DDI)
5051  *
5052  * PARAMETERS
5053  *      func: the callback function
5054  *
5055  *            The callback function will be invoked. The function is invoked
5056  *            in kernel context if the argument level passed is the zero.
5057  *            Otherwise it's invoked in interrupt context at the specified
5058  *            level.
5059  *
5060  *       arg: the argument passed to the callback function
5061  *
5062  *  interval: interval time
5063  *
5064  *    level : callback interrupt level
5065  *
5066  *            If the value is the zero, the callback function is invoked
5067  *            in kernel context. If the value is more than the zero, but
5068  *            less than or equal to ten, the callback function is invoked in
5069  *            interrupt context at the specified interrupt level, which may
5070  *            be used for real time applications.
5071  *
5072  *            This value must be in range of 0-10, which can be a numeric
5073  *            number or a pre-defined macro (DDI_IPL_0, ... , DDI_IPL_10).
5074  *
5075  * DESCRIPTION
5076  *      ddi_periodic_add(9F) schedules the specified function to be
5077  *      periodically invoked in the interval time.
5078  *
5079  *      As well as timeout(9F), the exact time interval over which the function
5080  *      takes effect cannot be guaranteed, but the value given is a close
5081  *      approximation.
5082  *
5083  *      Drivers waiting on behalf of processes with real-time constraints must
5084  *      pass non-zero value with the level argument to ddi_periodic_add(9F).
5085  *
5086  * RETURN VALUES
5087  *      ddi_periodic_add(9F) returns a non-zero opaque value (ddi_periodic_t),
5088  *      which must be used for ddi_periodic_delete(9F) to specify the request.
5089  *
5090  * CONTEXT
5091  *      ddi_periodic_add(9F) can be called in user or kernel context, but
5092  *      it cannot be called in interrupt context, which is different from
5093  *      timeout(9F).
5094  */
5095 ddi_periodic_t
5096 ddi_periodic_add(void (*func)(void *), void *arg, hrtime_t interval, int level)
5097 {
5098         /*
5099          * Sanity check of the argument level.
5100          */
5101         if (level < DDI_IPL_0 || level > DDI_IPL_10)
5102                 cmn_err(CE_PANIC,
5103                     "ddi_periodic_add: invalid interrupt level (%d).", level);
5104 
5105         /*
5106          * Sanity check of the context. ddi_periodic_add() cannot be
5107          * called in either interrupt context or high interrupt context.
5108          */
5109         if (servicing_interrupt())
5110                 cmn_err(CE_PANIC,
5111                     "ddi_periodic_add: called in (high) interrupt context.");
5112 
5113         return ((ddi_periodic_t)i_timeout(func, arg, interval, level));
5114 }
5115 
5116 /*
5117  * void
5118  * ddi_periodic_delete(ddi_periodic_t req)
5119  *
5120  * INTERFACE LEVEL
5121  *     Solaris DDI specific (Solaris DDI)
5122  *
5123  * PARAMETERS
5124  *     req: ddi_periodic_t opaque value ddi_periodic_add(9F) returned
5125  *     previously.
5126  *
5127  * DESCRIPTION
5128  *     ddi_periodic_delete(9F) cancels the ddi_periodic_add(9F) request
5129  *     previously requested.
5130  *
5131  *     ddi_periodic_delete(9F) will not return until the pending request
5132  *     is canceled or executed.
5133  *
5134  *     As well as untimeout(9F), calling ddi_periodic_delete(9F) for a
5135  *     timeout which is either running on another CPU, or has already
5136  *     completed causes no problems. However, unlike untimeout(9F), there is
5137  *     no restrictions on the lock which might be held across the call to
5138  *     ddi_periodic_delete(9F).
5139  *
5140  *     Drivers should be structured with the understanding that the arrival of
5141  *     both an interrupt and a timeout for that interrupt can occasionally
5142  *     occur, in either order.
5143  *
5144  * CONTEXT
5145  *     ddi_periodic_delete(9F) can be called in user or kernel context, but
5146  *     it cannot be called in interrupt context, which is different from
5147  *     untimeout(9F).
5148  */
5149 void
5150 ddi_periodic_delete(ddi_periodic_t req)
5151 {
5152         /*
5153          * Sanity check of the context. ddi_periodic_delete() cannot be
5154          * called in either interrupt context or high interrupt context.
5155          */
5156         if (servicing_interrupt())
5157                 cmn_err(CE_PANIC,
5158                     "ddi_periodic_delete: called in (high) interrupt context.");
5159 
5160         i_untimeout((timeout_t)req);
5161 }
5162 
5163 dev_info_t *
5164 nodevinfo(dev_t dev, int otyp)
5165 {
5166         _NOTE(ARGUNUSED(dev, otyp))
5167         return ((dev_info_t *)0);
5168 }
5169 
5170 /*
5171  * A driver should support its own getinfo(9E) entry point. This function
5172  * is provided as a convenience for ON drivers that don't expect their
5173  * getinfo(9E) entry point to be called. A driver that uses this must not
5174  * call ddi_create_minor_node.
5175  */
5176 int
5177 ddi_no_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
5178 {
5179         _NOTE(ARGUNUSED(dip, infocmd, arg, result))
5180         return (DDI_FAILURE);
5181 }
5182 
5183 /*
5184  * A driver should support its own getinfo(9E) entry point. This function
5185  * is provided as a convenience for ON drivers that where the minor number
5186  * is the instance. Drivers that do not have 1:1 mapping must implement
5187  * their own getinfo(9E) function.
5188  */
5189 int
5190 ddi_getinfo_1to1(dev_info_t *dip, ddi_info_cmd_t infocmd,
5191     void *arg, void **result)
5192 {
5193         _NOTE(ARGUNUSED(dip))
5194         int     instance;
5195 
5196         if (infocmd != DDI_INFO_DEVT2INSTANCE)
5197                 return (DDI_FAILURE);
5198 
5199         instance = getminor((dev_t)(uintptr_t)arg);
5200         *result = (void *)(uintptr_t)instance;
5201         return (DDI_SUCCESS);
5202 }
5203 
5204 int
5205 ddifail(dev_info_t *devi, ddi_attach_cmd_t cmd)
5206 {
5207         _NOTE(ARGUNUSED(devi, cmd))
5208         return (DDI_FAILURE);
5209 }
5210 
5211 int
5212 ddi_no_dma_map(dev_info_t *dip, dev_info_t *rdip,
5213     struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep)
5214 {
5215         _NOTE(ARGUNUSED(dip, rdip, dmareqp, handlep))
5216         return (DDI_DMA_NOMAPPING);
5217 }
5218 
5219 int
5220 ddi_no_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
5221     int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep)
5222 {
5223         _NOTE(ARGUNUSED(dip, rdip, attr, waitfp, arg, handlep))
5224         return (DDI_DMA_BADATTR);
5225 }
5226 
5227 int
5228 ddi_no_dma_freehdl(dev_info_t *dip, dev_info_t *rdip,
5229     ddi_dma_handle_t handle)
5230 {
5231         _NOTE(ARGUNUSED(dip, rdip, handle))
5232         return (DDI_FAILURE);
5233 }
5234 
5235 int
5236 ddi_no_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
5237     ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
5238     ddi_dma_cookie_t *cp, uint_t *ccountp)
5239 {
5240         _NOTE(ARGUNUSED(dip, rdip, handle, dmareq, cp, ccountp))
5241         return (DDI_DMA_NOMAPPING);
5242 }
5243 
5244 int
5245 ddi_no_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
5246     ddi_dma_handle_t handle)
5247 {
5248         _NOTE(ARGUNUSED(dip, rdip, handle))
5249         return (DDI_FAILURE);
5250 }
5251 
5252 int
5253 ddi_no_dma_flush(dev_info_t *dip, dev_info_t *rdip,
5254     ddi_dma_handle_t handle, off_t off, size_t len,
5255     uint_t cache_flags)
5256 {
5257         _NOTE(ARGUNUSED(dip, rdip, handle, off, len, cache_flags))
5258         return (DDI_FAILURE);
5259 }
5260 
5261 int
5262 ddi_no_dma_win(dev_info_t *dip, dev_info_t *rdip,
5263     ddi_dma_handle_t handle, uint_t win, off_t *offp,
5264     size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp)
5265 {
5266         _NOTE(ARGUNUSED(dip, rdip, handle, win, offp, lenp, cookiep, ccountp))
5267         return (DDI_FAILURE);
5268 }
5269 
5270 int
5271 ddi_no_dma_mctl(dev_info_t *dip, dev_info_t *rdip,
5272     ddi_dma_handle_t handle, enum ddi_dma_ctlops request,
5273     off_t *offp, size_t *lenp, caddr_t *objp, uint_t flags)
5274 {
5275         _NOTE(ARGUNUSED(dip, rdip, handle, request, offp, lenp, objp, flags))
5276         return (DDI_FAILURE);
5277 }
5278 
5279 void
5280 ddivoid(void)
5281 {}
5282 
5283 int
5284 nochpoll(dev_t dev, short events, int anyyet, short *reventsp,
5285     struct pollhead **pollhdrp)
5286 {
5287         _NOTE(ARGUNUSED(dev, events, anyyet, reventsp, pollhdrp))
5288         return (ENXIO);
5289 }
5290 
5291 cred_t *
5292 ddi_get_cred(void)
5293 {
5294         return (CRED());
5295 }
5296 
5297 clock_t
5298 ddi_get_lbolt(void)
5299 {
5300         return ((clock_t)lbolt_hybrid());
5301 }
5302 
5303 int64_t
5304 ddi_get_lbolt64(void)
5305 {
5306         return (lbolt_hybrid());
5307 }
5308 
5309 time_t
5310 ddi_get_time(void)
5311 {
5312         time_t  now;
5313 
5314         if ((now = gethrestime_sec()) == 0) {
5315                 timestruc_t ts;
5316                 mutex_enter(&tod_lock);
5317                 ts = tod_get();
5318                 mutex_exit(&tod_lock);
5319                 return (ts.tv_sec);
5320         } else {
5321                 return (now);
5322         }
5323 }
5324 
5325 pid_t
5326 ddi_get_pid(void)
5327 {
5328         return (ttoproc(curthread)->p_pid);
5329 }
5330 
5331 kt_did_t
5332 ddi_get_kt_did(void)
5333 {
5334         return (curthread->t_did);
5335 }
5336 
5337 /*
5338  * This function returns B_TRUE if the caller can reasonably expect that a call
5339  * to cv_wait_sig(9F), cv_timedwait_sig(9F), or qwait_sig(9F) could be awakened
5340  * by user-level signal.  If it returns B_FALSE, then the caller should use
5341  * other means to make certain that the wait will not hang "forever."
5342  *
5343  * It does not check the signal mask, nor for reception of any particular
5344  * signal.
5345  *
5346  * Currently, a thread can receive a signal if it's not a kernel thread and it
5347  * is not in the middle of exit(2) tear-down.  Threads that are in that
5348  * tear-down effectively convert cv_wait_sig to cv_wait, cv_timedwait_sig to
5349  * cv_timedwait, and qwait_sig to qwait.
5350  */
5351 boolean_t
5352 ddi_can_receive_sig(void)
5353 {
5354         proc_t *pp;
5355 
5356         if (curthread->t_proc_flag & TP_LWPEXIT)
5357                 return (B_FALSE);
5358         if ((pp = ttoproc(curthread)) == NULL)
5359                 return (B_FALSE);
5360         return (pp->p_as != &kas);
5361 }
5362 
5363 /*
5364  * Swap bytes in 16-bit [half-]words
5365  */
5366 void
5367 swab(void *src, void *dst, size_t nbytes)
5368 {
5369         uchar_t *pf = (uchar_t *)src;
5370         uchar_t *pt = (uchar_t *)dst;
5371         uchar_t tmp;
5372         int nshorts;
5373 
5374         nshorts = nbytes >> 1;
5375 
5376         while (--nshorts >= 0) {
5377                 tmp = *pf++;
5378                 *pt++ = *pf++;
5379                 *pt++ = tmp;
5380         }
5381 }
5382 
5383 static void
5384 ddi_append_minor_node(dev_info_t *ddip, struct ddi_minor_data *dmdp)
5385 {
5386         int                     circ;
5387         struct ddi_minor_data   *dp;
5388 
5389         ndi_devi_enter(ddip, &circ);
5390         if ((dp = DEVI(ddip)->devi_minor) == (struct ddi_minor_data *)NULL) {
5391                 DEVI(ddip)->devi_minor = dmdp;
5392         } else {
5393                 while (dp->next != (struct ddi_minor_data *)NULL)
5394                         dp = dp->next;
5395                 dp->next = dmdp;
5396         }
5397         ndi_devi_exit(ddip, circ);
5398 }
5399 
5400 /*
5401  * Part of the obsolete SunCluster DDI Hooks.
5402  * Keep for binary compatibility
5403  */
5404 minor_t
5405 ddi_getiminor(dev_t dev)
5406 {
5407         return (getminor(dev));
5408 }
5409 
5410 static int
5411 i_log_devfs_minor_create(dev_info_t *dip, char *minor_name)
5412 {
5413         int se_flag;
5414         int kmem_flag;
5415         int se_err;
5416         char *pathname, *class_name;
5417         sysevent_t *ev = NULL;
5418         sysevent_id_t eid;
5419         sysevent_value_t se_val;
5420         sysevent_attr_list_t *ev_attr_list = NULL;
5421 
5422         /* determine interrupt context */
5423         se_flag = (servicing_interrupt()) ? SE_NOSLEEP : SE_SLEEP;
5424         kmem_flag = (se_flag == SE_SLEEP) ? KM_SLEEP : KM_NOSLEEP;
5425 
5426         i_ddi_di_cache_invalidate();
5427 
5428 #ifdef DEBUG
5429         if ((se_flag == SE_NOSLEEP) && sunddi_debug) {
5430                 cmn_err(CE_CONT, "ddi_create_minor_node: called from "
5431                     "interrupt level by driver %s",
5432                     ddi_driver_name(dip));
5433         }
5434 #endif /* DEBUG */
5435 
5436         ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_MINOR_CREATE, EP_DDI, se_flag);
5437         if (ev == NULL) {
5438                 goto fail;
5439         }
5440 
5441         pathname = kmem_alloc(MAXPATHLEN, kmem_flag);
5442         if (pathname == NULL) {
5443                 sysevent_free(ev);
5444                 goto fail;
5445         }
5446 
5447         (void) ddi_pathname(dip, pathname);
5448         ASSERT(strlen(pathname));
5449         se_val.value_type = SE_DATA_TYPE_STRING;
5450         se_val.value.sv_string = pathname;
5451         if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME,
5452             &se_val, se_flag) != 0) {
5453                 kmem_free(pathname, MAXPATHLEN);
5454                 sysevent_free(ev);
5455                 goto fail;
5456         }
5457         kmem_free(pathname, MAXPATHLEN);
5458 
5459         /* add the device class attribute */
5460         if ((class_name = i_ddi_devi_class(dip)) != NULL) {
5461                 se_val.value_type = SE_DATA_TYPE_STRING;
5462                 se_val.value.sv_string = class_name;
5463                 if (sysevent_add_attr(&ev_attr_list,
5464                     DEVFS_DEVI_CLASS, &se_val, SE_SLEEP) != 0) {
5465                         sysevent_free_attr(ev_attr_list);
5466                         goto fail;
5467                 }
5468         }
5469 
5470         /*
5471          * allow for NULL minor names
5472          */
5473         if (minor_name != NULL) {
5474                 se_val.value.sv_string = minor_name;
5475                 if (sysevent_add_attr(&ev_attr_list, DEVFS_MINOR_NAME,
5476                     &se_val, se_flag) != 0) {
5477                         sysevent_free_attr(ev_attr_list);
5478                         sysevent_free(ev);
5479                         goto fail;
5480                 }
5481         }
5482 
5483         if (sysevent_attach_attributes(ev, ev_attr_list) != 0) {
5484                 sysevent_free_attr(ev_attr_list);
5485                 sysevent_free(ev);
5486                 goto fail;
5487         }
5488 
5489         if ((se_err = log_sysevent(ev, se_flag, &eid)) != 0) {
5490                 if (se_err == SE_NO_TRANSPORT) {
5491                         cmn_err(CE_WARN, "/devices or /dev may not be current "
5492                             "for driver %s (%s). Run devfsadm -i %s",
5493                             ddi_driver_name(dip), "syseventd not responding",
5494                             ddi_driver_name(dip));
5495                 } else {
5496                         sysevent_free(ev);
5497                         goto fail;
5498                 }
5499         }
5500 
5501         sysevent_free(ev);
5502         return (DDI_SUCCESS);
5503 fail:
5504         cmn_err(CE_WARN, "/devices or /dev may not be current "
5505             "for driver %s. Run devfsadm -i %s",
5506             ddi_driver_name(dip), ddi_driver_name(dip));
5507         return (DDI_SUCCESS);
5508 }
5509 
5510 /*
5511  * failing to remove a minor node is not of interest
5512  * therefore we do not generate an error message
5513  */
5514 static int
5515 i_log_devfs_minor_remove(dev_info_t *dip, char *minor_name)
5516 {
5517         char *pathname, *class_name;
5518         sysevent_t *ev;
5519         sysevent_id_t eid;
5520         sysevent_value_t se_val;
5521         sysevent_attr_list_t *ev_attr_list = NULL;
5522 
5523         /*
5524          * only log ddi_remove_minor_node() calls outside the scope
5525          * of attach/detach reconfigurations and when the dip is
5526          * still initialized.
5527          */
5528         if (DEVI_IS_ATTACHING(dip) || DEVI_IS_DETACHING(dip) ||
5529             (i_ddi_node_state(dip) < DS_INITIALIZED)) {
5530                 return (DDI_SUCCESS);
5531         }
5532 
5533         i_ddi_di_cache_invalidate();
5534 
5535         ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_MINOR_REMOVE, EP_DDI, SE_SLEEP);
5536         if (ev == NULL) {
5537                 return (DDI_SUCCESS);
5538         }
5539 
5540         pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
5541         if (pathname == NULL) {
5542                 sysevent_free(ev);
5543                 return (DDI_SUCCESS);
5544         }
5545 
5546         (void) ddi_pathname(dip, pathname);
5547         ASSERT(strlen(pathname));
5548         se_val.value_type = SE_DATA_TYPE_STRING;
5549         se_val.value.sv_string = pathname;
5550         if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME,
5551             &se_val, SE_SLEEP) != 0) {
5552                 kmem_free(pathname, MAXPATHLEN);
5553                 sysevent_free(ev);
5554                 return (DDI_SUCCESS);
5555         }
5556 
5557         kmem_free(pathname, MAXPATHLEN);
5558 
5559         /*
5560          * allow for NULL minor names
5561          */
5562         if (minor_name != NULL) {
5563                 se_val.value.sv_string = minor_name;
5564                 if (sysevent_add_attr(&ev_attr_list, DEVFS_MINOR_NAME,
5565                     &se_val, SE_SLEEP) != 0) {
5566                         sysevent_free_attr(ev_attr_list);
5567                         goto fail;
5568                 }
5569         }
5570 
5571         if ((class_name = i_ddi_devi_class(dip)) != NULL) {
5572                 /* add the device class, driver name and instance attributes */
5573 
5574                 se_val.value_type = SE_DATA_TYPE_STRING;
5575                 se_val.value.sv_string = class_name;
5576                 if (sysevent_add_attr(&ev_attr_list,
5577                     DEVFS_DEVI_CLASS, &se_val, SE_SLEEP) != 0) {
5578                         sysevent_free_attr(ev_attr_list);
5579                         goto fail;
5580                 }
5581 
5582                 se_val.value_type = SE_DATA_TYPE_STRING;
5583                 se_val.value.sv_string = (char *)ddi_driver_name(dip);
5584                 if (sysevent_add_attr(&ev_attr_list,
5585                     DEVFS_DRIVER_NAME, &se_val, SE_SLEEP) != 0) {
5586                         sysevent_free_attr(ev_attr_list);
5587                         goto fail;
5588                 }
5589 
5590                 se_val.value_type = SE_DATA_TYPE_INT32;
5591                 se_val.value.sv_int32 = ddi_get_instance(dip);
5592                 if (sysevent_add_attr(&ev_attr_list,
5593                     DEVFS_INSTANCE, &se_val, SE_SLEEP) != 0) {
5594                         sysevent_free_attr(ev_attr_list);
5595                         goto fail;
5596                 }
5597 
5598         }
5599 
5600         if (sysevent_attach_attributes(ev, ev_attr_list) != 0) {
5601                 sysevent_free_attr(ev_attr_list);
5602         } else {
5603                 (void) log_sysevent(ev, SE_SLEEP, &eid);
5604         }
5605 fail:
5606         sysevent_free(ev);
5607         return (DDI_SUCCESS);
5608 }
5609 
5610 /*
5611  * Derive the device class of the node.
5612  * Device class names aren't defined yet. Until this is done we use
5613  * devfs event subclass names as device class names.
5614  */
5615 static int
5616 derive_devi_class(dev_info_t *dip, char *node_type, int flag)
5617 {
5618         int rv = DDI_SUCCESS;
5619 
5620         if (i_ddi_devi_class(dip) == NULL) {
5621                 if (strncmp(node_type, DDI_NT_BLOCK,
5622                     sizeof (DDI_NT_BLOCK) - 1) == 0 &&
5623                     (node_type[sizeof (DDI_NT_BLOCK) - 1] == '\0' ||
5624                     node_type[sizeof (DDI_NT_BLOCK) - 1] == ':') &&
5625                     strcmp(node_type, DDI_NT_FD) != 0) {
5626 
5627                         rv = i_ddi_set_devi_class(dip, ESC_DISK, flag);
5628 
5629                 } else if (strncmp(node_type, DDI_NT_NET,
5630                     sizeof (DDI_NT_NET) - 1) == 0 &&
5631                     (node_type[sizeof (DDI_NT_NET) - 1] == '\0' ||
5632                     node_type[sizeof (DDI_NT_NET) - 1] == ':')) {
5633 
5634                         rv = i_ddi_set_devi_class(dip, ESC_NETWORK, flag);
5635 
5636                 } else if (strncmp(node_type, DDI_NT_PRINTER,
5637                     sizeof (DDI_NT_PRINTER) - 1) == 0 &&
5638                     (node_type[sizeof (DDI_NT_PRINTER) - 1] == '\0' ||
5639                     node_type[sizeof (DDI_NT_PRINTER) - 1] == ':')) {
5640 
5641                         rv = i_ddi_set_devi_class(dip, ESC_PRINTER, flag);
5642 
5643                 } else if (strncmp(node_type, DDI_PSEUDO,
5644                     sizeof (DDI_PSEUDO) -1) == 0 &&
5645                     (strncmp(ESC_LOFI, ddi_node_name(dip),
5646                     sizeof (ESC_LOFI) -1) == 0)) {
5647                         rv = i_ddi_set_devi_class(dip, ESC_LOFI, flag);
5648                 }
5649         }
5650 
5651         return (rv);
5652 }
5653 
5654 /*
5655  * Check compliance with PSARC 2003/375:
5656  *
5657  * The name must contain only characters a-z, A-Z, 0-9 or _ and it must not
5658  * exceed IFNAMSIZ (16) characters in length.
5659  */
5660 static boolean_t
5661 verify_name(char *name)
5662 {
5663         size_t  len = strlen(name);
5664         char    *cp;
5665 
5666         if (len == 0 || len > IFNAMSIZ)
5667                 return (B_FALSE);
5668 
5669         for (cp = name; *cp != '\0'; cp++) {
5670                 if (!isalnum(*cp) && *cp != '_')
5671                         return (B_FALSE);
5672         }
5673 
5674         return (B_TRUE);
5675 }
5676 
5677 /*
5678  * ddi_create_minor_common:     Create a  ddi_minor_data structure and
5679  *                              attach it to the given devinfo node.
5680  */
5681 
5682 int
5683 ddi_create_minor_common(dev_info_t *dip, char *name, int spec_type,
5684     minor_t minor_num, char *node_type, int flag, ddi_minor_type mtype,
5685     const char *read_priv, const char *write_priv, mode_t priv_mode)
5686 {
5687         struct ddi_minor_data *dmdp;
5688         major_t major;
5689 
5690         if (spec_type != S_IFCHR && spec_type != S_IFBLK)
5691                 return (DDI_FAILURE);
5692 
5693         if (name == NULL)
5694                 return (DDI_FAILURE);
5695 
5696         /*
5697          * Log a message if the minor number the driver is creating
5698          * is not expressible on the on-disk filesystem (currently
5699          * this is limited to 18 bits both by UFS). The device can
5700          * be opened via devfs, but not by device special files created
5701          * via mknod().
5702          */
5703         if (minor_num > L_MAXMIN32) {
5704                 cmn_err(CE_WARN,
5705                     "%s%d:%s minor 0x%x too big for 32-bit applications",
5706                     ddi_driver_name(dip), ddi_get_instance(dip),
5707                     name, minor_num);
5708                 return (DDI_FAILURE);
5709         }
5710 
5711         /* dip must be bound and attached */
5712         major = ddi_driver_major(dip);
5713         ASSERT(major != DDI_MAJOR_T_NONE);
5714 
5715         /*
5716          * Default node_type to DDI_PSEUDO and issue notice in debug mode
5717          */
5718         if (node_type == NULL) {
5719                 node_type = DDI_PSEUDO;
5720                 NDI_CONFIG_DEBUG((CE_NOTE, "!illegal node_type NULL for %s%d "
5721                     " minor node %s; default to DDI_PSEUDO",
5722                     ddi_driver_name(dip), ddi_get_instance(dip), name));
5723         }
5724 
5725         /*
5726          * If the driver is a network driver, ensure that the name falls within
5727          * the interface naming constraints specified by PSARC/2003/375.
5728          */
5729         if (strcmp(node_type, DDI_NT_NET) == 0) {
5730                 if (!verify_name(name))
5731                         return (DDI_FAILURE);
5732 
5733                 if (mtype == DDM_MINOR) {
5734                         struct devnames *dnp = &devnamesp[major];
5735 
5736                         /* Mark driver as a network driver */
5737                         LOCK_DEV_OPS(&dnp->dn_lock);
5738                         dnp->dn_flags |= DN_NETWORK_DRIVER;
5739 
5740                         /*
5741                          * If this minor node is created during the device
5742                          * attachment, this is a physical network device.
5743                          * Mark the driver as a physical network driver.
5744                          */
5745                         if (DEVI_IS_ATTACHING(dip))
5746                                 dnp->dn_flags |= DN_NETWORK_PHYSDRIVER;
5747                         UNLOCK_DEV_OPS(&dnp->dn_lock);
5748                 }
5749         }
5750 
5751         if (mtype == DDM_MINOR) {
5752                 if (derive_devi_class(dip,  node_type, KM_NOSLEEP) !=
5753                     DDI_SUCCESS)
5754                         return (DDI_FAILURE);
5755         }
5756 
5757         /*
5758          * Take care of minor number information for the node.
5759          */
5760 
5761         if ((dmdp = kmem_zalloc(sizeof (struct ddi_minor_data),
5762             KM_NOSLEEP)) == NULL) {
5763                 return (DDI_FAILURE);
5764         }
5765         if ((dmdp->ddm_name = i_ddi_strdup(name, KM_NOSLEEP)) == NULL) {
5766                 kmem_free(dmdp, sizeof (struct ddi_minor_data));
5767                 return (DDI_FAILURE);
5768         }
5769         dmdp->dip = dip;
5770         dmdp->ddm_dev = makedevice(major, minor_num);
5771         dmdp->ddm_spec_type = spec_type;
5772         dmdp->ddm_node_type = node_type;
5773         dmdp->type = mtype;
5774         if (flag & CLONE_DEV) {
5775                 dmdp->type = DDM_ALIAS;
5776                 dmdp->ddm_dev = makedevice(ddi_driver_major(clone_dip), major);
5777         }
5778         if (flag & PRIVONLY_DEV) {
5779                 dmdp->ddm_flags |= DM_NO_FSPERM;
5780         }
5781         if (read_priv || write_priv) {
5782                 dmdp->ddm_node_priv =
5783                     devpolicy_priv_by_name(read_priv, write_priv);
5784         }
5785         dmdp->ddm_priv_mode = priv_mode;
5786 
5787         ddi_append_minor_node(dip, dmdp);
5788 
5789         /*
5790          * only log ddi_create_minor_node() calls which occur
5791          * outside the scope of attach(9e)/detach(9e) reconfigurations
5792          */
5793         if (!(DEVI_IS_ATTACHING(dip) || DEVI_IS_DETACHING(dip)) &&
5794             mtype != DDM_INTERNAL_PATH) {
5795                 (void) i_log_devfs_minor_create(dip, name);
5796         }
5797 
5798         /*
5799          * Check if any dacf rules match the creation of this minor node
5800          */
5801         dacfc_match_create_minor(name, node_type, dip, dmdp, flag);
5802         return (DDI_SUCCESS);
5803 }
5804 
5805 int
5806 ddi_create_minor_node(dev_info_t *dip, char *name, int spec_type,
5807     minor_t minor_num, char *node_type, int flag)
5808 {
5809         return (ddi_create_minor_common(dip, name, spec_type, minor_num,
5810             node_type, flag, DDM_MINOR, NULL, NULL, 0));
5811 }
5812 
5813 int
5814 ddi_create_priv_minor_node(dev_info_t *dip, char *name, int spec_type,
5815     minor_t minor_num, char *node_type, int flag,
5816     const char *rdpriv, const char *wrpriv, mode_t priv_mode)
5817 {
5818         return (ddi_create_minor_common(dip, name, spec_type, minor_num,
5819             node_type, flag, DDM_MINOR, rdpriv, wrpriv, priv_mode));
5820 }
5821 
5822 int
5823 ddi_create_default_minor_node(dev_info_t *dip, char *name, int spec_type,
5824     minor_t minor_num, char *node_type, int flag)
5825 {
5826         return (ddi_create_minor_common(dip, name, spec_type, minor_num,
5827             node_type, flag, DDM_DEFAULT, NULL, NULL, 0));
5828 }
5829 
5830 /*
5831  * Internal (non-ddi) routine for drivers to export names known
5832  * to the kernel (especially ddi_pathname_to_dev_t and friends)
5833  * but not exported externally to /dev
5834  */
5835 int
5836 ddi_create_internal_pathname(dev_info_t *dip, char *name, int spec_type,
5837     minor_t minor_num)
5838 {
5839         return (ddi_create_minor_common(dip, name, spec_type, minor_num,
5840             "internal", 0, DDM_INTERNAL_PATH, NULL, NULL, 0));
5841 }
5842 
5843 void
5844 ddi_remove_minor_node(dev_info_t *dip, char *name)
5845 {
5846         int                     circ;
5847         struct ddi_minor_data   *dmdp, *dmdp1;
5848         struct ddi_minor_data   **dmdp_prev;
5849 
5850         ndi_devi_enter(dip, &circ);
5851         dmdp_prev = &DEVI(dip)->devi_minor;
5852         dmdp = DEVI(dip)->devi_minor;
5853         while (dmdp != NULL) {
5854                 dmdp1 = dmdp->next;
5855                 if ((name == NULL || (dmdp->ddm_name != NULL &&
5856                     strcmp(name, dmdp->ddm_name) == 0))) {
5857                         if (dmdp->ddm_name != NULL) {
5858                                 if (dmdp->type != DDM_INTERNAL_PATH)
5859                                         (void) i_log_devfs_minor_remove(dip,
5860                                             dmdp->ddm_name);
5861                                 kmem_free(dmdp->ddm_name,
5862                                     strlen(dmdp->ddm_name) + 1);
5863                         }
5864                         /*
5865                          * Release device privilege, if any.
5866                          * Release dacf client data associated with this minor
5867                          * node by storing NULL.
5868                          */
5869                         if (dmdp->ddm_node_priv)
5870                                 dpfree(dmdp->ddm_node_priv);
5871                         dacf_store_info((dacf_infohdl_t)dmdp, NULL);
5872                         kmem_free(dmdp, sizeof (struct ddi_minor_data));
5873                         *dmdp_prev = dmdp1;
5874                         /*
5875                          * OK, we found it, so get out now -- if we drive on,
5876                          * we will strcmp against garbage.  See 1139209.
5877                          */
5878                         if (name != NULL)
5879                                 break;
5880                 } else {
5881                         dmdp_prev = &dmdp->next;
5882                 }
5883                 dmdp = dmdp1;
5884         }
5885         ndi_devi_exit(dip, circ);
5886 }
5887 
5888 
5889 int
5890 ddi_in_panic()
5891 {
5892         return (panicstr != NULL);
5893 }
5894 
5895 
5896 /*
5897  * Find first bit set in a mask (returned counting from 1 up)
5898  */
5899 
5900 int
5901 ddi_ffs(long mask)
5902 {
5903         return (ffs(mask));
5904 }
5905 
5906 int
5907 ddi_ffsll(long long mask)
5908 {
5909         return (ffs(mask));
5910 }
5911 
5912 /*
5913  * Find last bit set. Take mask and clear
5914  * all but the most significant bit, and
5915  * then let ffs do the rest of the work.
5916  *
5917  * Algorithm courtesy of Steve Chessin.
5918  */
5919 
5920 int
5921 ddi_fls(long mask)
5922 {
5923         return (ddi_flsll(mask));
5924 }
5925 
5926 int
5927 ddi_flsll(long long mask)
5928 {
5929         while (mask) {
5930                 long long nx;
5931 
5932                 if ((nx = (mask & (mask - 1))) == 0)
5933                         break;
5934                 mask = nx;
5935         }
5936         return (ffs(mask));
5937 }
5938 
5939 /*
5940  * The ddi_soft_state_* routines comprise generic storage management utilities
5941  * for driver soft state structures (in "the old days," this was done with
5942  * statically sized array - big systems and dynamic loading and unloading
5943  * make heap allocation more attractive).
5944  */
5945 
5946 /*
5947  * Allocate a set of pointers to 'n_items' objects of size 'size'
5948  * bytes.  Each pointer is initialized to nil.
5949  *
5950  * The 'size' and 'n_items' values are stashed in the opaque
5951  * handle returned to the caller.
5952  *
5953  * This implementation interprets 'set of pointers' to mean 'array
5954  * of pointers' but note that nothing in the interface definition
5955  * precludes an implementation that uses, for example, a linked list.
5956  * However there should be a small efficiency gain from using an array
5957  * at lookup time.
5958  *
5959  * NOTE As an optimization, we make our growable array allocations in
5960  *      powers of two (bytes), since that's how much kmem_alloc (currently)
5961  *      gives us anyway.  It should save us some free/realloc's ..
5962  *
5963  *      As a further optimization, we make the growable array start out
5964  *      with MIN_N_ITEMS in it.
5965  */
5966 
5967 #define MIN_N_ITEMS     8       /* 8 void *'s == 32 bytes */
5968 
5969 int
5970 ddi_soft_state_init(void **state_p, size_t size, size_t n_items)
5971 {
5972         i_ddi_soft_state        *ss;
5973 
5974         if (state_p == NULL || size == 0)
5975                 return (EINVAL);
5976 
5977         ss = kmem_zalloc(sizeof (*ss), KM_SLEEP);
5978         mutex_init(&ss->lock, NULL, MUTEX_DRIVER, NULL);
5979         ss->size = size;
5980 
5981         if (n_items < MIN_N_ITEMS)
5982                 ss->n_items = MIN_N_ITEMS;
5983         else {
5984                 int bitlog;
5985 
5986                 if ((bitlog = ddi_fls(n_items)) == ddi_ffs(n_items))
5987                         bitlog--;
5988                 ss->n_items = 1 << bitlog;
5989         }
5990 
5991         ASSERT(ss->n_items >= n_items);
5992 
5993         ss->array = kmem_zalloc(ss->n_items * sizeof (void *), KM_SLEEP);
5994 
5995         *state_p = ss;
5996         return (0);
5997 }
5998 
5999 /*
6000  * Allocate a state structure of size 'size' to be associated
6001  * with item 'item'.
6002  *
6003  * In this implementation, the array is extended to
6004  * allow the requested offset, if needed.
6005  */
6006 int
6007 ddi_soft_state_zalloc(void *state, int item)
6008 {
6009         i_ddi_soft_state        *ss = (i_ddi_soft_state *)state;
6010         void                    **array;
6011         void                    *new_element;
6012 
6013         if ((state == NULL) || (item < 0))
6014                 return (DDI_FAILURE);
6015 
6016         mutex_enter(&ss->lock);
6017         if (ss->size == 0) {
6018                 mutex_exit(&ss->lock);
6019                 cmn_err(CE_WARN, "ddi_soft_state_zalloc: bad handle: %s",
6020                     mod_containing_pc(caller()));
6021                 return (DDI_FAILURE);
6022         }
6023 
6024         array = ss->array;   /* NULL if ss->n_items == 0 */
6025         ASSERT(ss->n_items != 0 && array != NULL);
6026 
6027         /*
6028          * refuse to tread on an existing element
6029          */
6030         if (item < ss->n_items && array[item] != NULL) {
6031                 mutex_exit(&ss->lock);
6032                 return (DDI_FAILURE);
6033         }
6034 
6035         /*
6036          * Allocate a new element to plug in
6037          */
6038         new_element = kmem_zalloc(ss->size, KM_SLEEP);
6039 
6040         /*
6041          * Check if the array is big enough, if not, grow it.
6042          */
6043         if (item >= ss->n_items) {
6044                 void                    **new_array;
6045                 size_t                  new_n_items;
6046                 struct i_ddi_soft_state *dirty;
6047 
6048                 /*
6049                  * Allocate a new array of the right length, copy
6050                  * all the old pointers to the new array, then
6051                  * if it exists at all, put the old array on the
6052                  * dirty list.
6053                  *
6054                  * Note that we can't kmem_free() the old array.
6055                  *
6056                  * Why -- well the 'get' operation is 'mutex-free', so we
6057                  * can't easily catch a suspended thread that is just about
6058                  * to dereference the array we just grew out of.  So we
6059                  * cons up a header and put it on a list of 'dirty'
6060                  * pointer arrays.  (Dirty in the sense that there may
6061                  * be suspended threads somewhere that are in the middle
6062                  * of referencing them).  Fortunately, we -can- garbage
6063                  * collect it all at ddi_soft_state_fini time.
6064                  */
6065                 new_n_items = ss->n_items;
6066                 while (new_n_items < (1 + item))
6067                         new_n_items <<= 1;        /* double array size .. */
6068 
6069                 ASSERT(new_n_items >= (1 + item));   /* sanity check! */
6070 
6071                 new_array = kmem_zalloc(new_n_items * sizeof (void *),
6072                     KM_SLEEP);
6073                 /*
6074                  * Copy the pointers into the new array
6075                  */
6076                 bcopy(array, new_array, ss->n_items * sizeof (void *));
6077 
6078                 /*
6079                  * Save the old array on the dirty list
6080                  */
6081                 dirty = kmem_zalloc(sizeof (*dirty), KM_SLEEP);
6082                 dirty->array = ss->array;
6083                 dirty->n_items = ss->n_items;
6084                 dirty->next = ss->next;
6085                 ss->next = dirty;
6086 
6087                 ss->array = (array = new_array);
6088                 ss->n_items = new_n_items;
6089         }
6090 
6091         ASSERT(array != NULL && item < ss->n_items && array[item] == NULL);
6092 
6093         array[item] = new_element;
6094 
6095         mutex_exit(&ss->lock);
6096         return (DDI_SUCCESS);
6097 }
6098 
6099 /*
6100  * Fetch a pointer to the allocated soft state structure.
6101  *
6102  * This is designed to be cheap.
6103  *
6104  * There's an argument that there should be more checking for
6105  * nil pointers and out of bounds on the array.. but we do a lot
6106  * of that in the alloc/free routines.
6107  *
6108  * An array has the convenience that we don't need to lock read-access
6109  * to it c.f. a linked list.  However our "expanding array" strategy
6110  * means that we should hold a readers lock on the i_ddi_soft_state
6111  * structure.
6112  *
6113  * However, from a performance viewpoint, we need to do it without
6114  * any locks at all -- this also makes it a leaf routine.  The algorithm
6115  * is 'lock-free' because we only discard the pointer arrays at
6116  * ddi_soft_state_fini() time.
6117  */
6118 void *
6119 ddi_get_soft_state(void *state, int item)
6120 {
6121         i_ddi_soft_state        *ss = (i_ddi_soft_state *)state;
6122 
6123         ASSERT((ss != NULL) && (item >= 0));
6124 
6125         if (item < ss->n_items && ss->array != NULL)
6126                 return (ss->array[item]);
6127         return (NULL);
6128 }
6129 
6130 /*
6131  * Free the state structure corresponding to 'item.'   Freeing an
6132  * element that has either gone or was never allocated is not
6133  * considered an error.  Note that we free the state structure, but
6134  * we don't shrink our pointer array, or discard 'dirty' arrays,
6135  * since even a few pointers don't really waste too much memory.
6136  *
6137  * Passing an item number that is out of bounds, or a null pointer will
6138  * provoke an error message.
6139  */
6140 void
6141 ddi_soft_state_free(void *state, int item)
6142 {
6143         i_ddi_soft_state        *ss = (i_ddi_soft_state *)state;
6144         void                    **array;
6145         void                    *element;
6146         static char             msg[] = "ddi_soft_state_free:";
6147 
6148         if (ss == NULL) {
6149                 cmn_err(CE_WARN, "%s null handle: %s",
6150                     msg, mod_containing_pc(caller()));
6151                 return;
6152         }
6153 
6154         element = NULL;
6155 
6156         mutex_enter(&ss->lock);
6157 
6158         if ((array = ss->array) == NULL || ss->size == 0) {
6159                 cmn_err(CE_WARN, "%s bad handle: %s",
6160                     msg, mod_containing_pc(caller()));
6161         } else if (item < 0 || item >= ss->n_items) {
6162                 cmn_err(CE_WARN, "%s item %d not in range [0..%lu]: %s",
6163                     msg, item, ss->n_items - 1, mod_containing_pc(caller()));
6164         } else if (array[item] != NULL) {
6165                 element = array[item];
6166                 array[item] = NULL;
6167         }
6168 
6169         mutex_exit(&ss->lock);
6170 
6171         if (element)
6172                 kmem_free(element, ss->size);
6173 }
6174 
6175 /*
6176  * Free the entire set of pointers, and any
6177  * soft state structures contained therein.
6178  *
6179  * Note that we don't grab the ss->lock mutex, even though
6180  * we're inspecting the various fields of the data structure.
6181  *
6182  * There is an implicit assumption that this routine will
6183  * never run concurrently with any of the above on this
6184  * particular state structure i.e. by the time the driver
6185  * calls this routine, there should be no other threads
6186  * running in the driver.
6187  */
6188 void
6189 ddi_soft_state_fini(void **state_p)
6190 {
6191         i_ddi_soft_state        *ss, *dirty;
6192         int                     item;
6193         static char             msg[] = "ddi_soft_state_fini:";
6194 
6195         if (state_p == NULL ||
6196             (ss = (i_ddi_soft_state *)(*state_p)) == NULL) {
6197                 cmn_err(CE_WARN, "%s null handle: %s",
6198                     msg, mod_containing_pc(caller()));
6199                 return;
6200         }
6201 
6202         if (ss->size == 0) {
6203                 cmn_err(CE_WARN, "%s bad handle: %s",
6204                     msg, mod_containing_pc(caller()));
6205                 return;
6206         }
6207 
6208         if (ss->n_items > 0) {
6209                 for (item = 0; item < ss->n_items; item++)
6210                         ddi_soft_state_free(ss, item);
6211                 kmem_free(ss->array, ss->n_items * sizeof (void *));
6212         }
6213 
6214         /*
6215          * Now delete any dirty arrays from previous 'grow' operations
6216          */
6217         for (dirty = ss->next; dirty; dirty = ss->next) {
6218                 ss->next = dirty->next;
6219                 kmem_free(dirty->array, dirty->n_items * sizeof (void *));
6220                 kmem_free(dirty, sizeof (*dirty));
6221         }
6222 
6223         mutex_destroy(&ss->lock);
6224         kmem_free(ss, sizeof (*ss));
6225 
6226         *state_p = NULL;
6227 }
6228 
6229 #define SS_N_ITEMS_PER_HASH     16
6230 #define SS_MIN_HASH_SZ          16
6231 #define SS_MAX_HASH_SZ          4096
6232 
6233 int
6234 ddi_soft_state_bystr_init(ddi_soft_state_bystr **state_p, size_t size,
6235     int n_items)
6236 {
6237         i_ddi_soft_state_bystr  *sss;
6238         int                     hash_sz;
6239 
6240         ASSERT(state_p && size && n_items);
6241         if ((state_p == NULL) || (size == 0) || (n_items == 0))
6242                 return (EINVAL);
6243 
6244         /* current implementation is based on hash, convert n_items to hash */
6245         hash_sz = n_items / SS_N_ITEMS_PER_HASH;
6246         if (hash_sz < SS_MIN_HASH_SZ)
6247                 hash_sz = SS_MIN_HASH_SZ;
6248         else if (hash_sz > SS_MAX_HASH_SZ)
6249                 hash_sz = SS_MAX_HASH_SZ;
6250 
6251         /* allocate soft_state pool */
6252         sss = kmem_zalloc(sizeof (*sss), KM_SLEEP);
6253         sss->ss_size = size;
6254         sss->ss_mod_hash = mod_hash_create_strhash("soft_state_bystr",
6255             hash_sz, mod_hash_null_valdtor);
6256         *state_p = (ddi_soft_state_bystr *)sss;
6257         return (0);
6258 }
6259 
6260 int
6261 ddi_soft_state_bystr_zalloc(ddi_soft_state_bystr *state, const char *str)
6262 {
6263         i_ddi_soft_state_bystr  *sss = (i_ddi_soft_state_bystr *)state;
6264         void                    *sso;
6265         char                    *dup_str;
6266 
6267         ASSERT(sss && str && sss->ss_mod_hash);
6268         if ((sss == NULL) || (str == NULL) || (sss->ss_mod_hash == NULL))
6269                 return (DDI_FAILURE);
6270         sso = kmem_zalloc(sss->ss_size, KM_SLEEP);
6271         dup_str = i_ddi_strdup((char *)str, KM_SLEEP);
6272         if (mod_hash_insert(sss->ss_mod_hash,
6273             (mod_hash_key_t)dup_str, (mod_hash_val_t)sso) == 0)
6274                 return (DDI_SUCCESS);
6275 
6276         /*
6277          * The only error from an strhash insert is caused by a duplicate key.
6278          * We refuse to tread on an existing elements, so free and fail.
6279          */
6280         kmem_free(dup_str, strlen(dup_str) + 1);
6281         kmem_free(sso, sss->ss_size);
6282         return (DDI_FAILURE);
6283 }
6284 
6285 void *
6286 ddi_soft_state_bystr_get(ddi_soft_state_bystr *state, const char *str)
6287 {
6288         i_ddi_soft_state_bystr  *sss = (i_ddi_soft_state_bystr *)state;
6289         void                    *sso;
6290 
6291         ASSERT(sss && str && sss->ss_mod_hash);
6292         if ((sss == NULL) || (str == NULL) || (sss->ss_mod_hash == NULL))
6293                 return (NULL);
6294 
6295         if (mod_hash_find(sss->ss_mod_hash,
6296             (mod_hash_key_t)str, (mod_hash_val_t *)&sso) == 0)
6297                 return (sso);
6298         return (NULL);
6299 }
6300 
6301 void
6302 ddi_soft_state_bystr_free(ddi_soft_state_bystr *state, const char *str)
6303 {
6304         i_ddi_soft_state_bystr  *sss = (i_ddi_soft_state_bystr *)state;
6305         void                    *sso;
6306 
6307         ASSERT(sss && str && sss->ss_mod_hash);
6308         if ((sss == NULL) || (str == NULL) || (sss->ss_mod_hash == NULL))
6309                 return;
6310 
6311         (void) mod_hash_remove(sss->ss_mod_hash,
6312             (mod_hash_key_t)str, (mod_hash_val_t *)&sso);
6313         kmem_free(sso, sss->ss_size);
6314 }
6315 
6316 void
6317 ddi_soft_state_bystr_fini(ddi_soft_state_bystr **state_p)
6318 {
6319         i_ddi_soft_state_bystr  *sss;
6320 
6321         ASSERT(state_p);
6322         if (state_p == NULL)
6323                 return;
6324 
6325         sss = (i_ddi_soft_state_bystr *)(*state_p);
6326         if (sss == NULL)
6327                 return;
6328 
6329         ASSERT(sss->ss_mod_hash);
6330         if (sss->ss_mod_hash) {
6331                 mod_hash_destroy_strhash(sss->ss_mod_hash);
6332                 sss->ss_mod_hash = NULL;
6333         }
6334 
6335         kmem_free(sss, sizeof (*sss));
6336         *state_p = NULL;
6337 }
6338 
6339 /*
6340  * The ddi_strid_* routines provide string-to-index management utilities.
6341  */
6342 /* allocate and initialize an strid set */
6343 int
6344 ddi_strid_init(ddi_strid **strid_p, int n_items)
6345 {
6346         i_ddi_strid     *ss;
6347         int             hash_sz;
6348 
6349         if (strid_p == NULL)
6350                 return (DDI_FAILURE);
6351 
6352         /* current implementation is based on hash, convert n_items to hash */
6353         hash_sz = n_items / SS_N_ITEMS_PER_HASH;
6354         if (hash_sz < SS_MIN_HASH_SZ)
6355                 hash_sz = SS_MIN_HASH_SZ;
6356         else if (hash_sz > SS_MAX_HASH_SZ)
6357                 hash_sz = SS_MAX_HASH_SZ;
6358 
6359         ss = kmem_alloc(sizeof (*ss), KM_SLEEP);
6360         ss->strid_chunksz = n_items;
6361         ss->strid_spacesz = n_items;
6362         ss->strid_space = id_space_create("strid", 1, n_items);
6363         ss->strid_bystr = mod_hash_create_strhash("strid_bystr", hash_sz,
6364             mod_hash_null_valdtor);
6365         ss->strid_byid = mod_hash_create_idhash("strid_byid", hash_sz,
6366             mod_hash_null_valdtor);
6367         *strid_p = (ddi_strid *)ss;
6368         return (DDI_SUCCESS);
6369 }
6370 
6371 /* allocate an id mapping within the specified set for str, return id */
6372 static id_t
6373 i_ddi_strid_alloc(ddi_strid *strid, char *str)
6374 {
6375         i_ddi_strid     *ss = (i_ddi_strid *)strid;
6376         id_t            id;
6377         char            *s;
6378 
6379         ASSERT(ss && str);
6380         if ((ss == NULL) || (str == NULL))
6381                 return (0);
6382 
6383         /*
6384          * Allocate an id using VM_FIRSTFIT in order to keep allocated id
6385          * range as compressed as possible.  This is important to minimize
6386          * the amount of space used when the id is used as a ddi_soft_state
6387          * index by the caller.
6388          *
6389          * If the id list is exhausted, increase the size of the list
6390          * by the chuck size specified in ddi_strid_init and reattempt
6391          * the allocation
6392          */
6393         if ((id = id_allocff_nosleep(ss->strid_space)) == (id_t)-1) {
6394                 id_space_extend(ss->strid_space, ss->strid_spacesz,
6395                     ss->strid_spacesz + ss->strid_chunksz);
6396                 ss->strid_spacesz += ss->strid_chunksz;
6397                 if ((id = id_allocff_nosleep(ss->strid_space)) == (id_t)-1)
6398                         return (0);
6399         }
6400 
6401         /*
6402          * NOTE: since we create and destroy in unison we can save space by
6403          * using bystr key as the byid value.  This means destroy must occur
6404          * in (byid, bystr) order.
6405          */
6406         s = i_ddi_strdup(str, KM_SLEEP);
6407         if (mod_hash_insert(ss->strid_bystr, (mod_hash_key_t)s,
6408             (mod_hash_val_t)(intptr_t)id) != 0) {
6409                 ddi_strid_free(strid, id);
6410                 return (0);
6411         }
6412         if (mod_hash_insert(ss->strid_byid, (mod_hash_key_t)(intptr_t)id,
6413             (mod_hash_val_t)s) != 0) {
6414                 ddi_strid_free(strid, id);
6415                 return (0);
6416         }
6417 
6418         /* NOTE: s if freed on mod_hash_destroy by mod_hash_strval_dtor */
6419         return (id);
6420 }
6421 
6422 /* allocate an id mapping within the specified set for str, return id */
6423 id_t
6424 ddi_strid_alloc(ddi_strid *strid, char *str)
6425 {
6426         return (i_ddi_strid_alloc(strid, str));
6427 }
6428 
6429 /* return the id within the specified strid given the str */
6430 id_t
6431 ddi_strid_str2id(ddi_strid *strid, char *str)
6432 {
6433         i_ddi_strid     *ss = (i_ddi_strid *)strid;
6434         id_t            id = 0;
6435         mod_hash_val_t  hv;
6436 
6437         ASSERT(ss && str);
6438         if (ss && str && (mod_hash_find(ss->strid_bystr,
6439             (mod_hash_key_t)str, &hv) == 0))
6440                 id = (int)(intptr_t)hv;
6441         return (id);
6442 }
6443 
6444 /* return str within the specified strid given the id */
6445 char *
6446 ddi_strid_id2str(ddi_strid *strid, id_t id)
6447 {
6448         i_ddi_strid     *ss = (i_ddi_strid *)strid;
6449         char            *str = NULL;
6450         mod_hash_val_t  hv;
6451 
6452         ASSERT(ss && id > 0);
6453         if (ss && (id > 0) && (mod_hash_find(ss->strid_byid,
6454             (mod_hash_key_t)(uintptr_t)id, &hv) == 0))
6455                 str = (char *)hv;
6456         return (str);
6457 }
6458 
6459 /* free the id mapping within the specified strid */
6460 void
6461 ddi_strid_free(ddi_strid *strid, id_t id)
6462 {
6463         i_ddi_strid     *ss = (i_ddi_strid *)strid;
6464         char            *str;
6465 
6466         ASSERT(ss && id > 0);
6467         if ((ss == NULL) || (id <= 0))
6468                 return;
6469 
6470         /* bystr key is byid value: destroy order must be (byid, bystr) */
6471         str = ddi_strid_id2str(strid, id);
6472         (void) mod_hash_destroy(ss->strid_byid, (mod_hash_key_t)(uintptr_t)id);
6473         id_free(ss->strid_space, id);
6474 
6475         if (str)
6476                 (void) mod_hash_destroy(ss->strid_bystr, (mod_hash_key_t)str);
6477 }
6478 
6479 /* destroy the strid set */
6480 void
6481 ddi_strid_fini(ddi_strid **strid_p)
6482 {
6483         i_ddi_strid     *ss;
6484 
6485         ASSERT(strid_p);
6486         if (strid_p == NULL)
6487                 return;
6488 
6489         ss = (i_ddi_strid *)(*strid_p);
6490         if (ss == NULL)
6491                 return;
6492 
6493         /* bystr key is byid value: destroy order must be (byid, bystr) */
6494         if (ss->strid_byid)
6495                 mod_hash_destroy_hash(ss->strid_byid);
6496         if (ss->strid_byid)
6497                 mod_hash_destroy_hash(ss->strid_bystr);
6498         if (ss->strid_space)
6499                 id_space_destroy(ss->strid_space);
6500         kmem_free(ss, sizeof (*ss));
6501         *strid_p = NULL;
6502 }
6503 
6504 /*
6505  * This sets the devi_addr entry in the dev_info structure 'dip' to 'name'.
6506  * Storage is double buffered to prevent updates during devi_addr use -
6507  * double buffering is adaquate for reliable ddi_deviname() consumption.
6508  * The double buffer is not freed until dev_info structure destruction
6509  * (by i_ddi_free_node).
6510  */
6511 void
6512 ddi_set_name_addr(dev_info_t *dip, char *name)
6513 {
6514         char    *buf = DEVI(dip)->devi_addr_buf;
6515         char    *newaddr;
6516 
6517         if (buf == NULL) {
6518                 buf = kmem_zalloc(2 * MAXNAMELEN, KM_SLEEP);
6519                 DEVI(dip)->devi_addr_buf = buf;
6520         }
6521 
6522         if (name) {
6523                 ASSERT(strlen(name) < MAXNAMELEN);
6524                 newaddr = (DEVI(dip)->devi_addr == buf) ?
6525                     (buf + MAXNAMELEN) : buf;
6526                 (void) strlcpy(newaddr, name, MAXNAMELEN);
6527         } else
6528                 newaddr = NULL;
6529 
6530         DEVI(dip)->devi_addr = newaddr;
6531 }
6532 
6533 char *
6534 ddi_get_name_addr(dev_info_t *dip)
6535 {
6536         return (DEVI(dip)->devi_addr);
6537 }
6538 
6539 void
6540 ddi_set_parent_data(dev_info_t *dip, void *pd)
6541 {
6542         DEVI(dip)->devi_parent_data = pd;
6543 }
6544 
6545 void *
6546 ddi_get_parent_data(dev_info_t *dip)
6547 {
6548         return (DEVI(dip)->devi_parent_data);
6549 }
6550 
6551 /*
6552  * ddi_name_to_major: returns the major number of a named module,
6553  * derived from the current driver alias binding.
6554  *
6555  * Caveat: drivers should avoid the use of this function, in particular
6556  * together with ddi_get_name/ddi_binding name, as per
6557  *      major = ddi_name_to_major(ddi_get_name(devi));
6558  * ddi_name_to_major() relies on the state of the device/alias binding,
6559  * which can and does change dynamically as aliases are administered
6560  * over time.  An attached device instance cannot rely on the major
6561  * number returned by ddi_name_to_major() to match its own major number.
6562  *
6563  * For driver use, ddi_driver_major() reliably returns the major number
6564  * for the module to which the device was bound at attach time over
6565  * the life of the instance.
6566  *      major = ddi_driver_major(dev_info_t *)
6567  */
6568 major_t
6569 ddi_name_to_major(char *name)
6570 {
6571         return (mod_name_to_major(name));
6572 }
6573 
6574 /*
6575  * ddi_major_to_name: Returns the module name bound to a major number.
6576  */
6577 char *
6578 ddi_major_to_name(major_t major)
6579 {
6580         return (mod_major_to_name(major));
6581 }
6582 
6583 /*
6584  * Return the name of the devinfo node pointed at by 'dip' in the buffer
6585  * pointed at by 'name.'  A devinfo node is named as a result of calling
6586  * ddi_initchild().
6587  *
6588  * Note: the driver must be held before calling this function!
6589  */
6590 char *
6591 ddi_deviname(dev_info_t *dip, char *name)
6592 {
6593         char *addrname;
6594         char none = '\0';
6595 
6596         if (dip == ddi_root_node()) {
6597                 *name = '\0';
6598                 return (name);
6599         }
6600 
6601         if (i_ddi_node_state(dip) < DS_BOUND) {
6602                 addrname = &none;
6603         } else {
6604                 /*
6605                  * Use ddi_get_name_addr() without checking state so we get
6606                  * a unit-address if we are called after ddi_set_name_addr()
6607                  * by nexus DDI_CTL_INITCHILD code, but before completing
6608                  * node promotion to DS_INITIALIZED.  We currently have
6609                  * two situations where we are called in this state:
6610                  *   o  For framework processing of a path-oriented alias.
6611                  *   o  If a SCSA nexus driver calls ddi_devid_register()
6612                  *      from it's tran_tgt_init(9E) implementation.
6613                  */
6614                 addrname = ddi_get_name_addr(dip);
6615                 if (addrname == NULL)
6616                         addrname = &none;
6617         }
6618 
6619         if (*addrname == '\0') {
6620                 (void) sprintf(name, "/%s", ddi_node_name(dip));
6621         } else {
6622                 (void) sprintf(name, "/%s@%s", ddi_node_name(dip), addrname);
6623         }
6624 
6625         return (name);
6626 }
6627 
6628 /*
6629  * Spits out the name of device node, typically name@addr, for a given node,
6630  * using the driver name, not the nodename.
6631  *
6632  * Used by match_parent. Not to be used elsewhere.
6633  */
6634 char *
6635 i_ddi_parname(dev_info_t *dip, char *name)
6636 {
6637         char *addrname;
6638 
6639         if (dip == ddi_root_node()) {
6640                 *name = '\0';
6641                 return (name);
6642         }
6643 
6644         ASSERT(i_ddi_node_state(dip) >= DS_INITIALIZED);
6645 
6646         if (*(addrname = ddi_get_name_addr(dip)) == '\0')
6647                 (void) sprintf(name, "%s", ddi_binding_name(dip));
6648         else
6649                 (void) sprintf(name, "%s@%s", ddi_binding_name(dip), addrname);
6650         return (name);
6651 }
6652 
6653 static char *
6654 pathname_work(dev_info_t *dip, char *path)
6655 {
6656         char *bp;
6657 
6658         if (dip == ddi_root_node()) {
6659                 *path = '\0';
6660                 return (path);
6661         }
6662         (void) pathname_work(ddi_get_parent(dip), path);
6663         bp = path + strlen(path);
6664         (void) ddi_deviname(dip, bp);
6665         return (path);
6666 }
6667 
6668 char *
6669 ddi_pathname(dev_info_t *dip, char *path)
6670 {
6671         return (pathname_work(dip, path));
6672 }
6673 
6674 char *
6675 ddi_pathname_minor(struct ddi_minor_data *dmdp, char *path)
6676 {
6677         if (dmdp->dip == NULL)
6678                 *path = '\0';
6679         else {
6680                 (void) ddi_pathname(dmdp->dip, path);
6681                 if (dmdp->ddm_name) {
6682                         (void) strcat(path, ":");
6683                         (void) strcat(path, dmdp->ddm_name);
6684                 }
6685         }
6686         return (path);
6687 }
6688 
6689 static char *
6690 pathname_work_obp(dev_info_t *dip, char *path)
6691 {
6692         char *bp;
6693         char *obp_path;
6694 
6695         /*
6696          * look up the "obp-path" property, return the path if it exists
6697          */
6698         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
6699             "obp-path", &obp_path) == DDI_PROP_SUCCESS) {
6700                 (void) strcpy(path, obp_path);
6701                 ddi_prop_free(obp_path);
6702                 return (path);
6703         }
6704 
6705         /*
6706          * stop at root, no obp path
6707          */
6708         if (dip == ddi_root_node()) {
6709                 return (NULL);
6710         }
6711 
6712         obp_path = pathname_work_obp(ddi_get_parent(dip), path);
6713         if (obp_path == NULL)
6714                 return (NULL);
6715 
6716         /*
6717          * append our component to parent's obp path
6718          */
6719         bp = path + strlen(path);
6720         if (*(bp - 1) != '/')
6721                 (void) strcat(bp++, "/");
6722         (void) ddi_deviname(dip, bp);
6723         return (path);
6724 }
6725 
6726 /*
6727  * return the 'obp-path' based path for the given node, or NULL if the node
6728  * does not have a different obp path. NOTE: Unlike ddi_pathname, this
6729  * function can't be called from interrupt context (since we need to
6730  * lookup a string property).
6731  */
6732 char *
6733 ddi_pathname_obp(dev_info_t *dip, char *path)
6734 {
6735         ASSERT(!servicing_interrupt());
6736         if (dip == NULL || path == NULL)
6737                 return (NULL);
6738 
6739         /* split work into a separate function to aid debugging */
6740         return (pathname_work_obp(dip, path));
6741 }
6742 
6743 int
6744 ddi_pathname_obp_set(dev_info_t *dip, char *component)
6745 {
6746         dev_info_t *pdip;
6747         char *obp_path = NULL;
6748         int rc = DDI_FAILURE;
6749 
6750         if (dip == NULL)
6751                 return (DDI_FAILURE);
6752 
6753         obp_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
6754 
6755         pdip = ddi_get_parent(dip);
6756 
6757         if (ddi_pathname_obp(pdip, obp_path) == NULL) {
6758                 (void) ddi_pathname(pdip, obp_path);
6759         }
6760 
6761         if (component) {
6762                 (void) strncat(obp_path, "/", MAXPATHLEN);
6763                 (void) strncat(obp_path, component, MAXPATHLEN);
6764         }
6765         rc = ndi_prop_update_string(DDI_DEV_T_NONE, dip, "obp-path",
6766             obp_path);
6767 
6768         if (obp_path)
6769                 kmem_free(obp_path, MAXPATHLEN);
6770 
6771         return (rc);
6772 }
6773 
6774 /*
6775  * Given a dev_t, return the pathname of the corresponding device in the
6776  * buffer pointed at by "path."  The buffer is assumed to be large enough
6777  * to hold the pathname of the device (MAXPATHLEN).
6778  *
6779  * The pathname of a device is the pathname of the devinfo node to which
6780  * the device "belongs," concatenated with the character ':' and the name
6781  * of the minor node corresponding to the dev_t.  If spec_type is 0 then
6782  * just the pathname of the devinfo node is returned without driving attach
6783  * of that node.  For a non-zero spec_type, an attach is performed and a
6784  * search of the minor list occurs.
6785  *
6786  * It is possible that the path associated with the dev_t is not
6787  * currently available in the devinfo tree.  In order to have a
6788  * dev_t, a device must have been discovered before, which means
6789  * that the path is always in the instance tree.  The one exception
6790  * to this is if the dev_t is associated with a pseudo driver, in
6791  * which case the device must exist on the pseudo branch of the
6792  * devinfo tree as a result of parsing .conf files.
6793  */
6794 int
6795 ddi_dev_pathname(dev_t devt, int spec_type, char *path)
6796 {
6797         int             circ;
6798         major_t         major = getmajor(devt);
6799         int             instance;
6800         dev_info_t      *dip;
6801         char            *minorname;
6802         char            *drvname;
6803 
6804         if (major >= devcnt)
6805                 goto fail;
6806         if (major == clone_major) {
6807                 /* clone has no minor nodes, manufacture the path here */
6808                 if ((drvname = ddi_major_to_name(getminor(devt))) == NULL)
6809                         goto fail;
6810 
6811                 (void) snprintf(path, MAXPATHLEN, "%s:%s", CLONE_PATH, drvname);
6812                 return (DDI_SUCCESS);
6813         }
6814 
6815         /* extract instance from devt (getinfo(9E) DDI_INFO_DEVT2INSTANCE). */
6816         if ((instance = dev_to_instance(devt)) == -1)
6817                 goto fail;
6818 
6819         /* reconstruct the path given the major/instance */
6820         if (e_ddi_majorinstance_to_path(major, instance, path) != DDI_SUCCESS)
6821                 goto fail;
6822 
6823         /* if spec_type given we must drive attach and search minor nodes */
6824         if ((spec_type == S_IFCHR) || (spec_type == S_IFBLK)) {
6825                 /* attach the path so we can search minors */
6826                 if ((dip = e_ddi_hold_devi_by_path(path, 0)) == NULL)
6827                         goto fail;
6828 
6829                 /* Add minorname to path. */
6830                 ndi_devi_enter(dip, &circ);
6831                 minorname = i_ddi_devtspectype_to_minorname(dip,
6832                     devt, spec_type);
6833                 if (minorname) {
6834                         (void) strcat(path, ":");
6835                         (void) strcat(path, minorname);
6836                 }
6837                 ndi_devi_exit(dip, circ);
6838                 ddi_release_devi(dip);
6839                 if (minorname == NULL)
6840                         goto fail;
6841         }
6842         ASSERT(strlen(path) < MAXPATHLEN);
6843         return (DDI_SUCCESS);
6844 
6845 fail:   *path = 0;
6846         return (DDI_FAILURE);
6847 }
6848 
6849 /*
6850  * Given a major number and an instance, return the path.
6851  * This interface does NOT drive attach.
6852  */
6853 int
6854 e_ddi_majorinstance_to_path(major_t major, int instance, char *path)
6855 {
6856         struct devnames *dnp;
6857         dev_info_t      *dip;
6858 
6859         if ((major >= devcnt) || (instance == -1)) {
6860                 *path = 0;
6861                 return (DDI_FAILURE);
6862         }
6863 
6864         /* look for the major/instance in the instance tree */
6865         if (e_ddi_instance_majorinstance_to_path(major, instance,
6866             path) == DDI_SUCCESS) {
6867                 ASSERT(strlen(path) < MAXPATHLEN);
6868                 return (DDI_SUCCESS);
6869         }
6870 
6871         /*
6872          * Not in instance tree, find the instance on the per driver list and
6873          * construct path to instance via ddi_pathname(). This is how paths
6874          * down the 'pseudo' branch are constructed.
6875          */
6876         dnp = &(devnamesp[major]);
6877         LOCK_DEV_OPS(&(dnp->dn_lock));
6878         for (dip = dnp->dn_head; dip;
6879             dip = (dev_info_t *)DEVI(dip)->devi_next) {
6880                 /* Skip if instance does not match. */
6881                 if (DEVI(dip)->devi_instance != instance)
6882                         continue;
6883 
6884                 /*
6885                  * An ndi_hold_devi() does not prevent DS_INITIALIZED->DS_BOUND
6886                  * node demotion, so it is not an effective way of ensuring
6887                  * that the ddi_pathname result has a unit-address.  Instead,
6888                  * we reverify the node state after calling ddi_pathname().
6889                  */
6890                 if (i_ddi_node_state(dip) >= DS_INITIALIZED) {
6891                         (void) ddi_pathname(dip, path);
6892                         if (i_ddi_node_state(dip) < DS_INITIALIZED)
6893                                 continue;
6894                         UNLOCK_DEV_OPS(&(dnp->dn_lock));
6895                         ASSERT(strlen(path) < MAXPATHLEN);
6896                         return (DDI_SUCCESS);
6897                 }
6898         }
6899         UNLOCK_DEV_OPS(&(dnp->dn_lock));
6900 
6901         /* can't reconstruct the path */
6902         *path = 0;
6903         return (DDI_FAILURE);
6904 }
6905 
6906 #define GLD_DRIVER_PPA "SUNW,gld_v0_ppa"
6907 
6908 /*
6909  * Given the dip for a network interface return the ppa for that interface.
6910  *
6911  * In all cases except GLD v0 drivers, the ppa == instance.
6912  * In the case of GLD v0 drivers, the ppa is equal to the attach order.
6913  * So for these drivers when the attach routine calls gld_register(),
6914  * the GLD framework creates an integer property called "gld_driver_ppa"
6915  * that can be queried here.
6916  *
6917  * The only time this function is used is when a system is booting over nfs.
6918  * In this case the system has to resolve the pathname of the boot device
6919  * to it's ppa.
6920  */
6921 int
6922 i_ddi_devi_get_ppa(dev_info_t *dip)
6923 {
6924         return (ddi_prop_get_int(DDI_DEV_T_ANY, dip,
6925             DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
6926             GLD_DRIVER_PPA, ddi_get_instance(dip)));
6927 }
6928 
6929 /*
6930  * i_ddi_devi_set_ppa() should only be called from gld_register()
6931  * and only for GLD v0 drivers
6932  */
6933 void
6934 i_ddi_devi_set_ppa(dev_info_t *dip, int ppa)
6935 {
6936         (void) e_ddi_prop_update_int(DDI_DEV_T_NONE, dip, GLD_DRIVER_PPA, ppa);
6937 }
6938 
6939 
6940 /*
6941  * Private DDI Console bell functions.
6942  */
6943 void
6944 ddi_ring_console_bell(clock_t duration)
6945 {
6946         if (ddi_console_bell_func != NULL)
6947                 (*ddi_console_bell_func)(duration);
6948 }
6949 
6950 void
6951 ddi_set_console_bell(void (*bellfunc)(clock_t duration))
6952 {
6953         ddi_console_bell_func = bellfunc;
6954 }
6955 
6956 int
6957 ddi_dma_alloc_handle(dev_info_t *dip, ddi_dma_attr_t *attr,
6958         int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep)
6959 {
6960         int (*funcp)() = ddi_dma_allochdl;
6961         ddi_dma_attr_t dma_attr;
6962         struct bus_ops *bop;
6963 
6964         if (attr == (ddi_dma_attr_t *)0)
6965                 return (DDI_DMA_BADATTR);
6966 
6967         dma_attr = *attr;
6968 
6969         bop = DEVI(dip)->devi_ops->devo_bus_ops;
6970         if (bop && bop->bus_dma_allochdl)
6971                 funcp = bop->bus_dma_allochdl;
6972 
6973         return ((*funcp)(dip, dip, &dma_attr, waitfp, arg, handlep));
6974 }
6975 
6976 void
6977 ddi_dma_free_handle(ddi_dma_handle_t *handlep)
6978 {
6979         ddi_dma_handle_t h = *handlep;
6980         (void) ddi_dma_freehdl(HD, HD, h);
6981 }
6982 
6983 static uintptr_t dma_mem_list_id = 0;
6984 
6985 
6986 int
6987 ddi_dma_mem_alloc(ddi_dma_handle_t handle, size_t length,
6988         ddi_device_acc_attr_t *accattrp, uint_t flags,
6989         int (*waitfp)(caddr_t), caddr_t arg, caddr_t *kaddrp,
6990         size_t *real_length, ddi_acc_handle_t *handlep)
6991 {
6992         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
6993         dev_info_t *dip = hp->dmai_rdip;
6994         ddi_acc_hdl_t *ap;
6995         ddi_dma_attr_t *attrp = &hp->dmai_attr;
6996         uint_t sleepflag, xfermodes;
6997         int (*fp)(caddr_t);
6998         int rval;
6999 
7000         if (waitfp == DDI_DMA_SLEEP)
7001                 fp = (int (*)())KM_SLEEP;
7002         else if (waitfp == DDI_DMA_DONTWAIT)
7003                 fp = (int (*)())KM_NOSLEEP;
7004         else
7005                 fp = waitfp;
7006         *handlep = impl_acc_hdl_alloc(fp, arg);
7007         if (*handlep == NULL)
7008                 return (DDI_FAILURE);
7009 
7010         /* check if the cache attributes are supported */
7011         if (i_ddi_check_cache_attr(flags) == B_FALSE)
7012                 return (DDI_FAILURE);
7013 
7014         /*
7015          * Transfer the meaningful bits to xfermodes.
7016          * Double-check if the 3rd party driver correctly sets the bits.
7017          * If not, set DDI_DMA_STREAMING to keep compatibility.
7018          */
7019         xfermodes = flags & (DDI_DMA_CONSISTENT | DDI_DMA_STREAMING);
7020         if (xfermodes == 0) {
7021                 xfermodes = DDI_DMA_STREAMING;
7022         }
7023 
7024         /*
7025          * initialize the common elements of data access handle
7026          */
7027         ap = impl_acc_hdl_get(*handlep);
7028         ap->ah_vers = VERS_ACCHDL;
7029         ap->ah_dip = dip;
7030         ap->ah_offset = 0;
7031         ap->ah_len = 0;
7032         ap->ah_xfermodes = flags;
7033         ap->ah_acc = *accattrp;
7034 
7035         sleepflag = ((waitfp == DDI_DMA_SLEEP) ? 1 : 0);
7036         if (xfermodes == DDI_DMA_CONSISTENT) {
7037                 rval = i_ddi_mem_alloc(dip, attrp, length, sleepflag,
7038                     flags, accattrp, kaddrp, NULL, ap);
7039                 *real_length = length;
7040         } else {
7041                 rval = i_ddi_mem_alloc(dip, attrp, length, sleepflag,
7042                     flags, accattrp, kaddrp, real_length, ap);
7043         }
7044         if (rval == DDI_SUCCESS) {
7045                 ap->ah_len = (off_t)(*real_length);
7046                 ap->ah_addr = *kaddrp;
7047         } else {
7048                 impl_acc_hdl_free(*handlep);
7049                 *handlep = (ddi_acc_handle_t)NULL;
7050                 if (waitfp != DDI_DMA_SLEEP && waitfp != DDI_DMA_DONTWAIT) {
7051                         ddi_set_callback(waitfp, arg, &dma_mem_list_id);
7052                 }
7053                 rval = DDI_FAILURE;
7054         }
7055         return (rval);
7056 }
7057 
7058 void
7059 ddi_dma_mem_free(ddi_acc_handle_t *handlep)
7060 {
7061         ddi_acc_hdl_t *ap;
7062 
7063         ap = impl_acc_hdl_get(*handlep);
7064         ASSERT(ap);
7065 
7066         i_ddi_mem_free((caddr_t)ap->ah_addr, ap);
7067 
7068         /*
7069          * free the handle
7070          */
7071         impl_acc_hdl_free(*handlep);
7072         *handlep = (ddi_acc_handle_t)NULL;
7073 
7074         if (dma_mem_list_id != 0) {
7075                 ddi_run_callback(&dma_mem_list_id);
7076         }
7077 }
7078 
7079 int
7080 ddi_dma_buf_bind_handle(ddi_dma_handle_t handle, struct buf *bp,
7081         uint_t flags, int (*waitfp)(caddr_t), caddr_t arg,
7082         ddi_dma_cookie_t *cookiep, uint_t *ccountp)
7083 {
7084         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7085         dev_info_t *dip, *rdip;
7086         struct ddi_dma_req dmareq;
7087         int (*funcp)();
7088 
7089         dmareq.dmar_flags = flags;
7090         dmareq.dmar_fp = waitfp;
7091         dmareq.dmar_arg = arg;
7092         dmareq.dmar_object.dmao_size = (uint_t)bp->b_bcount;
7093 
7094         if (bp->b_flags & B_PAGEIO) {
7095                 dmareq.dmar_object.dmao_type = DMA_OTYP_PAGES;
7096                 dmareq.dmar_object.dmao_obj.pp_obj.pp_pp = bp->b_pages;
7097                 dmareq.dmar_object.dmao_obj.pp_obj.pp_offset =
7098                     (uint_t)(((uintptr_t)bp->b_un.b_addr) & MMU_PAGEOFFSET);
7099         } else {
7100                 dmareq.dmar_object.dmao_obj.virt_obj.v_addr = bp->b_un.b_addr;
7101                 if (bp->b_flags & B_SHADOW) {
7102                         dmareq.dmar_object.dmao_obj.virt_obj.v_priv =
7103                             bp->b_shadow;
7104                         dmareq.dmar_object.dmao_type = DMA_OTYP_BUFVADDR;
7105                 } else {
7106                         dmareq.dmar_object.dmao_type =
7107                             (bp->b_flags & (B_PHYS | B_REMAPPED)) ?
7108                             DMA_OTYP_BUFVADDR : DMA_OTYP_VADDR;
7109                         dmareq.dmar_object.dmao_obj.virt_obj.v_priv = NULL;
7110                 }
7111 
7112                 /*
7113                  * If the buffer has no proc pointer, or the proc
7114                  * struct has the kernel address space, or the buffer has
7115                  * been marked B_REMAPPED (meaning that it is now
7116                  * mapped into the kernel's address space), then
7117                  * the address space is kas (kernel address space).
7118                  */
7119                 if ((bp->b_proc == NULL) || (bp->b_proc->p_as == &kas) ||
7120                     (bp->b_flags & B_REMAPPED)) {
7121                         dmareq.dmar_object.dmao_obj.virt_obj.v_as = 0;
7122                 } else {
7123                         dmareq.dmar_object.dmao_obj.virt_obj.v_as =
7124                             bp->b_proc->p_as;
7125                 }
7126         }
7127 
7128         dip = rdip = hp->dmai_rdip;
7129         if (dip != ddi_root_node())
7130                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl;
7131         funcp = DEVI(rdip)->devi_bus_dma_bindfunc;
7132         return ((*funcp)(dip, rdip, handle, &dmareq, cookiep, ccountp));
7133 }
7134 
7135 int
7136 ddi_dma_addr_bind_handle(ddi_dma_handle_t handle, struct as *as,
7137         caddr_t addr, size_t len, uint_t flags, int (*waitfp)(caddr_t),
7138         caddr_t arg, ddi_dma_cookie_t *cookiep, uint_t *ccountp)
7139 {
7140         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7141         dev_info_t *dip, *rdip;
7142         struct ddi_dma_req dmareq;
7143         int (*funcp)();
7144 
7145         if (len == (uint_t)0) {
7146                 return (DDI_DMA_NOMAPPING);
7147         }
7148         dmareq.dmar_flags = flags;
7149         dmareq.dmar_fp = waitfp;
7150         dmareq.dmar_arg = arg;
7151         dmareq.dmar_object.dmao_size = len;
7152         dmareq.dmar_object.dmao_type = DMA_OTYP_VADDR;
7153         dmareq.dmar_object.dmao_obj.virt_obj.v_as = as;
7154         dmareq.dmar_object.dmao_obj.virt_obj.v_addr = addr;
7155         dmareq.dmar_object.dmao_obj.virt_obj.v_priv = NULL;
7156 
7157         dip = rdip = hp->dmai_rdip;
7158         if (dip != ddi_root_node())
7159                 dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl;
7160         funcp = DEVI(rdip)->devi_bus_dma_bindfunc;
7161         return ((*funcp)(dip, rdip, handle, &dmareq, cookiep, ccountp));
7162 }
7163 
7164 void
7165 ddi_dma_nextcookie(ddi_dma_handle_t handle, ddi_dma_cookie_t *cookiep)
7166 {
7167         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7168         ddi_dma_cookie_t *cp;
7169 
7170         cp = hp->dmai_cookie;
7171         ASSERT(cp);
7172 
7173         cookiep->dmac_notused = cp->dmac_notused;
7174         cookiep->dmac_type = cp->dmac_type;
7175         cookiep->dmac_address = cp->dmac_address;
7176         cookiep->dmac_size = cp->dmac_size;
7177         hp->dmai_cookie++;
7178 }
7179 
7180 int
7181 ddi_dma_numwin(ddi_dma_handle_t handle, uint_t *nwinp)
7182 {
7183         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7184         if ((hp->dmai_rflags & DDI_DMA_PARTIAL) == 0) {
7185                 return (DDI_FAILURE);
7186         } else {
7187                 *nwinp = hp->dmai_nwin;
7188                 return (DDI_SUCCESS);
7189         }
7190 }
7191 
7192 int
7193 ddi_dma_getwin(ddi_dma_handle_t h, uint_t win, off_t *offp,
7194         size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp)
7195 {
7196         int (*funcp)() = ddi_dma_win;
7197         struct bus_ops *bop;
7198 
7199         bop = DEVI(HD)->devi_ops->devo_bus_ops;
7200         if (bop && bop->bus_dma_win)
7201                 funcp = bop->bus_dma_win;
7202 
7203         return ((*funcp)(HD, HD, h, win, offp, lenp, cookiep, ccountp));
7204 }
7205 
7206 int
7207 ddi_dma_set_sbus64(ddi_dma_handle_t h, ulong_t burstsizes)
7208 {
7209         return (ddi_dma_mctl(HD, HD, h, DDI_DMA_SET_SBUS64, 0,
7210             &burstsizes, 0, 0));
7211 }
7212 
7213 int
7214 i_ddi_dma_fault_check(ddi_dma_impl_t *hp)
7215 {
7216         return (hp->dmai_fault);
7217 }
7218 
7219 int
7220 ddi_check_dma_handle(ddi_dma_handle_t handle)
7221 {
7222         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7223         int (*check)(ddi_dma_impl_t *);
7224 
7225         if ((check = hp->dmai_fault_check) == NULL)
7226                 check = i_ddi_dma_fault_check;
7227 
7228         return (((*check)(hp) == DDI_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
7229 }
7230 
7231 void
7232 i_ddi_dma_set_fault(ddi_dma_handle_t handle)
7233 {
7234         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7235         void (*notify)(ddi_dma_impl_t *);
7236 
7237         if (!hp->dmai_fault) {
7238                 hp->dmai_fault = 1;
7239                 if ((notify = hp->dmai_fault_notify) != NULL)
7240                         (*notify)(hp);
7241         }
7242 }
7243 
7244 void
7245 i_ddi_dma_clr_fault(ddi_dma_handle_t handle)
7246 {
7247         ddi_dma_impl_t *hp = (ddi_dma_impl_t *)handle;
7248         void (*notify)(ddi_dma_impl_t *);
7249 
7250         if (hp->dmai_fault) {
7251                 hp->dmai_fault = 0;
7252                 if ((notify = hp->dmai_fault_notify) != NULL)
7253                         (*notify)(hp);
7254         }
7255 }
7256 
7257 /*
7258  * register mapping routines.
7259  */
7260 int
7261 ddi_regs_map_setup(dev_info_t *dip, uint_t rnumber, caddr_t *addrp,
7262         offset_t offset, offset_t len, ddi_device_acc_attr_t *accattrp,
7263         ddi_acc_handle_t *handle)
7264 {
7265         ddi_map_req_t mr;
7266         ddi_acc_hdl_t *hp;
7267         int result;
7268 
7269         /*
7270          * Allocate and initialize the common elements of data access handle.
7271          */
7272         *handle = impl_acc_hdl_alloc(KM_SLEEP, NULL);
7273         hp = impl_acc_hdl_get(*handle);
7274         hp->ah_vers = VERS_ACCHDL;
7275         hp->ah_dip = dip;
7276         hp->ah_rnumber = rnumber;
7277         hp->ah_offset = offset;
7278         hp->ah_len = len;
7279         hp->ah_acc = *accattrp;
7280 
7281         /*
7282          * Set up the mapping request and call to parent.
7283          */
7284         mr.map_op = DDI_MO_MAP_LOCKED;
7285         mr.map_type = DDI_MT_RNUMBER;
7286         mr.map_obj.rnumber = rnumber;
7287         mr.map_prot = PROT_READ | PROT_WRITE;
7288         mr.map_flags = DDI_MF_KERNEL_MAPPING;
7289         mr.map_handlep = hp;
7290         mr.map_vers = DDI_MAP_VERSION;
7291         result = ddi_map(dip, &mr, offset, len, addrp);
7292 
7293         /*
7294          * check for end result
7295          */
7296         if (result != DDI_SUCCESS) {
7297                 impl_acc_hdl_free(*handle);
7298                 *handle = (ddi_acc_handle_t)NULL;
7299         } else {
7300                 hp->ah_addr = *addrp;
7301         }
7302 
7303         return (result);
7304 }
7305 
7306 void
7307 ddi_regs_map_free(ddi_acc_handle_t *handlep)
7308 {
7309         ddi_map_req_t mr;
7310         ddi_acc_hdl_t *hp;
7311 
7312         hp = impl_acc_hdl_get(*handlep);
7313         ASSERT(hp);
7314 
7315         mr.map_op = DDI_MO_UNMAP;
7316         mr.map_type = DDI_MT_RNUMBER;
7317         mr.map_obj.rnumber = hp->ah_rnumber;
7318         mr.map_prot = PROT_READ | PROT_WRITE;
7319         mr.map_flags = DDI_MF_KERNEL_MAPPING;
7320         mr.map_handlep = hp;
7321         mr.map_vers = DDI_MAP_VERSION;
7322 
7323         /*
7324          * Call my parent to unmap my regs.
7325          */
7326         (void) ddi_map(hp->ah_dip, &mr, hp->ah_offset,
7327             hp->ah_len, &hp->ah_addr);
7328         /*
7329          * free the handle
7330          */
7331         impl_acc_hdl_free(*handlep);
7332         *handlep = (ddi_acc_handle_t)NULL;
7333 }
7334 
7335 int
7336 ddi_device_zero(ddi_acc_handle_t handle, caddr_t dev_addr, size_t bytecount,
7337         ssize_t dev_advcnt, uint_t dev_datasz)
7338 {
7339         uint8_t *b;
7340         uint16_t *w;
7341         uint32_t *l;
7342         uint64_t *ll;
7343 
7344         /* check for total byte count is multiple of data transfer size */
7345         if (bytecount != ((bytecount / dev_datasz) * dev_datasz))
7346                 return (DDI_FAILURE);
7347 
7348         switch (dev_datasz) {
7349         case DDI_DATA_SZ01_ACC:
7350                 for (b = (uint8_t *)dev_addr;
7351                     bytecount != 0; bytecount -= 1, b += dev_advcnt)
7352                         ddi_put8(handle, b, 0);
7353                 break;
7354         case DDI_DATA_SZ02_ACC:
7355                 for (w = (uint16_t *)dev_addr;
7356                     bytecount != 0; bytecount -= 2, w += dev_advcnt)
7357                         ddi_put16(handle, w, 0);
7358                 break;
7359         case DDI_DATA_SZ04_ACC:
7360                 for (l = (uint32_t *)dev_addr;
7361                     bytecount != 0; bytecount -= 4, l += dev_advcnt)
7362                         ddi_put32(handle, l, 0);
7363                 break;
7364         case DDI_DATA_SZ08_ACC:
7365                 for (ll = (uint64_t *)dev_addr;
7366                     bytecount != 0; bytecount -= 8, ll += dev_advcnt)
7367                         ddi_put64(handle, ll, 0x0ll);
7368                 break;
7369         default:
7370                 return (DDI_FAILURE);
7371         }
7372         return (DDI_SUCCESS);
7373 }
7374 
7375 int
7376 ddi_device_copy(
7377         ddi_acc_handle_t src_handle, caddr_t src_addr, ssize_t src_advcnt,
7378         ddi_acc_handle_t dest_handle, caddr_t dest_addr, ssize_t dest_advcnt,
7379         size_t bytecount, uint_t dev_datasz)
7380 {
7381         uint8_t *b_src, *b_dst;
7382         uint16_t *w_src, *w_dst;
7383         uint32_t *l_src, *l_dst;
7384         uint64_t *ll_src, *ll_dst;
7385 
7386         /* check for total byte count is multiple of data transfer size */
7387         if (bytecount != ((bytecount / dev_datasz) * dev_datasz))
7388                 return (DDI_FAILURE);
7389 
7390         switch (dev_datasz) {
7391         case DDI_DATA_SZ01_ACC:
7392                 b_src = (uint8_t *)src_addr;
7393                 b_dst = (uint8_t *)dest_addr;
7394 
7395                 for (; bytecount != 0; bytecount -= 1) {
7396                         ddi_put8(dest_handle, b_dst,
7397                             ddi_get8(src_handle, b_src));
7398                         b_dst += dest_advcnt;
7399                         b_src += src_advcnt;
7400                 }
7401                 break;
7402         case DDI_DATA_SZ02_ACC:
7403                 w_src = (uint16_t *)src_addr;
7404                 w_dst = (uint16_t *)dest_addr;
7405 
7406                 for (; bytecount != 0; bytecount -= 2) {
7407                         ddi_put16(dest_handle, w_dst,
7408                             ddi_get16(src_handle, w_src));
7409                         w_dst += dest_advcnt;
7410                         w_src += src_advcnt;
7411                 }
7412                 break;
7413         case DDI_DATA_SZ04_ACC:
7414                 l_src = (uint32_t *)src_addr;
7415                 l_dst = (uint32_t *)dest_addr;
7416 
7417                 for (; bytecount != 0; bytecount -= 4) {
7418                         ddi_put32(dest_handle, l_dst,
7419                             ddi_get32(src_handle, l_src));
7420                         l_dst += dest_advcnt;
7421                         l_src += src_advcnt;
7422                 }
7423                 break;
7424         case DDI_DATA_SZ08_ACC:
7425                 ll_src = (uint64_t *)src_addr;
7426                 ll_dst = (uint64_t *)dest_addr;
7427 
7428                 for (; bytecount != 0; bytecount -= 8) {
7429                         ddi_put64(dest_handle, ll_dst,
7430                             ddi_get64(src_handle, ll_src));
7431                         ll_dst += dest_advcnt;
7432                         ll_src += src_advcnt;
7433                 }
7434                 break;
7435         default:
7436                 return (DDI_FAILURE);
7437         }
7438         return (DDI_SUCCESS);
7439 }
7440 
7441 #define swap16(value)  \
7442         ((((value) & 0xff) << 8) | ((value) >> 8))
7443 
7444 #define swap32(value)   \
7445         (((uint32_t)swap16((uint16_t)((value) & 0xffff)) << 16) | \
7446         (uint32_t)swap16((uint16_t)((value) >> 16)))
7447 
7448 #define swap64(value)   \
7449         (((uint64_t)swap32((uint32_t)((value) & 0xffffffff)) \
7450             << 32) | \
7451         (uint64_t)swap32((uint32_t)((value) >> 32)))
7452 
7453 uint16_t
7454 ddi_swap16(uint16_t value)
7455 {
7456         return (swap16(value));
7457 }
7458 
7459 uint32_t
7460 ddi_swap32(uint32_t value)
7461 {
7462         return (swap32(value));
7463 }
7464 
7465 uint64_t
7466 ddi_swap64(uint64_t value)
7467 {
7468         return (swap64(value));
7469 }
7470 
7471 /*
7472  * Convert a binding name to a driver name.
7473  * A binding name is the name used to determine the driver for a
7474  * device - it may be either an alias for the driver or the name
7475  * of the driver itself.
7476  */
7477 char *
7478 i_binding_to_drv_name(char *bname)
7479 {
7480         major_t major_no;
7481 
7482         ASSERT(bname != NULL);
7483 
7484         if ((major_no = ddi_name_to_major(bname)) == -1)
7485                 return (NULL);
7486         return (ddi_major_to_name(major_no));
7487 }
7488 
7489 /*
7490  * Search for minor name that has specified dev_t and spec_type.
7491  * If spec_type is zero then any dev_t match works.  Since we
7492  * are returning a pointer to the minor name string, we require the
7493  * caller to do the locking.
7494  */
7495 char *
7496 i_ddi_devtspectype_to_minorname(dev_info_t *dip, dev_t dev, int spec_type)
7497 {
7498         struct ddi_minor_data   *dmdp;
7499 
7500         /*
7501          * The did layered driver currently intentionally returns a
7502          * devinfo ptr for an underlying sd instance based on a did
7503          * dev_t. In this case it is not an error.
7504          *
7505          * The did layered driver is associated with Sun Cluster.
7506          */
7507         ASSERT((ddi_driver_major(dip) == getmajor(dev)) ||
7508             (strcmp(ddi_major_to_name(getmajor(dev)), "did") == 0));
7509 
7510         ASSERT(DEVI_BUSY_OWNED(dip));
7511         for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) {
7512                 if (((dmdp->type == DDM_MINOR) ||
7513                     (dmdp->type == DDM_INTERNAL_PATH) ||
7514                     (dmdp->type == DDM_DEFAULT)) &&
7515                     (dmdp->ddm_dev == dev) &&
7516                     ((((spec_type & (S_IFCHR|S_IFBLK))) == 0) ||
7517                     (dmdp->ddm_spec_type == spec_type)))
7518                         return (dmdp->ddm_name);
7519         }
7520 
7521         return (NULL);
7522 }
7523 
7524 /*
7525  * Find the devt and spectype of the specified minor_name.
7526  * Return DDI_FAILURE if minor_name not found. Since we are
7527  * returning everything via arguments we can do the locking.
7528  */
7529 int
7530 i_ddi_minorname_to_devtspectype(dev_info_t *dip, char *minor_name,
7531         dev_t *devtp, int *spectypep)
7532 {
7533         int                     circ;
7534         struct ddi_minor_data   *dmdp;
7535 
7536         /* deal with clone minor nodes */
7537         if (dip == clone_dip) {
7538                 major_t major;
7539                 /*
7540                  * Make sure minor_name is a STREAMS driver.
7541                  * We load the driver but don't attach to any instances.
7542                  */
7543 
7544                 major = ddi_name_to_major(minor_name);
7545                 if (major == DDI_MAJOR_T_NONE)
7546                         return (DDI_FAILURE);
7547 
7548                 if (ddi_hold_driver(major) == NULL)
7549                         return (DDI_FAILURE);
7550 
7551                 if (STREAMSTAB(major) == NULL) {
7552                         ddi_rele_driver(major);
7553                         return (DDI_FAILURE);
7554                 }
7555                 ddi_rele_driver(major);
7556 
7557                 if (devtp)
7558                         *devtp = makedevice(clone_major, (minor_t)major);
7559 
7560                 if (spectypep)
7561                         *spectypep = S_IFCHR;
7562 
7563                 return (DDI_SUCCESS);
7564         }
7565 
7566         ndi_devi_enter(dip, &circ);
7567         for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) {
7568                 if (((dmdp->type != DDM_MINOR) &&
7569                     (dmdp->type != DDM_INTERNAL_PATH) &&
7570                     (dmdp->type != DDM_DEFAULT)) ||
7571                     strcmp(minor_name, dmdp->ddm_name))
7572                         continue;
7573 
7574                 if (devtp)
7575                         *devtp = dmdp->ddm_dev;
7576 
7577                 if (spectypep)
7578                         *spectypep = dmdp->ddm_spec_type;
7579 
7580                 ndi_devi_exit(dip, circ);
7581                 return (DDI_SUCCESS);
7582         }
7583         ndi_devi_exit(dip, circ);
7584 
7585         return (DDI_FAILURE);
7586 }
7587 
7588 static kmutex_t devid_gen_mutex;
7589 static short    devid_gen_number;
7590 
7591 #ifdef DEBUG
7592 
7593 static int      devid_register_corrupt = 0;
7594 static int      devid_register_corrupt_major = 0;
7595 static int      devid_register_corrupt_hint = 0;
7596 static int      devid_register_corrupt_hint_major = 0;
7597 
7598 static int devid_lyr_debug = 0;
7599 
7600 #define DDI_DEBUG_DEVID_DEVTS(msg, ndevs, devs)         \
7601         if (devid_lyr_debug)                                    \
7602                 ddi_debug_devid_devts(msg, ndevs, devs)
7603 
7604 #else
7605 
7606 #define DDI_DEBUG_DEVID_DEVTS(msg, ndevs, devs)
7607 
7608 #endif /* DEBUG */
7609 
7610 
7611 #ifdef  DEBUG
7612 
7613 static void
7614 ddi_debug_devid_devts(char *msg, int ndevs, dev_t *devs)
7615 {
7616         int i;
7617 
7618         cmn_err(CE_CONT, "%s:\n", msg);
7619         for (i = 0; i < ndevs; i++) {
7620                 cmn_err(CE_CONT, "    0x%lx\n", devs[i]);
7621         }
7622 }
7623 
7624 static void
7625 ddi_debug_devid_paths(char *msg, int npaths, char **paths)
7626 {
7627         int i;
7628 
7629         cmn_err(CE_CONT, "%s:\n", msg);
7630         for (i = 0; i < npaths; i++) {
7631                 cmn_err(CE_CONT, "    %s\n", paths[i]);
7632         }
7633 }
7634 
7635 static void
7636 ddi_debug_devid_devts_per_path(char *path, int ndevs, dev_t *devs)
7637 {
7638         int i;
7639 
7640         cmn_err(CE_CONT, "dev_ts per path %s\n", path);
7641         for (i = 0; i < ndevs; i++) {
7642                 cmn_err(CE_CONT, "    0x%lx\n", devs[i]);
7643         }
7644 }
7645 
7646 #endif  /* DEBUG */
7647 
7648 /*
7649  * Register device id into DDI framework.
7650  * Must be called when the driver is bound.
7651  */
7652 static int
7653 i_ddi_devid_register(dev_info_t *dip, ddi_devid_t devid)
7654 {
7655         impl_devid_t    *i_devid = (impl_devid_t *)devid;
7656         size_t          driver_len;
7657         const char      *driver_name;
7658         char            *devid_str;
7659         major_t         major;
7660 
7661         if ((dip == NULL) ||
7662             ((major = ddi_driver_major(dip)) == DDI_MAJOR_T_NONE))
7663                 return (DDI_FAILURE);
7664 
7665         /* verify that the devid is valid */
7666         if (ddi_devid_valid(devid) != DDI_SUCCESS)
7667                 return (DDI_FAILURE);
7668 
7669         /* Updating driver name hint in devid */
7670         driver_name = ddi_driver_name(dip);
7671         driver_len = strlen(driver_name);
7672         if (driver_len > DEVID_HINT_SIZE) {
7673                 /* Pick up last four characters of driver name */
7674                 driver_name += driver_len - DEVID_HINT_SIZE;
7675                 driver_len = DEVID_HINT_SIZE;
7676         }
7677         bzero(i_devid->did_driver, DEVID_HINT_SIZE);
7678         bcopy(driver_name, i_devid->did_driver, driver_len);
7679 
7680 #ifdef DEBUG
7681         /* Corrupt the devid for testing. */
7682         if (devid_register_corrupt)
7683                 i_devid->did_id[0] += devid_register_corrupt;
7684         if (devid_register_corrupt_major &&
7685             (major == devid_register_corrupt_major))
7686                 i_devid->did_id[0] += 1;
7687         if (devid_register_corrupt_hint)
7688                 i_devid->did_driver[0] += devid_register_corrupt_hint;
7689         if (devid_register_corrupt_hint_major &&
7690             (major == devid_register_corrupt_hint_major))
7691                 i_devid->did_driver[0] += 1;
7692 #endif /* DEBUG */
7693 
7694         /* encode the devid as a string */
7695         if ((devid_str = ddi_devid_str_encode(devid, NULL)) == NULL)
7696                 return (DDI_FAILURE);
7697 
7698         /* add string as a string property */
7699         if (ndi_prop_update_string(DDI_DEV_T_NONE, dip,
7700             DEVID_PROP_NAME, devid_str) != DDI_SUCCESS) {
7701                 cmn_err(CE_WARN, "%s%d: devid property update failed",
7702                     ddi_driver_name(dip), ddi_get_instance(dip));
7703                 ddi_devid_str_free(devid_str);
7704                 return (DDI_FAILURE);
7705         }
7706 
7707         /* keep pointer to devid string for interrupt context fma code */
7708         if (DEVI(dip)->devi_devid_str)
7709                 ddi_devid_str_free(DEVI(dip)->devi_devid_str);
7710         DEVI(dip)->devi_devid_str = devid_str;
7711         return (DDI_SUCCESS);
7712 }
7713 
7714 int
7715 ddi_devid_register(dev_info_t *dip, ddi_devid_t devid)
7716 {
7717         int rval;
7718 
7719         rval = i_ddi_devid_register(dip, devid);
7720         if (rval == DDI_SUCCESS) {
7721                 /*
7722                  * Register devid in devid-to-path cache
7723                  */
7724                 if (e_devid_cache_register(dip, devid) == DDI_SUCCESS) {
7725                         mutex_enter(&DEVI(dip)->devi_lock);
7726                         DEVI(dip)->devi_flags |= DEVI_CACHED_DEVID;
7727                         mutex_exit(&DEVI(dip)->devi_lock);
7728                 } else if (ddi_get_name_addr(dip)) {
7729                         /*
7730                          * We only expect cache_register DDI_FAILURE when we
7731                          * can't form the full path because of NULL devi_addr.
7732                          */
7733                         cmn_err(CE_WARN, "%s%d: failed to cache devid",
7734                             ddi_driver_name(dip), ddi_get_instance(dip));
7735                 }
7736         } else {
7737                 cmn_err(CE_WARN, "%s%d: failed to register devid",
7738                     ddi_driver_name(dip), ddi_get_instance(dip));
7739         }
7740         return (rval);
7741 }
7742 
7743 /*
7744  * Remove (unregister) device id from DDI framework.
7745  * Must be called when device is detached.
7746  */
7747 static void
7748 i_ddi_devid_unregister(dev_info_t *dip)
7749 {
7750         if (DEVI(dip)->devi_devid_str) {
7751                 ddi_devid_str_free(DEVI(dip)->devi_devid_str);
7752                 DEVI(dip)->devi_devid_str = NULL;
7753         }
7754 
7755         /* remove the devid property */
7756         (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, DEVID_PROP_NAME);
7757 }
7758 
7759 void
7760 ddi_devid_unregister(dev_info_t *dip)
7761 {
7762         mutex_enter(&DEVI(dip)->devi_lock);
7763         DEVI(dip)->devi_flags &= ~DEVI_CACHED_DEVID;
7764         mutex_exit(&DEVI(dip)->devi_lock);
7765         e_devid_cache_unregister(dip);
7766         i_ddi_devid_unregister(dip);
7767 }
7768 
7769 /*
7770  * Allocate and initialize a device id.
7771  */
7772 int
7773 ddi_devid_init(
7774         dev_info_t      *dip,
7775         ushort_t        devid_type,
7776         ushort_t        nbytes,
7777         void            *id,
7778         ddi_devid_t     *ret_devid)
7779 {
7780         impl_devid_t    *i_devid;
7781         int             sz = sizeof (*i_devid) + nbytes - sizeof (char);
7782         int             driver_len;
7783         const char      *driver_name;
7784 
7785         switch (devid_type) {
7786         case DEVID_SCSI3_WWN:
7787                 /*FALLTHRU*/
7788         case DEVID_SCSI_SERIAL:
7789                 /*FALLTHRU*/
7790         case DEVID_ATA_SERIAL:
7791                 /*FALLTHRU*/
7792         case DEVID_ENCAP:
7793                 if (nbytes == 0)
7794                         return (DDI_FAILURE);
7795                 if (id == NULL)
7796                         return (DDI_FAILURE);
7797                 break;
7798         case DEVID_FAB:
7799                 if (nbytes != 0)
7800                         return (DDI_FAILURE);
7801                 if (id != NULL)
7802                         return (DDI_FAILURE);
7803                 nbytes = sizeof (int) +
7804                     sizeof (struct timeval32) + sizeof (short);
7805                 sz += nbytes;
7806                 break;
7807         default:
7808                 return (DDI_FAILURE);
7809         }
7810 
7811         if ((i_devid = kmem_zalloc(sz, KM_SLEEP)) == NULL)
7812                 return (DDI_FAILURE);
7813 
7814         i_devid->did_magic_hi = DEVID_MAGIC_MSB;
7815         i_devid->did_magic_lo = DEVID_MAGIC_LSB;
7816         i_devid->did_rev_hi = DEVID_REV_MSB;
7817         i_devid->did_rev_lo = DEVID_REV_LSB;
7818         DEVID_FORMTYPE(i_devid, devid_type);
7819         DEVID_FORMLEN(i_devid, nbytes);
7820 
7821         /* Fill in driver name hint */
7822         driver_name = ddi_driver_name(dip);
7823         driver_len = strlen(driver_name);
7824         if (driver_len > DEVID_HINT_SIZE) {
7825                 /* Pick up last four characters of driver name */
7826                 driver_name += driver_len - DEVID_HINT_SIZE;
7827                 driver_len = DEVID_HINT_SIZE;
7828         }
7829 
7830         bcopy(driver_name, i_devid->did_driver, driver_len);
7831 
7832         /* Fill in id field */
7833         if (devid_type == DEVID_FAB) {
7834                 char            *cp;
7835                 uint32_t        hostid;
7836                 struct timeval32 timestamp32;
7837                 int             i;
7838                 int             *ip;
7839                 short           gen;
7840 
7841                 /* increase the generation number */
7842                 mutex_enter(&devid_gen_mutex);
7843                 gen = devid_gen_number++;
7844                 mutex_exit(&devid_gen_mutex);
7845 
7846                 cp = i_devid->did_id;
7847 
7848                 /* Fill in host id (big-endian byte ordering) */
7849                 hostid = zone_get_hostid(NULL);
7850                 *cp++ = hibyte(hiword(hostid));
7851                 *cp++ = lobyte(hiword(hostid));
7852                 *cp++ = hibyte(loword(hostid));
7853                 *cp++ = lobyte(loword(hostid));
7854 
7855                 /*
7856                  * Fill in timestamp (big-endian byte ordering)
7857                  *
7858                  * (Note that the format may have to be changed
7859                  * before 2038 comes around, though it's arguably
7860                  * unique enough as it is..)
7861                  */
7862                 uniqtime32(&timestamp32);
7863                 ip = (int *)&timestamp32;
7864                 for (i = 0;
7865                     i < sizeof (timestamp32) / sizeof (int); i++, ip++) {
7866                         int     val;
7867                         val = *ip;
7868                         *cp++ = hibyte(hiword(val));
7869                         *cp++ = lobyte(hiword(val));
7870                         *cp++ = hibyte(loword(val));
7871                         *cp++ = lobyte(loword(val));
7872                 }
7873 
7874                 /* fill in the generation number */
7875                 *cp++ = hibyte(gen);
7876                 *cp++ = lobyte(gen);
7877         } else
7878                 bcopy(id, i_devid->did_id, nbytes);
7879 
7880         /* return device id */
7881         *ret_devid = (ddi_devid_t)i_devid;
7882         return (DDI_SUCCESS);
7883 }
7884 
7885 int
7886 ddi_devid_get(dev_info_t *dip, ddi_devid_t *ret_devid)
7887 {
7888         return (i_ddi_devi_get_devid(DDI_DEV_T_ANY, dip, ret_devid));
7889 }
7890 
7891 int
7892 i_ddi_devi_get_devid(dev_t dev, dev_info_t *dip, ddi_devid_t *ret_devid)
7893 {
7894         char            *devidstr;
7895 
7896         ASSERT(dev != DDI_DEV_T_NONE);
7897 
7898         /* look up the property, devt specific first */
7899         if (ddi_prop_lookup_string(dev, dip, DDI_PROP_DONTPASS,
7900             DEVID_PROP_NAME, &devidstr) != DDI_PROP_SUCCESS) {
7901                 if ((dev == DDI_DEV_T_ANY) ||
7902                     (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
7903                     DDI_PROP_DONTPASS, DEVID_PROP_NAME, &devidstr) !=
7904                     DDI_PROP_SUCCESS)) {
7905                         return (DDI_FAILURE);
7906                 }
7907         }
7908 
7909         /* convert to binary form */
7910         if (ddi_devid_str_decode(devidstr, ret_devid, NULL) == -1) {
7911                 ddi_prop_free(devidstr);
7912                 return (DDI_FAILURE);
7913         }
7914         ddi_prop_free(devidstr);
7915         return (DDI_SUCCESS);
7916 }
7917 
7918 /*
7919  * Return a copy of the device id for dev_t
7920  */
7921 int
7922 ddi_lyr_get_devid(dev_t dev, ddi_devid_t *ret_devid)
7923 {
7924         dev_info_t      *dip;
7925         int             rval;
7926 
7927         /* get the dip */
7928         if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
7929                 return (DDI_FAILURE);
7930 
7931         rval = i_ddi_devi_get_devid(dev, dip, ret_devid);
7932 
7933         ddi_release_devi(dip);          /* e_ddi_hold_devi_by_dev() */
7934         return (rval);
7935 }
7936 
7937 /*
7938  * Return a copy of the minor name for dev_t and spec_type
7939  */
7940 int
7941 ddi_lyr_get_minor_name(dev_t dev, int spec_type, char **minor_name)
7942 {
7943         char            *buf;
7944         int             circ;
7945         dev_info_t      *dip;
7946         char            *nm;
7947         int             rval;
7948 
7949         if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) {
7950                 *minor_name = NULL;
7951                 return (DDI_FAILURE);
7952         }
7953 
7954         /* Find the minor name and copy into max size buf */
7955         buf = kmem_alloc(MAXNAMELEN, KM_SLEEP);
7956         ndi_devi_enter(dip, &circ);
7957         nm = i_ddi_devtspectype_to_minorname(dip, dev, spec_type);
7958         if (nm)
7959                 (void) strcpy(buf, nm);
7960         ndi_devi_exit(dip, circ);
7961         ddi_release_devi(dip);  /* e_ddi_hold_devi_by_dev() */
7962 
7963         if (nm) {
7964                 /* duplicate into min size buf for return result */
7965                 *minor_name = i_ddi_strdup(buf, KM_SLEEP);
7966                 rval = DDI_SUCCESS;
7967         } else {
7968                 *minor_name = NULL;
7969                 rval = DDI_FAILURE;
7970         }
7971 
7972         /* free max size buf and return */
7973         kmem_free(buf, MAXNAMELEN);
7974         return (rval);
7975 }
7976 
7977 int
7978 ddi_lyr_devid_to_devlist(
7979         ddi_devid_t     devid,
7980         char            *minor_name,
7981         int             *retndevs,
7982         dev_t           **retdevs)
7983 {
7984         ASSERT(ddi_devid_valid(devid) == DDI_SUCCESS);
7985 
7986         if (e_devid_cache_to_devt_list(devid, minor_name,
7987             retndevs, retdevs) == DDI_SUCCESS) {
7988                 ASSERT(*retndevs > 0);
7989                 DDI_DEBUG_DEVID_DEVTS("ddi_lyr_devid_to_devlist",
7990                     *retndevs, *retdevs);
7991                 return (DDI_SUCCESS);
7992         }
7993 
7994         if (e_ddi_devid_discovery(devid) == DDI_FAILURE) {
7995                 return (DDI_FAILURE);
7996         }
7997 
7998         if (e_devid_cache_to_devt_list(devid, minor_name,
7999             retndevs, retdevs) == DDI_SUCCESS) {
8000                 ASSERT(*retndevs > 0);
8001                 DDI_DEBUG_DEVID_DEVTS("ddi_lyr_devid_to_devlist",
8002                     *retndevs, *retdevs);
8003                 return (DDI_SUCCESS);
8004         }
8005 
8006         return (DDI_FAILURE);
8007 }
8008 
8009 void
8010 ddi_lyr_free_devlist(dev_t *devlist, int ndevs)
8011 {
8012         kmem_free(devlist, sizeof (dev_t) * ndevs);
8013 }
8014 
8015 /*
8016  * Note: This will need to be fixed if we ever allow processes to
8017  * have more than one data model per exec.
8018  */
8019 model_t
8020 ddi_mmap_get_model(void)
8021 {
8022         return (get_udatamodel());
8023 }
8024 
8025 model_t
8026 ddi_model_convert_from(model_t model)
8027 {
8028         return ((model & DDI_MODEL_MASK) & ~DDI_MODEL_NATIVE);
8029 }
8030 
8031 /*
8032  * ddi interfaces managing storage and retrieval of eventcookies.
8033  */
8034 
8035 /*
8036  * Invoke bus nexus driver's implementation of the
8037  * (*bus_remove_eventcall)() interface to remove a registered
8038  * callback handler for "event".
8039  */
8040 int
8041 ddi_remove_event_handler(ddi_callback_id_t id)
8042 {
8043         ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)id;
8044         dev_info_t *ddip;
8045 
8046         ASSERT(cb);
8047         if (!cb) {
8048                 return (DDI_FAILURE);
8049         }
8050 
8051         ddip = NDI_EVENT_DDIP(cb->ndi_evtcb_cookie);
8052         return (ndi_busop_remove_eventcall(ddip, id));
8053 }
8054 
8055 /*
8056  * Invoke bus nexus driver's implementation of the
8057  * (*bus_add_eventcall)() interface to register a callback handler
8058  * for "event".
8059  */
8060 int
8061 ddi_add_event_handler(dev_info_t *dip, ddi_eventcookie_t event,
8062     void (*handler)(dev_info_t *, ddi_eventcookie_t, void *, void *),
8063     void *arg, ddi_callback_id_t *id)
8064 {
8065         return (ndi_busop_add_eventcall(dip, dip, event, handler, arg, id));
8066 }
8067 
8068 
8069 /*
8070  * Return a handle for event "name" by calling up the device tree
8071  * hierarchy via  (*bus_get_eventcookie)() interface until claimed
8072  * by a bus nexus or top of dev_info tree is reached.
8073  */
8074 int
8075 ddi_get_eventcookie(dev_info_t *dip, char *name,
8076     ddi_eventcookie_t *event_cookiep)
8077 {
8078         return (ndi_busop_get_eventcookie(dip, dip,
8079             name, event_cookiep));
8080 }
8081 
8082 /*
8083  * This procedure is provided as the general callback function when
8084  * umem_lockmemory calls as_add_callback for long term memory locking.
8085  * When as_unmap, as_setprot, or as_free encounter segments which have
8086  * locked memory, this callback will be invoked.
8087  */
8088 void
8089 umem_lock_undo(struct as *as, void *arg, uint_t event)
8090 {
8091         _NOTE(ARGUNUSED(as, event))
8092         struct ddi_umem_cookie *cp = (struct ddi_umem_cookie *)arg;
8093 
8094         /*
8095          * Call the cleanup function.  Decrement the cookie reference
8096          * count, if it goes to zero, return the memory for the cookie.
8097          * The i_ddi_umem_unlock for this cookie may or may not have been
8098          * called already.  It is the responsibility of the caller of
8099          * umem_lockmemory to handle the case of the cleanup routine
8100          * being called after a ddi_umem_unlock for the cookie
8101          * was called.
8102          */
8103 
8104         (*cp->callbacks.cbo_umem_lock_cleanup)((ddi_umem_cookie_t)cp);
8105 
8106         /* remove the cookie if reference goes to zero */
8107         if (atomic_dec_ulong_nv((ulong_t *)(&(cp->cook_refcnt))) == 0) {
8108                 kmem_free(cp, sizeof (struct ddi_umem_cookie));
8109         }
8110 }
8111 
8112 /*
8113  * The following two Consolidation Private routines provide generic
8114  * interfaces to increase/decrease the amount of device-locked memory.
8115  *
8116  * To keep project_rele and project_hold consistent, i_ddi_decr_locked_memory()
8117  * must be called every time i_ddi_incr_locked_memory() is called.
8118  */
8119 int
8120 /* ARGSUSED */
8121 i_ddi_incr_locked_memory(proc_t *procp, rctl_qty_t inc)
8122 {
8123         ASSERT(procp != NULL);
8124         mutex_enter(&procp->p_lock);
8125         if (rctl_incr_locked_mem(procp, NULL, inc, 1)) {
8126                 mutex_exit(&procp->p_lock);
8127                 return (ENOMEM);
8128         }
8129         mutex_exit(&procp->p_lock);
8130         return (0);
8131 }
8132 
8133 /*
8134  * To keep project_rele and project_hold consistent, i_ddi_incr_locked_memory()
8135  * must be called every time i_ddi_decr_locked_memory() is called.
8136  */
8137 /* ARGSUSED */
8138 void
8139 i_ddi_decr_locked_memory(proc_t *procp, rctl_qty_t dec)
8140 {
8141         ASSERT(procp != NULL);
8142         mutex_enter(&procp->p_lock);
8143         rctl_decr_locked_mem(procp, NULL, dec, 1);
8144         mutex_exit(&procp->p_lock);
8145 }
8146 
8147 /*
8148  * The cookie->upd_max_lock_rctl flag is used to determine if we should
8149  * charge device locked memory to the max-locked-memory rctl.  Tracking
8150  * device locked memory causes the rctl locks to get hot under high-speed
8151  * I/O such as RDSv3 over IB.  If there is no max-locked-memory rctl limit,
8152  * we bypass charging the locked memory to the rctl altogether.  The cookie's
8153  * flag tells us if the rctl value should be updated when unlocking the memory,
8154  * in case the rctl gets changed after the memory was locked.  Any device
8155  * locked memory in that rare case will not be counted toward the rctl limit.
8156  *
8157  * When tracking the locked memory, the kproject_t parameter is always NULL
8158  * in the code paths:
8159  *      i_ddi_incr_locked_memory -> rctl_incr_locked_mem
8160  *      i_ddi_decr_locked_memory -> rctl_decr_locked_mem
8161  * Thus, we always use the tk_proj member to check the projp setting.
8162  */
8163 static void
8164 init_lockedmem_rctl_flag(struct ddi_umem_cookie *cookie)
8165 {
8166         proc_t          *p;
8167         kproject_t      *projp;
8168         zone_t          *zonep;
8169 
8170         ASSERT(cookie);
8171         p = cookie->procp;
8172         ASSERT(p);
8173 
8174         zonep = p->p_zone;
8175         projp = p->p_task->tk_proj;
8176 
8177         ASSERT(zonep);
8178         ASSERT(projp);
8179 
8180         if (zonep->zone_locked_mem_ctl == UINT64_MAX &&
8181             projp->kpj_data.kpd_locked_mem_ctl == UINT64_MAX)
8182                 cookie->upd_max_lock_rctl = 0;
8183         else
8184                 cookie->upd_max_lock_rctl = 1;
8185 }
8186 
8187 /*
8188  * This routine checks if the max-locked-memory resource ctl is
8189  * exceeded, if not increments it, grabs a hold on the project.
8190  * Returns 0 if successful otherwise returns error code
8191  */
8192 static int
8193 umem_incr_devlockmem(struct ddi_umem_cookie *cookie)
8194 {
8195         proc_t          *procp;
8196         int             ret;
8197 
8198         ASSERT(cookie);
8199         if (cookie->upd_max_lock_rctl == 0)
8200                 return (0);
8201 
8202         procp = cookie->procp;
8203         ASSERT(procp);
8204 
8205         if ((ret = i_ddi_incr_locked_memory(procp,
8206             cookie->size)) != 0) {
8207                 return (ret);
8208         }
8209         return (0);
8210 }
8211 
8212 /*
8213  * Decrements the max-locked-memory resource ctl and releases
8214  * the hold on the project that was acquired during umem_incr_devlockmem
8215  */
8216 static void
8217 umem_decr_devlockmem(struct ddi_umem_cookie *cookie)
8218 {
8219         proc_t          *proc;
8220 
8221         if (cookie->upd_max_lock_rctl == 0)
8222                 return;
8223 
8224         proc = (proc_t *)cookie->procp;
8225         if (!proc)
8226                 return;
8227 
8228         i_ddi_decr_locked_memory(proc, cookie->size);
8229 }
8230 
8231 /*
8232  * A consolidation private function which is essentially equivalent to
8233  * ddi_umem_lock but with the addition of arguments ops_vector and procp.
8234  * A call to as_add_callback is done if DDI_UMEMLOCK_LONGTERM is set, and
8235  * the ops_vector is valid.
8236  *
8237  * Lock the virtual address range in the current process and create a
8238  * ddi_umem_cookie (of type UMEM_LOCKED). This can be used to pass to
8239  * ddi_umem_iosetup to create a buf or do devmap_umem_setup/remap to export
8240  * to user space.
8241  *
8242  * Note: The resource control accounting currently uses a full charge model
8243  * in other words attempts to lock the same/overlapping areas of memory
8244  * will deduct the full size of the buffer from the projects running
8245  * counter for the device locked memory.
8246  *
8247  * addr, size should be PAGESIZE aligned
8248  *
8249  * flags - DDI_UMEMLOCK_READ, DDI_UMEMLOCK_WRITE or both
8250  *      identifies whether the locked memory will be read or written or both
8251  *      DDI_UMEMLOCK_LONGTERM  must be set when the locking will
8252  * be maintained for an indefinitely long period (essentially permanent),
8253  * rather than for what would be required for a typical I/O completion.
8254  * When DDI_UMEMLOCK_LONGTERM is set, umem_lockmemory will return EFAULT
8255  * if the memory pertains to a regular file which is mapped MAP_SHARED.
8256  * This is to prevent a deadlock if a file truncation is attempted after
8257  * after the locking is done.
8258  *
8259  * Returns 0 on success
8260  *      EINVAL - for invalid parameters
8261  *      EPERM, ENOMEM and other error codes returned by as_pagelock
8262  *      ENOMEM - is returned if the current request to lock memory exceeds
8263  *              *.max-locked-memory resource control value.
8264  *      EFAULT - memory pertains to a regular file mapped shared and
8265  *              and DDI_UMEMLOCK_LONGTERM flag is set
8266  *      EAGAIN - could not start the ddi_umem_unlock list processing thread
8267  */
8268 int
8269 umem_lockmemory(caddr_t addr, size_t len, int flags, ddi_umem_cookie_t *cookie,
8270                 struct umem_callback_ops *ops_vector,
8271                 proc_t *procp)
8272 {
8273         int     error;
8274         struct ddi_umem_cookie *p;
8275         void    (*driver_callback)() = NULL;
8276         struct as *as;
8277         struct seg              *seg;
8278         vnode_t                 *vp;
8279 
8280         /* Allow device drivers to not have to reference "curproc" */
8281         if (procp == NULL)
8282                 procp = curproc;
8283         as = procp->p_as;
8284         *cookie = NULL;         /* in case of any error return */
8285 
8286         /* These are the only three valid flags */
8287         if ((flags & ~(DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE |
8288             DDI_UMEMLOCK_LONGTERM)) != 0)
8289                 return (EINVAL);
8290 
8291         /* At least one (can be both) of the two access flags must be set */
8292         if ((flags & (DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE)) == 0)
8293                 return (EINVAL);
8294 
8295         /* addr and len must be page-aligned */
8296         if (((uintptr_t)addr & PAGEOFFSET) != 0)
8297                 return (EINVAL);
8298 
8299         if ((len & PAGEOFFSET) != 0)
8300                 return (EINVAL);
8301 
8302         /*
8303          * For longterm locking a driver callback must be specified; if
8304          * not longterm then a callback is optional.
8305          */
8306         if (ops_vector != NULL) {
8307                 if (ops_vector->cbo_umem_callback_version !=
8308                     UMEM_CALLBACK_VERSION)
8309                         return (EINVAL);
8310                 else
8311                         driver_callback = ops_vector->cbo_umem_lock_cleanup;
8312         }
8313         if ((driver_callback == NULL) && (flags & DDI_UMEMLOCK_LONGTERM))
8314                 return (EINVAL);
8315 
8316         /*
8317          * Call i_ddi_umem_unlock_thread_start if necessary.  It will
8318          * be called on first ddi_umem_lock or umem_lockmemory call.
8319          */
8320         if (ddi_umem_unlock_thread == NULL)
8321                 i_ddi_umem_unlock_thread_start();
8322 
8323         /* Allocate memory for the cookie */
8324         p = kmem_zalloc(sizeof (struct ddi_umem_cookie), KM_SLEEP);
8325 
8326         /* Convert the flags to seg_rw type */
8327         if (flags & DDI_UMEMLOCK_WRITE) {
8328                 p->s_flags = S_WRITE;
8329         } else {
8330                 p->s_flags = S_READ;
8331         }
8332 
8333         /* Store procp in cookie for later iosetup/unlock */
8334         p->procp = (void *)procp;
8335 
8336         /*
8337          * Store the struct as pointer in cookie for later use by
8338          * ddi_umem_unlock.  The proc->p_as will be stale if ddi_umem_unlock
8339          * is called after relvm is called.
8340          */
8341         p->asp = as;
8342 
8343         /*
8344          * The size field is needed for lockmem accounting.
8345          */
8346         p->size = len;
8347         init_lockedmem_rctl_flag(p);
8348 
8349         if (umem_incr_devlockmem(p) != 0) {
8350                 /*
8351                  * The requested memory cannot be locked
8352                  */
8353                 kmem_free(p, sizeof (struct ddi_umem_cookie));
8354                 *cookie = (ddi_umem_cookie_t)NULL;
8355                 return (ENOMEM);
8356         }
8357 
8358         /* Lock the pages corresponding to addr, len in memory */
8359         error = as_pagelock(as, &(p->pparray), addr, len, p->s_flags);
8360         if (error != 0) {
8361                 umem_decr_devlockmem(p);
8362                 kmem_free(p, sizeof (struct ddi_umem_cookie));
8363                 *cookie = (ddi_umem_cookie_t)NULL;
8364                 return (error);
8365         }
8366 
8367         /*
8368          * For longterm locking the addr must pertain to a seg_vn segment or
8369          * or a seg_spt segment.
8370          * If the segment pertains to a regular file, it cannot be
8371          * mapped MAP_SHARED.
8372          * This is to prevent a deadlock if a file truncation is attempted
8373          * after the locking is done.
8374          * Doing this after as_pagelock guarantees persistence of the as; if
8375          * an unacceptable segment is found, the cleanup includes calling
8376          * as_pageunlock before returning EFAULT.
8377          *
8378          * segdev is allowed here as it is already locked.  This allows
8379          * for memory exported by drivers through mmap() (which is already
8380          * locked) to be allowed for LONGTERM.
8381          */
8382         if (flags & DDI_UMEMLOCK_LONGTERM) {
8383                 extern  struct seg_ops segspt_shmops;
8384                 extern  struct seg_ops segdev_ops;
8385                 AS_LOCK_ENTER(as, RW_READER);
8386                 for (seg = as_segat(as, addr); ; seg = AS_SEGNEXT(as, seg)) {
8387                         if (seg == NULL || seg->s_base > addr + len)
8388                                 break;
8389                         if (seg->s_ops == &segdev_ops)
8390                                 continue;
8391                         if (((seg->s_ops != &segvn_ops) &&
8392                             (seg->s_ops != &segspt_shmops)) ||
8393                             ((SEGOP_GETVP(seg, addr, &vp) == 0 &&
8394                             vp != NULL && vp->v_type == VREG) &&
8395                             (SEGOP_GETTYPE(seg, addr) & MAP_SHARED))) {
8396                                 as_pageunlock(as, p->pparray,
8397                                     addr, len, p->s_flags);
8398                                 AS_LOCK_EXIT(as);
8399                                 umem_decr_devlockmem(p);
8400                                 kmem_free(p, sizeof (struct ddi_umem_cookie));
8401                                 *cookie = (ddi_umem_cookie_t)NULL;
8402                                 return (EFAULT);
8403                         }
8404                 }
8405                 AS_LOCK_EXIT(as);
8406         }
8407 
8408 
8409         /* Initialize the fields in the ddi_umem_cookie */
8410         p->cvaddr = addr;
8411         p->type = UMEM_LOCKED;
8412         if (driver_callback != NULL) {
8413                 /* i_ddi_umem_unlock and umem_lock_undo may need the cookie */
8414                 p->cook_refcnt = 2;
8415                 p->callbacks = *ops_vector;
8416         } else {
8417                 /* only i_ddi_umme_unlock needs the cookie */
8418                 p->cook_refcnt = 1;
8419         }
8420 
8421         *cookie = (ddi_umem_cookie_t)p;
8422 
8423         /*
8424          * If a driver callback was specified, add an entry to the
8425          * as struct callback list. The as_pagelock above guarantees
8426          * the persistence of as.
8427          */
8428         if (driver_callback) {
8429                 error = as_add_callback(as, umem_lock_undo, p, AS_ALL_EVENT,
8430                     addr, len, KM_SLEEP);
8431                 if (error != 0) {
8432                         as_pageunlock(as, p->pparray,
8433                             addr, len, p->s_flags);
8434                         umem_decr_devlockmem(p);
8435                         kmem_free(p, sizeof (struct ddi_umem_cookie));
8436                         *cookie = (ddi_umem_cookie_t)NULL;
8437                 }
8438         }
8439         return (error);
8440 }
8441 
8442 /*
8443  * Unlock the pages locked by ddi_umem_lock or umem_lockmemory and free
8444  * the cookie.  Called from i_ddi_umem_unlock_thread.
8445  */
8446 
8447 static void
8448 i_ddi_umem_unlock(struct ddi_umem_cookie *p)
8449 {
8450         uint_t  rc;
8451 
8452         /*
8453          * There is no way to determine whether a callback to
8454          * umem_lock_undo was registered via as_add_callback.
8455          * (i.e. umem_lockmemory was called with DDI_MEMLOCK_LONGTERM and
8456          * a valid callback function structure.)  as_delete_callback
8457          * is called to delete a possible registered callback.  If the
8458          * return from as_delete_callbacks is AS_CALLBACK_DELETED, it
8459          * indicates that there was a callback registered, and that is was
8460          * successfully deleted.  Thus, the cookie reference count
8461          * will never be decremented by umem_lock_undo.  Just return the
8462          * memory for the cookie, since both users of the cookie are done.
8463          * A return of AS_CALLBACK_NOTFOUND indicates a callback was
8464          * never registered.  A return of AS_CALLBACK_DELETE_DEFERRED
8465          * indicates that callback processing is taking place and, and
8466          * umem_lock_undo is, or will be, executing, and thus decrementing
8467          * the cookie reference count when it is complete.
8468          *
8469          * This needs to be done before as_pageunlock so that the
8470          * persistence of as is guaranteed because of the locked pages.
8471          *
8472          */
8473         rc = as_delete_callback(p->asp, p);
8474 
8475 
8476         /*
8477          * The proc->p_as will be stale if i_ddi_umem_unlock is called
8478          * after relvm is called so use p->asp.
8479          */
8480         as_pageunlock(p->asp, p->pparray, p->cvaddr, p->size, p->s_flags);
8481 
8482         /*
8483          * Now that we have unlocked the memory decrement the
8484          * *.max-locked-memory rctl
8485          */
8486         umem_decr_devlockmem(p);
8487 
8488         if (rc == AS_CALLBACK_DELETED) {
8489                 /* umem_lock_undo will not happen, return the cookie memory */
8490                 ASSERT(p->cook_refcnt == 2);
8491                 kmem_free(p, sizeof (struct ddi_umem_cookie));
8492         } else {
8493                 /*
8494                  * umem_undo_lock may happen if as_delete_callback returned
8495                  * AS_CALLBACK_DELETE_DEFERRED.  In that case, decrement the
8496                  * reference count, atomically, and return the cookie
8497                  * memory if the reference count goes to zero.  The only
8498                  * other value for rc is AS_CALLBACK_NOTFOUND.  In that
8499                  * case, just return the cookie memory.
8500                  */
8501                 if ((rc != AS_CALLBACK_DELETE_DEFERRED) ||
8502                     (atomic_dec_ulong_nv((ulong_t *)(&(p->cook_refcnt)))
8503                     == 0)) {
8504                         kmem_free(p, sizeof (struct ddi_umem_cookie));
8505                 }
8506         }
8507 }
8508 
8509 /*
8510  * i_ddi_umem_unlock_thread - deferred ddi_umem_unlock list handler.
8511  *
8512  * Call i_ddi_umem_unlock for entries in the ddi_umem_unlock list
8513  * until it is empty.  Then, wait for more to be added.  This thread is awoken
8514  * via calls to ddi_umem_unlock.
8515  */
8516 
8517 static void
8518 i_ddi_umem_unlock_thread(void)
8519 {
8520         struct ddi_umem_cookie  *ret_cookie;
8521         callb_cpr_t     cprinfo;
8522 
8523         /* process the ddi_umem_unlock list */
8524         CALLB_CPR_INIT(&cprinfo, &ddi_umem_unlock_mutex,
8525             callb_generic_cpr, "unlock_thread");
8526         for (;;) {
8527                 mutex_enter(&ddi_umem_unlock_mutex);
8528                 if (ddi_umem_unlock_head != NULL) {     /* list not empty */
8529                         ret_cookie = ddi_umem_unlock_head;
8530                         /* take if off the list */
8531                         if ((ddi_umem_unlock_head =
8532                             ddi_umem_unlock_head->unl_forw) == NULL) {
8533                                 ddi_umem_unlock_tail = NULL;
8534                         }
8535                         mutex_exit(&ddi_umem_unlock_mutex);
8536                         /* unlock the pages in this cookie */
8537                         (void) i_ddi_umem_unlock(ret_cookie);
8538                 } else {   /* list is empty, wait for next ddi_umem_unlock */
8539                         CALLB_CPR_SAFE_BEGIN(&cprinfo);
8540                         cv_wait(&ddi_umem_unlock_cv, &ddi_umem_unlock_mutex);
8541                         CALLB_CPR_SAFE_END(&cprinfo, &ddi_umem_unlock_mutex);
8542                         mutex_exit(&ddi_umem_unlock_mutex);
8543                 }
8544         }
8545         /* ddi_umem_unlock_thread does not exit */
8546         /* NOTREACHED */
8547 }
8548 
8549 /*
8550  * Start the thread that will process the ddi_umem_unlock list if it is
8551  * not already started (i_ddi_umem_unlock_thread).
8552  */
8553 static void
8554 i_ddi_umem_unlock_thread_start(void)
8555 {
8556         mutex_enter(&ddi_umem_unlock_mutex);
8557         if (ddi_umem_unlock_thread == NULL) {
8558                 ddi_umem_unlock_thread = thread_create(NULL, 0,
8559                     i_ddi_umem_unlock_thread, NULL, 0, &p0,
8560                     TS_RUN, minclsyspri);
8561         }
8562         mutex_exit(&ddi_umem_unlock_mutex);
8563 }
8564 
8565 /*
8566  * Lock the virtual address range in the current process and create a
8567  * ddi_umem_cookie (of type UMEM_LOCKED). This can be used to pass to
8568  * ddi_umem_iosetup to create a buf or do devmap_umem_setup/remap to export
8569  * to user space.
8570  *
8571  * Note: The resource control accounting currently uses a full charge model
8572  * in other words attempts to lock the same/overlapping areas of memory
8573  * will deduct the full size of the buffer from the projects running
8574  * counter for the device locked memory. This applies to umem_lockmemory too.
8575  *
8576  * addr, size should be PAGESIZE aligned
8577  * flags - DDI_UMEMLOCK_READ, DDI_UMEMLOCK_WRITE or both
8578  *      identifies whether the locked memory will be read or written or both
8579  *
8580  * Returns 0 on success
8581  *      EINVAL - for invalid parameters
8582  *      EPERM, ENOMEM and other error codes returned by as_pagelock
8583  *      ENOMEM - is returned if the current request to lock memory exceeds
8584  *              *.max-locked-memory resource control value.
8585  *      EAGAIN - could not start the ddi_umem_unlock list processing thread
8586  */
8587 int
8588 ddi_umem_lock(caddr_t addr, size_t len, int flags, ddi_umem_cookie_t *cookie)
8589 {
8590         int     error;
8591         struct ddi_umem_cookie *p;
8592 
8593         *cookie = NULL;         /* in case of any error return */
8594 
8595         /* These are the only two valid flags */
8596         if ((flags & ~(DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE)) != 0) {
8597                 return (EINVAL);
8598         }
8599 
8600         /* At least one of the two flags (or both) must be set */
8601         if ((flags & (DDI_UMEMLOCK_READ | DDI_UMEMLOCK_WRITE)) == 0) {
8602                 return (EINVAL);
8603         }
8604 
8605         /* addr and len must be page-aligned */
8606         if (((uintptr_t)addr & PAGEOFFSET) != 0) {
8607                 return (EINVAL);
8608         }
8609 
8610         if ((len & PAGEOFFSET) != 0) {
8611                 return (EINVAL);
8612         }
8613 
8614         /*
8615          * Call i_ddi_umem_unlock_thread_start if necessary.  It will
8616          * be called on first ddi_umem_lock or umem_lockmemory call.
8617          */
8618         if (ddi_umem_unlock_thread == NULL)
8619                 i_ddi_umem_unlock_thread_start();
8620 
8621         /* Allocate memory for the cookie */
8622         p = kmem_zalloc(sizeof (struct ddi_umem_cookie), KM_SLEEP);
8623 
8624         /* Convert the flags to seg_rw type */
8625         if (flags & DDI_UMEMLOCK_WRITE) {
8626                 p->s_flags = S_WRITE;
8627         } else {
8628                 p->s_flags = S_READ;
8629         }
8630 
8631         /* Store curproc in cookie for later iosetup/unlock */
8632         p->procp = (void *)curproc;
8633 
8634         /*
8635          * Store the struct as pointer in cookie for later use by
8636          * ddi_umem_unlock.  The proc->p_as will be stale if ddi_umem_unlock
8637          * is called after relvm is called.
8638          */
8639         p->asp = curproc->p_as;
8640         /*
8641          * The size field is needed for lockmem accounting.
8642          */
8643         p->size = len;
8644         init_lockedmem_rctl_flag(p);
8645 
8646         if (umem_incr_devlockmem(p) != 0) {
8647                 /*
8648                  * The requested memory cannot be locked
8649                  */
8650                 kmem_free(p, sizeof (struct ddi_umem_cookie));
8651                 *cookie = (ddi_umem_cookie_t)NULL;
8652                 return (ENOMEM);
8653         }
8654 
8655         /* Lock the pages corresponding to addr, len in memory */
8656         error = as_pagelock(((proc_t *)p->procp)->p_as, &(p->pparray),
8657             addr, len, p->s_flags);
8658         if (error != 0) {
8659                 umem_decr_devlockmem(p);
8660                 kmem_free(p, sizeof (struct ddi_umem_cookie));
8661                 *cookie = (ddi_umem_cookie_t)NULL;
8662                 return (error);
8663         }
8664 
8665         /* Initialize the fields in the ddi_umem_cookie */
8666         p->cvaddr = addr;
8667         p->type = UMEM_LOCKED;
8668         p->cook_refcnt = 1;
8669 
8670         *cookie = (ddi_umem_cookie_t)p;
8671         return (error);
8672 }
8673 
8674 /*
8675  * Add the cookie to the ddi_umem_unlock list.  Pages will be
8676  * unlocked by i_ddi_umem_unlock_thread.
8677  */
8678 
8679 void
8680 ddi_umem_unlock(ddi_umem_cookie_t cookie)
8681 {
8682         struct ddi_umem_cookie  *p = (struct ddi_umem_cookie *)cookie;
8683 
8684         ASSERT(p->type == UMEM_LOCKED);
8685         ASSERT(CPU_ON_INTR(CPU) == 0); /* cannot be high level */
8686         ASSERT(ddi_umem_unlock_thread != NULL);
8687 
8688         p->unl_forw = (struct ddi_umem_cookie *)NULL;        /* end of list */
8689         /*
8690          * Queue the unlock request and notify i_ddi_umem_unlock thread
8691          * if it's called in the interrupt context. Otherwise, unlock pages
8692          * immediately.
8693          */
8694         if (servicing_interrupt()) {
8695                 /* queue the unlock request and notify the thread */
8696                 mutex_enter(&ddi_umem_unlock_mutex);
8697                 if (ddi_umem_unlock_head == NULL) {
8698                         ddi_umem_unlock_head = ddi_umem_unlock_tail = p;
8699                         cv_broadcast(&ddi_umem_unlock_cv);
8700                 } else {
8701                         ddi_umem_unlock_tail->unl_forw = p;
8702                         ddi_umem_unlock_tail = p;
8703                 }
8704                 mutex_exit(&ddi_umem_unlock_mutex);
8705         } else {
8706                 /* unlock the pages right away */
8707                 (void) i_ddi_umem_unlock(p);
8708         }
8709 }
8710 
8711 /*
8712  * Create a buf structure from a ddi_umem_cookie
8713  * cookie - is a ddi_umem_cookie for from ddi_umem_lock and ddi_umem_alloc
8714  *              (only UMEM_LOCKED & KMEM_NON_PAGEABLE types supported)
8715  * off, len - identifies the portion of the memory represented by the cookie
8716  *              that the buf points to.
8717  *      NOTE: off, len need to follow the alignment/size restrictions of the
8718  *              device (dev) that this buf will be passed to. Some devices
8719  *              will accept unrestricted alignment/size, whereas others (such as
8720  *              st) require some block-size alignment/size. It is the caller's
8721  *              responsibility to ensure that the alignment/size restrictions
8722  *              are met (we cannot assert as we do not know the restrictions)
8723  *
8724  * direction - is one of B_READ or B_WRITE and needs to be compatible with
8725  *              the flags used in ddi_umem_lock
8726  *
8727  * The following three arguments are used to initialize fields in the
8728  * buf structure and are uninterpreted by this routine.
8729  *
8730  * dev
8731  * blkno
8732  * iodone
8733  *
8734  * sleepflag - is one of DDI_UMEM_SLEEP or DDI_UMEM_NOSLEEP
8735  *
8736  * Returns a buf structure pointer on success (to be freed by freerbuf)
8737  *      NULL on any parameter error or memory alloc failure
8738  *
8739  */
8740 struct buf *
8741 ddi_umem_iosetup(ddi_umem_cookie_t cookie, off_t off, size_t len,
8742         int direction, dev_t dev, daddr_t blkno,
8743         int (*iodone)(struct buf *), int sleepflag)
8744 {
8745         struct ddi_umem_cookie *p = (struct ddi_umem_cookie *)cookie;
8746         struct buf *bp;
8747 
8748         /*
8749          * check for valid cookie offset, len
8750          */
8751         if ((off + len) > p->size) {
8752                 return (NULL);
8753         }
8754 
8755         if (len > p->size) {
8756                 return (NULL);
8757         }
8758 
8759         /* direction has to be one of B_READ or B_WRITE */
8760         if ((direction != B_READ) && (direction != B_WRITE)) {
8761                 return (NULL);
8762         }
8763 
8764         /* These are the only two valid sleepflags */
8765         if ((sleepflag != DDI_UMEM_SLEEP) && (sleepflag != DDI_UMEM_NOSLEEP)) {
8766                 return (NULL);
8767         }
8768 
8769         /*
8770          * Only cookies of type UMEM_LOCKED and KMEM_NON_PAGEABLE are supported
8771          */
8772         if ((p->type != UMEM_LOCKED) && (p->type != KMEM_NON_PAGEABLE)) {
8773                 return (NULL);
8774         }
8775 
8776         /* If type is KMEM_NON_PAGEABLE procp is NULL */
8777         ASSERT((p->type == KMEM_NON_PAGEABLE) ?
8778             (p->procp == NULL) : (p->procp != NULL));
8779 
8780         bp = kmem_alloc(sizeof (struct buf), sleepflag);
8781         if (bp == NULL) {
8782                 return (NULL);
8783         }
8784         bioinit(bp);
8785 
8786         bp->b_flags = B_BUSY | B_PHYS | direction;
8787         bp->b_edev = dev;
8788         bp->b_lblkno = blkno;
8789         bp->b_iodone = iodone;
8790         bp->b_bcount = len;
8791         bp->b_proc = (proc_t *)p->procp;
8792         ASSERT(((uintptr_t)(p->cvaddr) & PAGEOFFSET) == 0);
8793         bp->b_un.b_addr = (caddr_t)((uintptr_t)(p->cvaddr) + off);
8794         if (p->pparray != NULL) {
8795                 bp->b_flags |= B_SHADOW;
8796                 ASSERT(((uintptr_t)(p->cvaddr) & PAGEOFFSET) == 0);
8797                 bp->b_shadow = p->pparray + btop(off);
8798         }
8799         return (bp);
8800 }
8801 
8802 /*
8803  * Fault-handling and related routines
8804  */
8805 
8806 ddi_devstate_t
8807 ddi_get_devstate(dev_info_t *dip)
8808 {
8809         if (DEVI_IS_DEVICE_OFFLINE(dip))
8810                 return (DDI_DEVSTATE_OFFLINE);
8811         else if (DEVI_IS_DEVICE_DOWN(dip) || DEVI_IS_BUS_DOWN(dip))
8812                 return (DDI_DEVSTATE_DOWN);
8813         else if (DEVI_IS_BUS_QUIESCED(dip))
8814                 return (DDI_DEVSTATE_QUIESCED);
8815         else if (DEVI_IS_DEVICE_DEGRADED(dip))
8816                 return (DDI_DEVSTATE_DEGRADED);
8817         else
8818                 return (DDI_DEVSTATE_UP);
8819 }
8820 
8821 void
8822 ddi_dev_report_fault(dev_info_t *dip, ddi_fault_impact_t impact,
8823         ddi_fault_location_t location, const char *message)
8824 {
8825         struct ddi_fault_event_data fd;
8826         ddi_eventcookie_t ec;
8827 
8828         /*
8829          * Assemble all the information into a fault-event-data structure
8830          */
8831         fd.f_dip = dip;
8832         fd.f_impact = impact;
8833         fd.f_location = location;
8834         fd.f_message = message;
8835         fd.f_oldstate = ddi_get_devstate(dip);
8836 
8837         /*
8838          * Get eventcookie from defining parent.
8839          */
8840         if (ddi_get_eventcookie(dip, DDI_DEVI_FAULT_EVENT, &ec) !=
8841             DDI_SUCCESS)
8842                 return;
8843 
8844         (void) ndi_post_event(dip, dip, ec, &fd);
8845 }
8846 
8847 char *
8848 i_ddi_devi_class(dev_info_t *dip)
8849 {
8850         return (DEVI(dip)->devi_device_class);
8851 }
8852 
8853 int
8854 i_ddi_set_devi_class(dev_info_t *dip, char *devi_class, int flag)
8855 {
8856         struct dev_info *devi = DEVI(dip);
8857 
8858         mutex_enter(&devi->devi_lock);
8859 
8860         if (devi->devi_device_class)
8861                 kmem_free(devi->devi_device_class,
8862                     strlen(devi->devi_device_class) + 1);
8863 
8864         if ((devi->devi_device_class = i_ddi_strdup(devi_class, flag))
8865             != NULL) {
8866                 mutex_exit(&devi->devi_lock);
8867                 return (DDI_SUCCESS);
8868         }
8869 
8870         mutex_exit(&devi->devi_lock);
8871 
8872         return (DDI_FAILURE);
8873 }
8874 
8875 
8876 /*
8877  * Task Queues DDI interfaces.
8878  */
8879 
8880 /* ARGSUSED */
8881 ddi_taskq_t *
8882 ddi_taskq_create(dev_info_t *dip, const char *name, int nthreads,
8883     pri_t pri, uint_t cflags)
8884 {
8885         char full_name[TASKQ_NAMELEN];
8886         const char *tq_name;
8887         int nodeid = 0;
8888 
8889         if (dip == NULL)
8890                 tq_name = name;
8891         else {
8892                 nodeid = ddi_get_instance(dip);
8893 
8894                 if (name == NULL)
8895                         name = "tq";
8896 
8897                 (void) snprintf(full_name, sizeof (full_name), "%s_%s",
8898                     ddi_driver_name(dip), name);
8899 
8900                 tq_name = full_name;
8901         }
8902 
8903         return ((ddi_taskq_t *)taskq_create_instance(tq_name, nodeid, nthreads,
8904             pri == TASKQ_DEFAULTPRI ? minclsyspri : pri,
8905             nthreads, INT_MAX, TASKQ_PREPOPULATE));
8906 }
8907 
8908 void
8909 ddi_taskq_destroy(ddi_taskq_t *tq)
8910 {
8911         taskq_destroy((taskq_t *)tq);
8912 }
8913 
8914 int
8915 ddi_taskq_dispatch(ddi_taskq_t *tq, void (* func)(void *),
8916     void *arg, uint_t dflags)
8917 {
8918         taskqid_t id = taskq_dispatch((taskq_t *)tq, func, arg,
8919             dflags == DDI_SLEEP ? TQ_SLEEP : TQ_NOSLEEP);
8920 
8921         return (id != 0 ? DDI_SUCCESS : DDI_FAILURE);
8922 }
8923 
8924 void
8925 ddi_taskq_wait(ddi_taskq_t *tq)
8926 {
8927         taskq_wait((taskq_t *)tq);
8928 }
8929 
8930 void
8931 ddi_taskq_suspend(ddi_taskq_t *tq)
8932 {
8933         taskq_suspend((taskq_t *)tq);
8934 }
8935 
8936 boolean_t
8937 ddi_taskq_suspended(ddi_taskq_t *tq)
8938 {
8939         return (taskq_suspended((taskq_t *)tq));
8940 }
8941 
8942 void
8943 ddi_taskq_resume(ddi_taskq_t *tq)
8944 {
8945         taskq_resume((taskq_t *)tq);
8946 }
8947 
8948 int
8949 ddi_parse(
8950         const char      *ifname,
8951         char            *alnum,
8952         uint_t          *nump)
8953 {
8954         const char      *p;
8955         int             l;
8956         ulong_t         num;
8957         boolean_t       nonum = B_TRUE;
8958         char            c;
8959 
8960         l = strlen(ifname);
8961         for (p = ifname + l; p != ifname; l--) {
8962                 c = *--p;
8963                 if (!isdigit(c)) {
8964                         (void) strlcpy(alnum, ifname, l + 1);
8965                         if (ddi_strtoul(p + 1, NULL, 10, &num) != 0)
8966                                 return (DDI_FAILURE);
8967                         break;
8968                 }
8969                 nonum = B_FALSE;
8970         }
8971         if (l == 0 || nonum)
8972                 return (DDI_FAILURE);
8973 
8974         *nump = num;
8975         return (DDI_SUCCESS);
8976 }
8977 
8978 /*
8979  * Default initialization function for drivers that don't need to quiesce.
8980  */
8981 /* ARGSUSED */
8982 int
8983 ddi_quiesce_not_needed(dev_info_t *dip)
8984 {
8985         return (DDI_SUCCESS);
8986 }
8987 
8988 /*
8989  * Initialization function for drivers that should implement quiesce()
8990  * but haven't yet.
8991  */
8992 /* ARGSUSED */
8993 int
8994 ddi_quiesce_not_supported(dev_info_t *dip)
8995 {
8996         return (DDI_FAILURE);
8997 }
8998 
8999 char *
9000 ddi_strdup(const char *str, int flag)
9001 {
9002         int     n;
9003         char    *ptr;
9004 
9005         ASSERT(str != NULL);
9006         ASSERT((flag == KM_SLEEP) || (flag == KM_NOSLEEP));
9007 
9008         n = strlen(str);
9009         if ((ptr = kmem_alloc(n + 1, flag)) == NULL)
9010                 return (NULL);
9011         bcopy(str, ptr, n + 1);
9012         return (ptr);
9013 }
9014 
9015 char *
9016 strdup(const char *str)
9017 {
9018         return (ddi_strdup(str, KM_SLEEP));
9019 }
9020 
9021 void
9022 strfree(char *str)
9023 {
9024         ASSERT(str != NULL);
9025         kmem_free(str, strlen(str) + 1);
9026 }
9027 
9028 /*
9029  * Generic DDI callback interfaces.
9030  */
9031 
9032 int
9033 ddi_cb_register(dev_info_t *dip, ddi_cb_flags_t flags, ddi_cb_func_t cbfunc,
9034     void *arg1, void *arg2, ddi_cb_handle_t *ret_hdlp)
9035 {
9036         ddi_cb_t        *cbp;
9037 
9038         ASSERT(dip != NULL);
9039         ASSERT(DDI_CB_FLAG_VALID(flags));
9040         ASSERT(cbfunc != NULL);
9041         ASSERT(ret_hdlp != NULL);
9042 
9043         /* Sanity check the context */
9044         ASSERT(!servicing_interrupt());
9045         if (servicing_interrupt())
9046                 return (DDI_FAILURE);
9047 
9048         /* Validate parameters */
9049         if ((dip == NULL) || !DDI_CB_FLAG_VALID(flags) ||
9050             (cbfunc == NULL) || (ret_hdlp == NULL))
9051                 return (DDI_EINVAL);
9052 
9053         /* Check for previous registration */
9054         if (DEVI(dip)->devi_cb_p != NULL)
9055                 return (DDI_EALREADY);
9056 
9057         /* Allocate and initialize callback */
9058         cbp = kmem_zalloc(sizeof (ddi_cb_t), KM_SLEEP);
9059         cbp->cb_dip = dip;
9060         cbp->cb_func = cbfunc;
9061         cbp->cb_arg1 = arg1;
9062         cbp->cb_arg2 = arg2;
9063         cbp->cb_flags = flags;
9064         DEVI(dip)->devi_cb_p = cbp;
9065 
9066         /* If adding an IRM callback, notify IRM */
9067         if (flags & DDI_CB_FLAG_INTR)
9068                 i_ddi_irm_set_cb(dip, B_TRUE);
9069 
9070         *ret_hdlp = (ddi_cb_handle_t)&(DEVI(dip)->devi_cb_p);
9071         return (DDI_SUCCESS);
9072 }
9073 
9074 int
9075 ddi_cb_unregister(ddi_cb_handle_t hdl)
9076 {
9077         ddi_cb_t        *cbp;
9078         dev_info_t      *dip;
9079 
9080         ASSERT(hdl != NULL);
9081 
9082         /* Sanity check the context */
9083         ASSERT(!servicing_interrupt());
9084         if (servicing_interrupt())
9085                 return (DDI_FAILURE);
9086 
9087         /* Validate parameters */
9088         if ((hdl == NULL) || ((cbp = *(ddi_cb_t **)hdl) == NULL) ||
9089             ((dip = cbp->cb_dip) == NULL))
9090                 return (DDI_EINVAL);
9091 
9092         /* If removing an IRM callback, notify IRM */
9093         if (cbp->cb_flags & DDI_CB_FLAG_INTR)
9094                 i_ddi_irm_set_cb(dip, B_FALSE);
9095 
9096         /* Destroy the callback */
9097         kmem_free(cbp, sizeof (ddi_cb_t));
9098         DEVI(dip)->devi_cb_p = NULL;
9099 
9100         return (DDI_SUCCESS);
9101 }
9102 
9103 /*
9104  * Platform independent DR routines
9105  */
9106 
9107 static int
9108 ndi2errno(int n)
9109 {
9110         int err = 0;
9111 
9112         switch (n) {
9113                 case NDI_NOMEM:
9114                         err = ENOMEM;
9115                         break;
9116                 case NDI_BUSY:
9117                         err = EBUSY;
9118                         break;
9119                 case NDI_FAULT:
9120                         err = EFAULT;
9121                         break;
9122                 case NDI_FAILURE:
9123                         err = EIO;
9124                         break;
9125                 case NDI_SUCCESS:
9126                         break;
9127                 case NDI_BADHANDLE:
9128                 default:
9129                         err = EINVAL;
9130                         break;
9131         }
9132         return (err);
9133 }
9134 
9135 /*
9136  * Prom tree node list
9137  */
9138 struct ptnode {
9139         pnode_t         nodeid;
9140         struct ptnode   *next;
9141 };
9142 
9143 /*
9144  * Prom tree walk arg
9145  */
9146 struct pta {
9147         dev_info_t      *pdip;
9148         devi_branch_t   *bp;
9149         uint_t          flags;
9150         dev_info_t      *fdip;
9151         struct ptnode   *head;
9152 };
9153 
9154 static void
9155 visit_node(pnode_t nodeid, struct pta *ap)
9156 {
9157         struct ptnode   **nextp;
9158         int             (*select)(pnode_t, void *, uint_t);
9159 
9160         ASSERT(nodeid != OBP_NONODE && nodeid != OBP_BADNODE);
9161 
9162         select = ap->bp->create.prom_branch_select;
9163 
9164         ASSERT(select);
9165 
9166         if (select(nodeid, ap->bp->arg, 0) == DDI_SUCCESS) {
9167 
9168                 for (nextp = &ap->head; *nextp; nextp = &(*nextp)->next)
9169                         ;
9170 
9171                 *nextp = kmem_zalloc(sizeof (struct ptnode), KM_SLEEP);
9172 
9173                 (*nextp)->nodeid = nodeid;
9174         }
9175 
9176         if ((ap->flags & DEVI_BRANCH_CHILD) == DEVI_BRANCH_CHILD)
9177                 return;
9178 
9179         nodeid = prom_childnode(nodeid);
9180         while (nodeid != OBP_NONODE && nodeid != OBP_BADNODE) {
9181                 visit_node(nodeid, ap);
9182                 nodeid = prom_nextnode(nodeid);
9183         }
9184 }
9185 
9186 /*
9187  * NOTE: The caller of this function must check for device contracts
9188  * or LDI callbacks against this dip before setting the dip offline.
9189  */
9190 static int
9191 set_infant_dip_offline(dev_info_t *dip, void *arg)
9192 {
9193         char    *path = (char *)arg;
9194 
9195         ASSERT(dip);
9196         ASSERT(arg);
9197 
9198         if (i_ddi_node_state(dip) >= DS_ATTACHED) {
9199                 (void) ddi_pathname(dip, path);
9200                 cmn_err(CE_WARN, "Attempt to set offline flag on attached "
9201                     "node: %s", path);
9202                 return (DDI_FAILURE);
9203         }
9204 
9205         mutex_enter(&(DEVI(dip)->devi_lock));
9206         if (!DEVI_IS_DEVICE_OFFLINE(dip))
9207                 DEVI_SET_DEVICE_OFFLINE(dip);
9208         mutex_exit(&(DEVI(dip)->devi_lock));
9209 
9210         return (DDI_SUCCESS);
9211 }
9212 
9213 typedef struct result {
9214         char    *path;
9215         int     result;
9216 } result_t;
9217 
9218 static int
9219 dip_set_offline(dev_info_t *dip, void *arg)
9220 {
9221         int end;
9222         result_t *resp = (result_t *)arg;
9223 
9224         ASSERT(dip);
9225         ASSERT(resp);
9226 
9227         /*
9228          * We stop the walk if e_ddi_offline_notify() returns
9229          * failure, because this implies that one or more consumers
9230          * (either LDI or contract based) has blocked the offline.
9231          * So there is no point in conitnuing the walk
9232          */
9233         if (e_ddi_offline_notify(dip) == DDI_FAILURE) {
9234                 resp->result = DDI_FAILURE;
9235                 return (DDI_WALK_TERMINATE);
9236         }
9237 
9238         /*
9239          * If set_infant_dip_offline() returns failure, it implies
9240          * that we failed to set a particular dip offline. This
9241          * does not imply that the offline as a whole should fail.
9242          * We want to do the best we can, so we continue the walk.
9243          */
9244         if (set_infant_dip_offline(dip, resp->path) == DDI_SUCCESS)
9245                 end = DDI_SUCCESS;
9246         else
9247                 end = DDI_FAILURE;
9248 
9249         e_ddi_offline_finalize(dip, end);
9250 
9251         return (DDI_WALK_CONTINUE);
9252 }
9253 
9254 /*
9255  * The call to e_ddi_offline_notify() exists for the
9256  * unlikely error case that a branch we are trying to
9257  * create already exists and has device contracts or LDI
9258  * event callbacks against it.
9259  *
9260  * We allow create to succeed for such branches only if
9261  * no constraints block the offline.
9262  */
9263 static int
9264 branch_set_offline(dev_info_t *dip, char *path)
9265 {
9266         int             circ;
9267         int             end;
9268         result_t        res;
9269 
9270 
9271         if (e_ddi_offline_notify(dip) == DDI_FAILURE) {
9272                 return (DDI_FAILURE);
9273         }
9274 
9275         if (set_infant_dip_offline(dip, path) == DDI_SUCCESS)
9276                 end = DDI_SUCCESS;
9277         else
9278                 end = DDI_FAILURE;
9279 
9280         e_ddi_offline_finalize(dip, end);
9281 
9282         if (end == DDI_FAILURE)
9283                 return (DDI_FAILURE);
9284 
9285         res.result = DDI_SUCCESS;
9286         res.path = path;
9287 
9288         ndi_devi_enter(dip, &circ);
9289         ddi_walk_devs(ddi_get_child(dip), dip_set_offline, &res);
9290         ndi_devi_exit(dip, circ);
9291 
9292         return (res.result);
9293 }
9294 
9295 /*ARGSUSED*/
9296 static int
9297 create_prom_branch(void *arg, int has_changed)
9298 {
9299         int             circ;
9300         int             exists, rv;
9301         pnode_t         nodeid;
9302         struct ptnode   *tnp;
9303         dev_info_t      *dip;
9304         struct pta      *ap = arg;
9305         devi_branch_t   *bp;
9306         char            *path;
9307 
9308         ASSERT(ap);
9309         ASSERT(ap->fdip == NULL);
9310         ASSERT(ap->pdip && ndi_dev_is_prom_node(ap->pdip));
9311 
9312         bp = ap->bp;
9313 
9314         nodeid = ddi_get_nodeid(ap->pdip);
9315         if (nodeid == OBP_NONODE || nodeid == OBP_BADNODE) {
9316                 cmn_err(CE_WARN, "create_prom_branch: invalid "
9317                     "nodeid: 0x%x", nodeid);
9318                 return (EINVAL);
9319         }
9320 
9321         ap->head = NULL;
9322 
9323         nodeid = prom_childnode(nodeid);
9324         while (nodeid != OBP_NONODE && nodeid != OBP_BADNODE) {
9325                 visit_node(nodeid, ap);
9326                 nodeid = prom_nextnode(nodeid);
9327         }
9328 
9329         if (ap->head == NULL)
9330                 return (ENODEV);
9331 
9332         path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
9333         rv = 0;
9334         while ((tnp = ap->head) != NULL) {
9335                 ap->head = tnp->next;
9336 
9337                 ndi_devi_enter(ap->pdip, &circ);
9338 
9339                 /*
9340                  * Check if the branch already exists.
9341                  */
9342                 exists = 0;
9343                 dip = e_ddi_nodeid_to_dip(tnp->nodeid);
9344                 if (dip != NULL) {
9345                         exists = 1;
9346 
9347                         /* Parent is held busy, so release hold */
9348                         ndi_rele_devi(dip);
9349 #ifdef  DEBUG
9350                         cmn_err(CE_WARN, "create_prom_branch: dip(%p) exists"
9351                             " for nodeid 0x%x", (void *)dip, tnp->nodeid);
9352 #endif
9353                 } else {
9354                         dip = i_ddi_create_branch(ap->pdip, tnp->nodeid);
9355                 }
9356 
9357                 kmem_free(tnp, sizeof (struct ptnode));
9358 
9359                 /*
9360                  * Hold the branch if it is not already held
9361                  */
9362                 if (dip && !exists) {
9363                         e_ddi_branch_hold(dip);
9364                 }
9365 
9366                 ASSERT(dip == NULL || e_ddi_branch_held(dip));
9367 
9368                 /*
9369                  * Set all dips in the newly created branch offline so that
9370                  * only a "configure" operation can attach
9371                  * the branch
9372                  */
9373                 if (dip == NULL || branch_set_offline(dip, path)
9374                     == DDI_FAILURE) {
9375                         ndi_devi_exit(ap->pdip, circ);
9376                         rv = EIO;
9377                         continue;
9378                 }
9379 
9380                 ASSERT(ddi_get_parent(dip) == ap->pdip);
9381 
9382                 ndi_devi_exit(ap->pdip, circ);
9383 
9384                 if (ap->flags & DEVI_BRANCH_CONFIGURE) {
9385                         int error = e_ddi_branch_configure(dip, &ap->fdip, 0);
9386                         if (error && rv == 0)
9387                                 rv = error;
9388                 }
9389 
9390                 /*
9391                  * Invoke devi_branch_callback() (if it exists) only for
9392                  * newly created branches
9393                  */
9394                 if (bp->devi_branch_callback && !exists)
9395                         bp->devi_branch_callback(dip, bp->arg, 0);
9396         }
9397 
9398         kmem_free(path, MAXPATHLEN);
9399 
9400         return (rv);
9401 }
9402 
9403 static int
9404 sid_node_create(dev_info_t *pdip, devi_branch_t *bp, dev_info_t **rdipp)
9405 {
9406         int                     rv, circ, len;
9407         int                     i, flags, ret;
9408         dev_info_t              *dip;
9409         char                    *nbuf;
9410         char                    *path;
9411         static const char       *noname = "<none>";
9412 
9413         ASSERT(pdip);
9414         ASSERT(DEVI_BUSY_OWNED(pdip));
9415 
9416         flags = 0;
9417 
9418         /*
9419          * Creating the root of a branch ?
9420          */
9421         if (rdipp) {
9422                 *rdipp = NULL;
9423                 flags = DEVI_BRANCH_ROOT;
9424         }
9425 
9426         ndi_devi_alloc_sleep(pdip, (char *)noname, DEVI_SID_NODEID, &dip);
9427         rv = bp->create.sid_branch_create(dip, bp->arg, flags);
9428 
9429         nbuf = kmem_alloc(OBP_MAXDRVNAME, KM_SLEEP);
9430 
9431         if (rv == DDI_WALK_ERROR) {
9432                 cmn_err(CE_WARN, "e_ddi_branch_create: Error setting"
9433                     " properties on devinfo node %p",  (void *)dip);
9434                 goto fail;
9435         }
9436 
9437         len = OBP_MAXDRVNAME;
9438         if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip,
9439             DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "name", nbuf, &len)
9440             != DDI_PROP_SUCCESS) {
9441                 cmn_err(CE_WARN, "e_ddi_branch_create: devinfo node %p has"
9442                     "no name property", (void *)dip);
9443                 goto fail;
9444         }
9445 
9446         ASSERT(i_ddi_node_state(dip) == DS_PROTO);
9447         if (ndi_devi_set_nodename(dip, nbuf, 0) != NDI_SUCCESS) {
9448                 cmn_err(CE_WARN, "e_ddi_branch_create: cannot set name (%s)"
9449                     " for devinfo node %p", nbuf, (void *)dip);
9450                 goto fail;
9451         }
9452 
9453         kmem_free(nbuf, OBP_MAXDRVNAME);
9454 
9455         /*
9456          * Ignore bind failures just like boot does
9457          */
9458         (void) ndi_devi_bind_driver(dip, 0);
9459 
9460         switch (rv) {
9461         case DDI_WALK_CONTINUE:
9462         case DDI_WALK_PRUNESIB:
9463                 ndi_devi_enter(dip, &circ);
9464 
9465                 i = DDI_WALK_CONTINUE;
9466                 for (; i == DDI_WALK_CONTINUE; ) {
9467                         i = sid_node_create(dip, bp, NULL);
9468                 }
9469 
9470                 ASSERT(i == DDI_WALK_ERROR || i == DDI_WALK_PRUNESIB);
9471                 if (i == DDI_WALK_ERROR)
9472                         rv = i;
9473                 /*
9474                  * If PRUNESIB stop creating siblings
9475                  * of dip's child. Subsequent walk behavior
9476                  * is determined by rv returned by dip.
9477                  */
9478 
9479                 ndi_devi_exit(dip, circ);
9480                 break;
9481         case DDI_WALK_TERMINATE:
9482                 /*
9483                  * Don't create children and ask our parent
9484                  * to not create siblings either.
9485                  */
9486                 rv = DDI_WALK_PRUNESIB;
9487                 break;
9488         case DDI_WALK_PRUNECHILD:
9489                 /*
9490                  * Don't create children, but ask parent to continue
9491                  * with siblings.
9492                  */
9493                 rv = DDI_WALK_CONTINUE;
9494                 break;
9495         default:
9496                 ASSERT(0);
9497                 break;
9498         }
9499 
9500         if (rdipp)
9501                 *rdipp = dip;
9502 
9503         /*
9504          * Set device offline - only the "configure" op should cause an attach.
9505          * Note that it is safe to set the dip offline without checking
9506          * for either device contract or layered driver (LDI) based constraints
9507          * since there cannot be any contracts or LDI opens of this device.
9508          * This is because this node is a newly created dip with the parent busy
9509          * held, so no other thread can come in and attach this dip. A dip that
9510          * has never been attached cannot have contracts since by definition
9511          * a device contract (an agreement between a process and a device minor
9512          * node) can only be created against a device that has minor nodes
9513          * i.e is attached. Similarly an LDI open will only succeed if the
9514          * dip is attached. We assert below that the dip is not attached.
9515          */
9516         ASSERT(i_ddi_node_state(dip) < DS_ATTACHED);
9517         path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
9518         ret = set_infant_dip_offline(dip, path);
9519         ASSERT(ret == DDI_SUCCESS);
9520         kmem_free(path, MAXPATHLEN);
9521 
9522         return (rv);
9523 fail:
9524         (void) ndi_devi_free(dip);
9525         kmem_free(nbuf, OBP_MAXDRVNAME);
9526         return (DDI_WALK_ERROR);
9527 }
9528 
9529 static int
9530 create_sid_branch(
9531         dev_info_t      *pdip,
9532         devi_branch_t   *bp,
9533         dev_info_t      **dipp,
9534         uint_t          flags)
9535 {
9536         int             rv = 0, state = DDI_WALK_CONTINUE;
9537         dev_info_t      *rdip;
9538 
9539         while (state == DDI_WALK_CONTINUE) {
9540                 int     circ;
9541 
9542                 ndi_devi_enter(pdip, &circ);
9543 
9544                 state = sid_node_create(pdip, bp, &rdip);
9545                 if (rdip == NULL) {
9546                         ndi_devi_exit(pdip, circ);
9547                         ASSERT(state == DDI_WALK_ERROR);
9548                         break;
9549                 }
9550 
9551                 e_ddi_branch_hold(rdip);
9552 
9553                 ndi_devi_exit(pdip, circ);
9554 
9555                 if (flags & DEVI_BRANCH_CONFIGURE) {
9556                         int error = e_ddi_branch_configure(rdip, dipp, 0);
9557                         if (error && rv == 0)
9558                                 rv = error;
9559                 }
9560 
9561                 /*
9562                  * devi_branch_callback() is optional
9563                  */
9564                 if (bp->devi_branch_callback)
9565                         bp->devi_branch_callback(rdip, bp->arg, 0);
9566         }
9567 
9568         ASSERT(state == DDI_WALK_ERROR || state == DDI_WALK_PRUNESIB);
9569 
9570         return (state == DDI_WALK_ERROR ? EIO : rv);
9571 }
9572 
9573 int
9574 e_ddi_branch_create(
9575         dev_info_t      *pdip,
9576         devi_branch_t   *bp,
9577         dev_info_t      **dipp,
9578         uint_t          flags)
9579 {
9580         int prom_devi, sid_devi, error;
9581 
9582         if (pdip == NULL || bp == NULL || bp->type == 0)
9583                 return (EINVAL);
9584 
9585         prom_devi = (bp->type == DEVI_BRANCH_PROM) ? 1 : 0;
9586         sid_devi = (bp->type == DEVI_BRANCH_SID) ? 1 : 0;
9587 
9588         if (prom_devi && bp->create.prom_branch_select == NULL)
9589                 return (EINVAL);
9590         else if (sid_devi && bp->create.sid_branch_create == NULL)
9591                 return (EINVAL);
9592         else if (!prom_devi && !sid_devi)
9593                 return (EINVAL);
9594 
9595         if (flags & DEVI_BRANCH_EVENT)
9596                 return (EINVAL);
9597 
9598         if (prom_devi) {
9599                 struct pta pta = {0};
9600 
9601                 pta.pdip = pdip;
9602                 pta.bp = bp;
9603                 pta.flags = flags;
9604 
9605                 error = prom_tree_access(create_prom_branch, &pta, NULL);
9606 
9607                 if (dipp)
9608                         *dipp = pta.fdip;
9609                 else if (pta.fdip)
9610                         ndi_rele_devi(pta.fdip);
9611         } else {
9612                 error = create_sid_branch(pdip, bp, dipp, flags);
9613         }
9614 
9615         return (error);
9616 }
9617 
9618 int
9619 e_ddi_branch_configure(dev_info_t *rdip, dev_info_t **dipp, uint_t flags)
9620 {
9621         int             rv;
9622         char            *devnm;
9623         dev_info_t      *pdip;
9624 
9625         if (dipp)
9626                 *dipp = NULL;
9627 
9628         if (rdip == NULL || flags != 0 || (flags & DEVI_BRANCH_EVENT))
9629                 return (EINVAL);
9630 
9631         pdip = ddi_get_parent(rdip);
9632 
9633         ndi_hold_devi(pdip);
9634 
9635         if (!e_ddi_branch_held(rdip)) {
9636                 ndi_rele_devi(pdip);
9637                 cmn_err(CE_WARN, "e_ddi_branch_configure: "
9638                     "dip(%p) not held", (void *)rdip);
9639                 return (EINVAL);
9640         }
9641 
9642         if (i_ddi_node_state(rdip) < DS_INITIALIZED) {
9643                 /*
9644                  * First attempt to bind a driver. If we fail, return
9645                  * success (On some platforms, dips for some device
9646                  * types (CPUs) may not have a driver)
9647                  */
9648                 if (ndi_devi_bind_driver(rdip, 0) != NDI_SUCCESS) {
9649                         ndi_rele_devi(pdip);
9650                         return (0);
9651                 }
9652 
9653                 if (ddi_initchild(pdip, rdip) != DDI_SUCCESS) {
9654                         rv = NDI_FAILURE;
9655                         goto out;
9656                 }
9657         }
9658 
9659         ASSERT(i_ddi_node_state(rdip) >= DS_INITIALIZED);
9660 
9661         devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP);
9662 
9663         (void) ddi_deviname(rdip, devnm);
9664 
9665         if ((rv = ndi_devi_config_one(pdip, devnm+1, &rdip,
9666             NDI_DEVI_ONLINE | NDI_CONFIG)) == NDI_SUCCESS) {
9667                 /* release hold from ndi_devi_config_one() */
9668                 ndi_rele_devi(rdip);
9669         }
9670 
9671         kmem_free(devnm, MAXNAMELEN + 1);
9672 out:
9673         if (rv != NDI_SUCCESS && dipp && rdip) {
9674                 ndi_hold_devi(rdip);
9675                 *dipp = rdip;
9676         }
9677         ndi_rele_devi(pdip);
9678         return (ndi2errno(rv));
9679 }
9680 
9681 void
9682 e_ddi_branch_hold(dev_info_t *rdip)
9683 {
9684         if (e_ddi_branch_held(rdip)) {
9685                 cmn_err(CE_WARN, "e_ddi_branch_hold: branch already held");
9686                 return;
9687         }
9688 
9689         mutex_enter(&DEVI(rdip)->devi_lock);
9690         if ((DEVI(rdip)->devi_flags & DEVI_BRANCH_HELD) == 0) {
9691                 DEVI(rdip)->devi_flags |= DEVI_BRANCH_HELD;
9692                 DEVI(rdip)->devi_ref++;
9693         }
9694         ASSERT(DEVI(rdip)->devi_ref > 0);
9695         mutex_exit(&DEVI(rdip)->devi_lock);
9696 }
9697 
9698 int
9699 e_ddi_branch_held(dev_info_t *rdip)
9700 {
9701         int rv = 0;
9702 
9703         mutex_enter(&DEVI(rdip)->devi_lock);
9704         if ((DEVI(rdip)->devi_flags & DEVI_BRANCH_HELD) &&
9705             DEVI(rdip)->devi_ref > 0) {
9706                 rv = 1;
9707         }
9708         mutex_exit(&DEVI(rdip)->devi_lock);
9709 
9710         return (rv);
9711 }
9712 
9713 void
9714 e_ddi_branch_rele(dev_info_t *rdip)
9715 {
9716         mutex_enter(&DEVI(rdip)->devi_lock);
9717         DEVI(rdip)->devi_flags &= ~DEVI_BRANCH_HELD;
9718         DEVI(rdip)->devi_ref--;
9719         mutex_exit(&DEVI(rdip)->devi_lock);
9720 }
9721 
9722 int
9723 e_ddi_branch_unconfigure(
9724         dev_info_t *rdip,
9725         dev_info_t **dipp,
9726         uint_t flags)
9727 {
9728         int     circ, rv;
9729         int     destroy;
9730         char    *devnm;
9731         uint_t  nflags;
9732         dev_info_t *pdip;
9733 
9734         if (dipp)
9735                 *dipp = NULL;
9736 
9737         if (rdip == NULL)
9738                 return (EINVAL);
9739 
9740         pdip = ddi_get_parent(rdip);
9741 
9742         ASSERT(pdip);
9743 
9744         /*
9745          * Check if caller holds pdip busy - can cause deadlocks during
9746          * devfs_clean()
9747          */
9748         if (DEVI_BUSY_OWNED(pdip)) {
9749                 cmn_err(CE_WARN, "e_ddi_branch_unconfigure: failed: parent"
9750                     " devinfo node(%p) is busy held", (void *)pdip);
9751                 return (EINVAL);
9752         }
9753 
9754         destroy = (flags & DEVI_BRANCH_DESTROY) ? 1 : 0;
9755 
9756         devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP);
9757 
9758         ndi_devi_enter(pdip, &circ);
9759         (void) ddi_deviname(rdip, devnm);
9760         ndi_devi_exit(pdip, circ);
9761 
9762         /*
9763          * ddi_deviname() returns a component name with / prepended.
9764          */
9765         (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE);
9766 
9767         ndi_devi_enter(pdip, &circ);
9768 
9769         /*
9770          * Recreate device name as it may have changed state (init/uninit)
9771          * when parent busy lock was dropped for devfs_clean()
9772          */
9773         (void) ddi_deviname(rdip, devnm);
9774 
9775         if (!e_ddi_branch_held(rdip)) {
9776                 kmem_free(devnm, MAXNAMELEN + 1);
9777                 ndi_devi_exit(pdip, circ);
9778                 cmn_err(CE_WARN, "e_ddi_%s_branch: dip(%p) not held",
9779                     destroy ? "destroy" : "unconfigure", (void *)rdip);
9780                 return (EINVAL);
9781         }
9782 
9783         /*
9784          * Release hold on the branch. This is ok since we are holding the
9785          * parent busy. If rdip is not removed, we must do a hold on the
9786          * branch before returning.
9787          */
9788         e_ddi_branch_rele(rdip);
9789 
9790         nflags = NDI_DEVI_OFFLINE;
9791         if (destroy || (flags & DEVI_BRANCH_DESTROY)) {
9792                 nflags |= NDI_DEVI_REMOVE;
9793                 destroy = 1;
9794         } else {
9795                 nflags |= NDI_UNCONFIG;         /* uninit but don't remove */
9796         }
9797 
9798         if (flags & DEVI_BRANCH_EVENT)
9799                 nflags |= NDI_POST_EVENT;
9800 
9801         if (i_ddi_devi_attached(pdip) &&
9802             (i_ddi_node_state(rdip) >= DS_INITIALIZED)) {
9803                 rv = ndi_devi_unconfig_one(pdip, devnm+1, dipp, nflags);
9804         } else {
9805                 rv = e_ddi_devi_unconfig(rdip, dipp, nflags);
9806                 if (rv == NDI_SUCCESS) {
9807                         ASSERT(!destroy || ddi_get_child(rdip) == NULL);
9808                         rv = ndi_devi_offline(rdip, nflags);
9809                 }
9810         }
9811 
9812         if (!destroy || rv != NDI_SUCCESS) {
9813                 /* The dip still exists, so do a hold */
9814                 e_ddi_branch_hold(rdip);
9815         }
9816 out:
9817         kmem_free(devnm, MAXNAMELEN + 1);
9818         ndi_devi_exit(pdip, circ);
9819         return (ndi2errno(rv));
9820 }
9821 
9822 int
9823 e_ddi_branch_destroy(dev_info_t *rdip, dev_info_t **dipp, uint_t flag)
9824 {
9825         return (e_ddi_branch_unconfigure(rdip, dipp,
9826             flag|DEVI_BRANCH_DESTROY));
9827 }
9828 
9829 /*
9830  * Number of chains for hash table
9831  */
9832 #define NUMCHAINS       17
9833 
9834 /*
9835  * Devinfo busy arg
9836  */
9837 struct devi_busy {
9838         int dv_total;
9839         int s_total;
9840         mod_hash_t *dv_hash;
9841         mod_hash_t *s_hash;
9842         int (*callback)(dev_info_t *, void *, uint_t);
9843         void *arg;
9844 };
9845 
9846 static int
9847 visit_dip(dev_info_t *dip, void *arg)
9848 {
9849         uintptr_t sbusy, dvbusy, ref;
9850         struct devi_busy *bsp = arg;
9851 
9852         ASSERT(bsp->callback);
9853 
9854         /*
9855          * A dip cannot be busy if its reference count is 0
9856          */
9857         if ((ref = e_ddi_devi_holdcnt(dip)) == 0) {
9858                 return (bsp->callback(dip, bsp->arg, 0));
9859         }
9860 
9861         if (mod_hash_find(bsp->dv_hash, dip, (mod_hash_val_t *)&dvbusy))
9862                 dvbusy = 0;
9863 
9864         /*
9865          * To catch device opens currently maintained on specfs common snodes.
9866          */
9867         if (mod_hash_find(bsp->s_hash, dip, (mod_hash_val_t *)&sbusy))
9868                 sbusy = 0;
9869 
9870 #ifdef  DEBUG
9871         if (ref < sbusy || ref < dvbusy) {
9872                 cmn_err(CE_WARN, "dip(%p): sopen = %lu, dvopen = %lu "
9873                     "dip ref = %lu\n", (void *)dip, sbusy, dvbusy, ref);
9874         }
9875 #endif
9876 
9877         dvbusy = (sbusy > dvbusy) ? sbusy : dvbusy;
9878 
9879         return (bsp->callback(dip, bsp->arg, dvbusy));
9880 }
9881 
9882 static int
9883 visit_snode(struct snode *sp, void *arg)
9884 {
9885         uintptr_t sbusy;
9886         dev_info_t *dip;
9887         int count;
9888         struct devi_busy *bsp = arg;
9889 
9890         ASSERT(sp);
9891 
9892         /*
9893          * The stable lock is held. This prevents
9894          * the snode and its associated dip from
9895          * going away.
9896          */
9897         dip = NULL;
9898         count = spec_devi_open_count(sp, &dip);
9899 
9900         if (count <= 0)
9901                 return (DDI_WALK_CONTINUE);
9902 
9903         ASSERT(dip);
9904 
9905         if (mod_hash_remove(bsp->s_hash, dip, (mod_hash_val_t *)&sbusy))
9906                 sbusy = count;
9907         else
9908                 sbusy += count;
9909 
9910         if (mod_hash_insert(bsp->s_hash, dip, (mod_hash_val_t)sbusy)) {
9911                 cmn_err(CE_WARN, "%s: s_hash insert failed: dip=0x%p, "
9912                     "sbusy = %lu", "e_ddi_branch_referenced",
9913                     (void *)dip, sbusy);
9914         }
9915 
9916         bsp->s_total += count;
9917 
9918         return (DDI_WALK_CONTINUE);
9919 }
9920 
9921 static void
9922 visit_dvnode(struct dv_node *dv, void *arg)
9923 {
9924         uintptr_t dvbusy;
9925         uint_t count;
9926         struct vnode *vp;
9927         struct devi_busy *bsp = arg;
9928 
9929         ASSERT(dv && dv->dv_devi);
9930 
9931         vp = DVTOV(dv);
9932 
9933         mutex_enter(&vp->v_lock);
9934         count = vp->v_count;
9935         mutex_exit(&vp->v_lock);
9936 
9937         if (!count)
9938                 return;
9939 
9940         if (mod_hash_remove(bsp->dv_hash, dv->dv_devi,
9941             (mod_hash_val_t *)&dvbusy))
9942                 dvbusy = count;
9943         else
9944                 dvbusy += count;
9945 
9946         if (mod_hash_insert(bsp->dv_hash, dv->dv_devi,
9947             (mod_hash_val_t)dvbusy)) {
9948                 cmn_err(CE_WARN, "%s: dv_hash insert failed: dip=0x%p, "
9949                     "dvbusy=%lu", "e_ddi_branch_referenced",
9950                     (void *)dv->dv_devi, dvbusy);
9951         }
9952 
9953         bsp->dv_total += count;
9954 }
9955 
9956 /*
9957  * Returns reference count on success or -1 on failure.
9958  */
9959 int
9960 e_ddi_branch_referenced(
9961         dev_info_t *rdip,
9962         int (*callback)(dev_info_t *dip, void *arg, uint_t ref),
9963         void *arg)
9964 {
9965         int circ;
9966         char *path;
9967         dev_info_t *pdip;
9968         struct devi_busy bsa = {0};
9969 
9970         ASSERT(rdip);
9971 
9972         path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
9973 
9974         ndi_hold_devi(rdip);
9975 
9976         pdip = ddi_get_parent(rdip);
9977 
9978         ASSERT(pdip);
9979 
9980         /*
9981          * Check if caller holds pdip busy - can cause deadlocks during
9982          * devfs_walk()
9983          */
9984         if (!e_ddi_branch_held(rdip) || DEVI_BUSY_OWNED(pdip)) {
9985                 cmn_err(CE_WARN, "e_ddi_branch_referenced: failed: "
9986                     "devinfo branch(%p) not held or parent busy held",
9987                     (void *)rdip);
9988                 ndi_rele_devi(rdip);
9989                 kmem_free(path, MAXPATHLEN);
9990                 return (-1);
9991         }
9992 
9993         ndi_devi_enter(pdip, &circ);
9994         (void) ddi_pathname(rdip, path);
9995         ndi_devi_exit(pdip, circ);
9996 
9997         bsa.dv_hash = mod_hash_create_ptrhash("dv_node busy hash", NUMCHAINS,
9998             mod_hash_null_valdtor, sizeof (struct dev_info));
9999 
10000         bsa.s_hash = mod_hash_create_ptrhash("snode busy hash", NUMCHAINS,
10001             mod_hash_null_valdtor, sizeof (struct snode));
10002 
10003         if (devfs_walk(path, visit_dvnode, &bsa)) {
10004                 cmn_err(CE_WARN, "e_ddi_branch_referenced: "
10005                     "devfs walk failed for: %s", path);
10006                 kmem_free(path, MAXPATHLEN);
10007                 bsa.s_total = bsa.dv_total = -1;
10008                 goto out;
10009         }
10010 
10011         kmem_free(path, MAXPATHLEN);
10012 
10013         /*
10014          * Walk the snode table to detect device opens, which are currently
10015          * maintained on specfs common snodes.
10016          */
10017         spec_snode_walk(visit_snode, &bsa);
10018 
10019         if (callback == NULL)
10020                 goto out;
10021 
10022         bsa.callback = callback;
10023         bsa.arg = arg;
10024 
10025         if (visit_dip(rdip, &bsa) == DDI_WALK_CONTINUE) {
10026                 ndi_devi_enter(rdip, &circ);
10027                 ddi_walk_devs(ddi_get_child(rdip), visit_dip, &bsa);
10028                 ndi_devi_exit(rdip, circ);
10029         }
10030 
10031 out:
10032         ndi_rele_devi(rdip);
10033         mod_hash_destroy_ptrhash(bsa.s_hash);
10034         mod_hash_destroy_ptrhash(bsa.dv_hash);
10035         return (bsa.s_total > bsa.dv_total ? bsa.s_total : bsa.dv_total);
10036 }