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