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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved.
27 */
28
29 /*
30 * pseudo bus nexus driver
31 * hotplug framework test facility
32 */
33
34 /*
35 * The pshot driver can be used to exercise the i/o framework together
36 * with devfs by configuring an arbitrarily complex device tree.
37 *
38 * The pshot driver is rooted at /devices/pshot. The following commands
39 * illustrate the operation of devfs together with pshot's bus_config.
40 * The first command demonstrates that, like the magician showing there's
41 * nothing up his sleeve, /devices/pshot is empty. The second command
42 * conjures up a branch of pshot nodes. Note that pshot's bus_config is
43 * called sequentially by devfs for each node, as part of the pathname
44 * resolution, and that each pshot node is fully configured and
45 * attached before that node's bus_config is called to configure the
46 * next child down the tree. The final result is a "disk" node configured
47 * at the bottom of the named hierarchy of pshot nodes.
48 *
49 * #
50 * # ls /devices/pshot
51 * #
52 * # ls -ld /devices/pshot/pshot@0/pshot@1/pshot@2/disk@3,0
53 * drwxr-xr-x 2 root sys 512 Feb 6 15:10
54 * /devices/pshot/pshot@0/pshot@1/pshot@2/disk@3,0
55 *
56 * pshot supports some unique behaviors as aids for test error cases.
57 *
58 * Match these special address formats to behavior:
59 *
60 * err.* - induce bus_config error
61 * delay - induce 1 second of bus_config delay time
62 * delay,n - induce n seconds of bus_config delay time
63 * wait - induce 1 second of bus_config wait time
64 * wait,n - induce n seconds of bus_config wait time
65 * failinit.* - induce error at INITCHILD
66 * failprobe.* - induce error at probe
67 * failattach.* - induce error at attach
68 */
69
70 #if defined(lint) && !defined(DEBUG)
71 #define DEBUG 1
72 #endif
73
74 #include <sys/types.h>
75 #include <sys/cmn_err.h>
76 #include <sys/conf.h>
77 #include <sys/ddi_impldefs.h>
78 #include <sys/autoconf.h>
79 #include <sys/open.h>
80 #include <sys/stat.h>
81 #include <sys/file.h>
82 #include <sys/errno.h>
83 #include <sys/systm.h>
84 #include <sys/modctl.h>
85 #include <sys/kmem.h>
86 #include <sys/ddi.h>
87 #include <sys/sunddi.h>
88 #include <sys/sunndi.h>
89 #include <sys/devctl.h>
90 #include <sys/disp.h>
91 #include <sys/utsname.h>
92 #include <sys/pshot.h>
93 #include <sys/debug.h>
94
95 static int pshot_log = 0;
96 static int pshot_devctl_debug = 0;
97 static int pshot_debug_busy = 0;
98
99 static void *pshot_softstatep;
100
101 static int pshot_prop_autoattach;
102
103 #define MAXPWR 3
104
105
106 /*
107 * device configuration data
108 */
109
110 /* should keep in sync with current release */
111 static struct {
112 char *name;
113 char *val;
114 } pshot_nodetypes[] = {
115 {"DDI_NT_SERIAL", DDI_NT_SERIAL},
116 {"DDI_NT_SERIAL_MB", DDI_NT_SERIAL_MB},
117 {"DDI_NT_SERIAL_DO", DDI_NT_SERIAL_DO},
118 {"DDI_NT_SERIAL_MB_DO", DDI_NT_SERIAL_MB_DO},
119 {"DDI_NT_SERIAL_LOMCON", DDI_NT_SERIAL_LOMCON},
120 {"DDI_NT_BLOCK", DDI_NT_BLOCK},
121 {"DDI_NT_BLOCK_CHAN", DDI_NT_BLOCK_CHAN},
122 {"DDI_NT_BLOCK_WWN", DDI_NT_BLOCK_WWN},
123 {"DDI_NT_BLOCK_SAS", DDI_NT_BLOCK_SAS},
124 {"DDI_NT_CD", DDI_NT_CD},
125 {"DDI_NT_CD_CHAN", DDI_NT_CD_CHAN},
126 {"DDI_NT_FD", DDI_NT_FD},
127 {"DDI_NT_ENCLOSURE", DDI_NT_ENCLOSURE},
128 {"DDI_NT_SCSI_ENCLOSURE", DDI_NT_SCSI_ENCLOSURE},
129 {"DDI_NT_TAPE", DDI_NT_TAPE},
130 {"DDI_NT_NET", DDI_NT_NET},
131 {"DDI_NT_DISPLAY", DDI_NT_DISPLAY},
132 {"DDI_PSEUDO", DDI_PSEUDO},
133 {"DDI_NT_AUDIO", DDI_NT_AUDIO},
134 {"DDI_NT_MOUSE", DDI_NT_MOUSE},
135 {"DDI_NT_KEYBOARD", DDI_NT_KEYBOARD},
136 {"DDI_NT_PARALLEL", DDI_NT_PARALLEL},
137 {"DDI_NT_PRINTER", DDI_NT_PRINTER},
138 {"DDI_NT_UGEN", DDI_NT_UGEN},
139 {"DDI_NT_NEXUS", DDI_NT_NEXUS},
140 {"DDI_NT_SCSI_NEXUS", DDI_NT_SCSI_NEXUS},
141 {"DDI_NT_ATTACHMENT_POINT", DDI_NT_ATTACHMENT_POINT},
142 {"DDI_NT_SCSI_ATTACHMENT_POINT", DDI_NT_SCSI_ATTACHMENT_POINT},
143 {"DDI_NT_PCI_ATTACHMENT_POINT", DDI_NT_PCI_ATTACHMENT_POINT},
144 {"DDI_NT_SBD_ATTACHMENT_POINT", DDI_NT_SBD_ATTACHMENT_POINT},
145 {"DDI_NT_FC_ATTACHMENT_POINT", DDI_NT_FC_ATTACHMENT_POINT},
146 {"DDI_NT_USB_ATTACHMENT_POINT", DDI_NT_USB_ATTACHMENT_POINT},
147 {"DDI_NT_BLOCK_FABRIC", DDI_NT_BLOCK_FABRIC},
148 {"DDI_NT_AV_ASYNC", DDI_NT_AV_ASYNC},
149 {"DDI_NT_AV_ISOCH", DDI_NT_AV_ISOCH},
150 { NULL, NULL }
151 };
152
153 /* Node name */
154 static char *pshot_compat_diskname = "cdisk";
155
156 /* Compatible names... */
157 static char *pshot_compat_psramdisks[] = {
158 "psramhead",
159 "psramrom",
160 "psramdisk",
161 "psramd",
162 "psramwhat"
163 };
164
165 /*
166 * devices "natively" supported by pshot (i.e. included with SUNWiotu)
167 * used to initialize pshot_devices with
168 */
169 static pshot_device_t pshot_stock_devices[] = {
170 {"disk", DDI_NT_BLOCK, "gen_drv"},
171 {"disk_chan", DDI_NT_BLOCK_CHAN, "gen_drv"},
172 {"disk_wwn", DDI_NT_BLOCK_WWN, "gen_drv"},
173 {"disk_cdrom", DDI_NT_CD, "gen_drv"},
174 {"disk_cdrom.chan", DDI_NT_CD_CHAN, "gen_drv"},
175 /* Note: use bad_drv to force attach errors */
176 {"disk_fd", DDI_NT_FD, "bad_drv"},
177 {"tape", DDI_NT_TAPE, "gen_drv"},
178 {"net", DDI_NT_NET, "gen_drv"},
179 {"display", DDI_NT_DISPLAY, "gen_drv"},
180 {"pseudo", DDI_PSEUDO, "gen_drv"},
181 {"audio", DDI_NT_AUDIO, "gen_drv"},
182 {"mouse", DDI_NT_MOUSE, "gen_drv"},
183 {"keyboard", DDI_NT_KEYBOARD, "gen_drv"},
184 {"nexus", DDI_NT_NEXUS, "pshot"}
185 };
186 #define PSHOT_N_STOCK_DEVICES \
187 (sizeof (pshot_stock_devices) / sizeof (pshot_device_t))
188
189 static pshot_device_t *pshot_devices = NULL;
190 static size_t pshot_devices_len = 0;
191
192 /* protects <pshot_devices>, <pshot_devices_len> */
193 static kmutex_t pshot_devices_lock;
194
195
196 /*
197 * event testing
198 */
199
200 static ndi_event_definition_t pshot_ndi_event_defs[] = {
201 { PSHOT_EVENT_TAG_OFFLINE, PSHOT_EVENT_NAME_DEV_OFFLINE,
202 EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
203
204 { PSHOT_EVENT_TAG_DEV_RESET, PSHOT_EVENT_NAME_DEV_RESET,
205 EPL_INTERRUPT, NDI_EVENT_POST_TO_TGT },
206
207 { PSHOT_EVENT_TAG_BUS_RESET, PSHOT_EVENT_NAME_BUS_RESET,
208 EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
209
210 { PSHOT_EVENT_TAG_BUS_QUIESCE, PSHOT_EVENT_NAME_BUS_QUIESCE,
211 EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
212
213 { PSHOT_EVENT_TAG_BUS_UNQUIESCE, PSHOT_EVENT_NAME_BUS_UNQUIESCE,
214 EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
215
216 { PSHOT_EVENT_TAG_TEST_POST, PSHOT_EVENT_NAME_BUS_TEST_POST,
217 EPL_INTERRUPT, NDI_EVENT_POST_TO_TGT }
218 };
219
220
221 #define PSHOT_N_NDI_EVENTS \
222 (sizeof (pshot_ndi_event_defs) / sizeof (ndi_event_definition_t))
223
224 #ifdef DEBUG
225
226 static ndi_event_definition_t pshot_test_events[] = {
227 { 10, "test event 0", EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
228 { 11, "test event 1", EPL_KERNEL, NDI_EVENT_POST_TO_TGT },
229 { 12, "test event 2", EPL_INTERRUPT, NDI_EVENT_POST_TO_TGT },
230 { 13, "test event 3", EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
231 { 14, "test event 4", EPL_KERNEL, NDI_EVENT_POST_TO_ALL},
232 { 15, "test event 5", EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL },
233 { 16, "test event 6", EPL_KERNEL, NDI_EVENT_POST_TO_ALL },
234 { 17, "test event 7", EPL_INTERRUPT, NDI_EVENT_POST_TO_ALL }
235 };
236
237 static ndi_event_definition_t pshot_test_events_high[] = {
238 { 20, "test event high 0", EPL_HIGHLEVEL, NDI_EVENT_POST_TO_ALL}
239 };
240
241 #define PSHOT_N_TEST_EVENTS \
242 (sizeof (pshot_test_events)/sizeof (ndi_event_definition_t))
243 #endif
244
245 struct register_events {
246 char *event_name;
247 ddi_eventcookie_t event_cookie;
248 void (*event_callback)
249 (dev_info_t *,
250 ddi_eventcookie_t,
251 void *arg,
252 void *impldata);
253 ddi_callback_id_t cb_id;
254 };
255
256 struct register_events pshot_register_events[] = {
257 { PSHOT_EVENT_NAME_DEV_OFFLINE, 0, pshot_event_cb, 0 },
258 { PSHOT_EVENT_NAME_DEV_RESET, 0, pshot_event_cb, 0 },
259 { PSHOT_EVENT_NAME_BUS_RESET, 0, pshot_event_cb, 0 },
260 { PSHOT_EVENT_NAME_BUS_QUIESCE, 0, pshot_event_cb, 0 },
261 { PSHOT_EVENT_NAME_BUS_UNQUIESCE, 0, pshot_event_cb, 0 },
262 { PSHOT_EVENT_NAME_BUS_TEST_POST, 0, pshot_event_cb, 0 }
263 };
264
265 #define PSHOT_N_DDI_EVENTS \
266 (sizeof (pshot_register_events) / sizeof (struct register_events))
267
268
269 #ifdef DEBUG
270
271 static struct register_events pshot_register_test[] = {
272 { "test event 0", 0, pshot_event_cb_test, 0},
273 { "test event 1", 0, pshot_event_cb_test, 0},
274 { "test event 2", 0, pshot_event_cb_test, 0},
275 { "test event 3", 0, pshot_event_cb_test, 0},
276 { "test event 4", 0, pshot_event_cb_test, 0},
277 { "test event 5", 0, pshot_event_cb_test, 0},
278 { "test event 6", 0, pshot_event_cb_test, 0},
279 { "test event 7", 0, pshot_event_cb_test, 0}
280 };
281
282
283 static struct register_events pshot_register_high_test[] = {
284 {"test event high 0", 0, pshot_event_cb_test, 0}
285 };
286
287 #endif /* DEBUG */
288
289 static struct {
290 int ioctl_int;
291 char *ioctl_char;
292 } pshot_devctls[] = {
293 {DEVCTL_DEVICE_GETSTATE, "DEVCTL_DEVICE_GETSTATE"},
294 {DEVCTL_DEVICE_ONLINE, "DEVCTL_DEVICE_ONLINE"},
295 {DEVCTL_DEVICE_OFFLINE, "DEVCTL_DEVICE_OFFLINE"},
296 {DEVCTL_DEVICE_REMOVE, "DEVCTL_DEVICE_REMOVE"},
297 {DEVCTL_BUS_GETSTATE, "DEVCTL_BUS_GETSTATE"},
298 {DEVCTL_BUS_DEV_CREATE, "DEVCTL_BUS_DEV_CREATE"},
299 {DEVCTL_BUS_RESET, "DEVCTL_BUS_RESET"},
300 {DEVCTL_BUS_RESETALL, "DEVCTL_BUS_RESETALL"},
301 {0, NULL}
302 };
303
304 static struct bus_ops pshot_bus_ops = {
305 BUSO_REV, /* busops_rev */
306 nullbusmap, /* bus_map */
307 NULL, /* bus_get_intrspec */
308 NULL, /* bus_add_interspec */
309 NULL, /* bus_remove_interspec */
310 i_ddi_map_fault, /* bus_map_fault */
311 NULL, /* bus_dma_map */
312 ddi_dma_allochdl, /* bus_dma_allochdl */
313 ddi_dma_freehdl, /* bus_dma_freehdl */
314 ddi_dma_bindhdl, /* bus_dma_bindhdl */
315 ddi_dma_unbindhdl, /* bus_dma_unbindhdl */
316 ddi_dma_flush, /* bus_dma_flush */
317 ddi_dma_win, /* bus_dma_win */
318 ddi_dma_mctl, /* bus_dma_ctl */
319 pshot_ctl, /* bus_ctl */
320 ddi_bus_prop_op, /* bus_prop_op */
321 pshot_get_eventcookie, /* bus_get_eventcookie */
322 pshot_add_eventcall, /* bus_add_eventcall */
323 pshot_remove_eventcall, /* bus_remove_event */
324 pshot_post_event, /* bus_post_event */
325 NULL, /* bus_intr_ctl */
326 pshot_bus_config, /* bus_config */
327 pshot_bus_unconfig, /* bus_unconfig */
328 NULL, /* bus_fm_init */
329 NULL, /* bus_fm_fini */
330 NULL, /* bus_fm_access_enter */
331 NULL, /* bus_fm_access_exit */
332 pshot_bus_power, /* bus_power */
333 pshot_bus_introp /* bus_intr_op */
334 };
335
336 static struct cb_ops pshot_cb_ops = {
337 pshot_open, /* open */
338 pshot_close, /* close */
339 nodev, /* strategy */
340 nodev, /* print */
341 nodev, /* dump */
342 nodev, /* read */
343 nodev, /* write */
344 pshot_ioctl, /* ioctl */
345 nodev, /* devmap */
346 nodev, /* mmap */
347 nodev, /* segmap */
348 nochpoll, /* poll */
349 ddi_prop_op, /* prop_op */
350 NULL, /* streamtab */
351 D_NEW | D_MP | D_HOTPLUG, /* flags */
352 CB_REV, /* cb_rev */
353 nodev, /* aread */
354 nodev, /* awrite */
355 };
356
357 static struct dev_ops pshot_ops = {
358 DEVO_REV, /* devo_rev, */
359 0, /* refcnt */
360 pshot_info, /* getinfo */
361 nulldev, /* identify */
362 pshot_probe, /* probe */
363 pshot_attach, /* attach */
364 pshot_detach, /* detach */
365 nodev, /* reset */
366 &pshot_cb_ops, /* driver operations */
367 &pshot_bus_ops, /* bus operations */
368 pshot_power, /* power */
369 ddi_quiesce_not_supported, /* devo_quiesce */
370
371 };
372
373
374 /*
375 * Module linkage information for the kernel.
376 */
377 static struct modldrv modldrv = {
378 &mod_driverops,
379 "pshotnex",
380 &pshot_ops,
381 };
382
383 static struct modlinkage modlinkage = {
384 MODREV_1, &modldrv, NULL
385 };
386
387
388 /*
389 * pshot_devices is set up on the first attach and destroyed on fini
390 *
391 * therefore PSHOT_PROP_DEV* properties may be set just for the root device,
392 * instead of being set globably, in pshot.conf by specifying the properties
393 * on a single line in the form:
394 * name="pshot" parent="/" <dev props ..>
395 * to unclutter a device tree snapshot.
396 * this of course produces a long single line that may wrap around several
397 * times on screen
398 */
399
400 int
401 _init(void)
402 {
403 int rv;
404
405 rv = ddi_soft_state_init(&pshot_softstatep, sizeof (pshot_t), 0);
406
407 if (rv != DDI_SUCCESS)
408 return (rv);
409
410 mutex_init(&pshot_devices_lock, NULL, MUTEX_DRIVER, NULL);
411 pshot_devices = NULL;
412 pshot_devices_len = 0;
413
414 if ((rv = mod_install(&modlinkage)) != 0) {
415 ddi_soft_state_fini(&pshot_softstatep);
416 mutex_destroy(&pshot_devices_lock);
417 }
418 return (rv);
419 }
420
421 int
422 _fini(void)
423 {
424 int rv;
425
426 if ((rv = mod_remove(&modlinkage)) != 0)
427 return (rv);
428
429 ddi_soft_state_fini(&pshot_softstatep);
430 mutex_destroy(&pshot_devices_lock);
431 if (pshot_devices)
432 pshot_devices_free(pshot_devices, pshot_devices_len);
433 return (0);
434 }
435
436 int
437 _info(struct modinfo *modinfop)
438 {
439 return (mod_info(&modlinkage, modinfop));
440 }
441
442
443 /*ARGSUSED*/
444 static int
445 pshot_probe(dev_info_t *devi)
446 {
447 int instance = ddi_get_instance(devi);
448 char *bus_addr;
449
450 /*
451 * Hook for tests to force probe fail
452 */
453 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 0, "bus-addr",
454 &bus_addr) == DDI_PROP_SUCCESS) {
455 if (strncmp(bus_addr, "failprobe", 9) == 0) {
456 if (pshot_debug)
457 cmn_err(CE_CONT, "pshot%d: "
458 "%s forced probe failure\n",
459 instance, bus_addr);
460 ddi_prop_free(bus_addr);
461 return (DDI_PROBE_FAILURE);
462 }
463 ddi_prop_free(bus_addr);
464 }
465
466 return (DDI_PROBE_SUCCESS);
467 }
468
469
470 /*ARGSUSED*/
471 static int
472 pshot_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
473 {
474 int instance;
475 minor_t minor;
476 pshot_t *pshot;
477
478 minor = getminor((dev_t)arg);
479 instance = pshot_minor_decode_inst(minor);
480 switch (infocmd) {
481 case DDI_INFO_DEVT2DEVINFO:
482 pshot = ddi_get_soft_state(pshot_softstatep, instance);
483 if (pshot == NULL) {
484 cmn_err(CE_WARN, "pshot_info: get soft state failed "
485 "on minor %u, instance %d", minor, instance);
486 return (DDI_FAILURE);
487 }
488 *result = (void *)pshot->dip;
489 break;
490 case DDI_INFO_DEVT2INSTANCE:
491 *result = (void *)(uintptr_t)instance;
492 break;
493 default:
494 cmn_err(CE_WARN, "pshot_info: unrecognized cmd 0x%x on "
495 "minor %u, instance %d", infocmd, minor, instance);
496 return (DDI_FAILURE);
497 }
498
499 return (DDI_SUCCESS);
500 }
501
502
503 static int
504 pshot_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
505 {
506 int instance = ddi_get_instance(devi);
507 pshot_t *pshot;
508 int rval, i;
509 int prop_flags = DDI_PROP_DONTPASS | DDI_PROP_NOTPROM;
510 char *bus_addr;
511 char *pm_comp[] = {
512 "NAME=bus",
513 "0=B3",
514 "1=B2",
515 "2=B1",
516 "3=B0"};
517 char *pm_hw_state = {"needs-suspend-resume"};
518
519 pshot_prop_autoattach = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
520 prop_flags, "autoattach", 0);
521
522 switch (cmd) {
523
524 case DDI_ATTACH:
525 if (pshot_debug)
526 cmn_err(CE_CONT, "attach: %s%d/pshot%d\n",
527 ddi_get_name(ddi_get_parent(devi)),
528 ddi_get_instance(ddi_get_parent(devi)),
529 instance);
530
531 /*
532 * Hook for tests to force attach fail
533 */
534 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 0, "bus-addr",
535 &bus_addr) == DDI_PROP_SUCCESS) && bus_addr != NULL) {
536 if (strncmp(bus_addr, "failattach", 10) == 0) {
537 if (pshot_debug)
538 cmn_err(CE_CONT, "pshot%d: "
539 "%s forced attach failure\n",
540 instance, bus_addr);
541 ddi_prop_free(bus_addr);
542 return (DDI_FAILURE);
543 }
544 ddi_prop_free(bus_addr);
545 }
546
547 /*
548 * minor nodes setup
549 */
550 if (ddi_soft_state_zalloc(pshot_softstatep, instance) !=
551 DDI_SUCCESS) {
552 return (DDI_FAILURE);
553 }
554 pshot = ddi_get_soft_state(pshot_softstatep, instance);
555 pshot->dip = devi;
556 pshot->instance = instance;
557 mutex_init(&pshot->lock, NULL, MUTEX_DRIVER, NULL);
558
559 /* set each minor, then create on dip all together */
560
561 i = PSHOT_NODENUM_DEVCTL;
562 pshot->nodes[i].pshot = pshot;
563 pshot->nodes[i].minor = pshot_minor_encode(instance, i);
564 (void) strncpy(pshot->nodes[i].name, PSHOT_NODENAME_DEVCTL,
565 PSHOT_MAX_MINOR_NAMELEN);
566
567 i = PSHOT_NODENUM_TESTCTL;
568 pshot->nodes[i].pshot = pshot;
569 pshot->nodes[i].minor = pshot_minor_encode(instance, i);
570 (void) strncpy(pshot->nodes[i].name, PSHOT_NODENAME_TESTCTL,
571 PSHOT_MAX_MINOR_NAMELEN);
572
573 /* this assumes contiguous a filling */
574 for (i = 0; i <= PSHOT_MAX_NODENUM; i++) {
575 if (ddi_create_minor_node(devi, pshot->nodes[i].name,
576 S_IFCHR, pshot->nodes[i].minor, DDI_NT_NEXUS, 0) !=
577 DDI_SUCCESS) {
578 cmn_err(CE_WARN, "attach: cannot create "
579 "minor %s", pshot->nodes[i].name);
580 goto FAIL_ATTACH;
581 }
582 }
583
584 /*
585 * pshot_devices setup
586 */
587 if (pshot_devices_setup(devi)) {
588 cmn_err(CE_WARN, "attach: pshot devices setup "
589 "failed");
590 goto FAIL_ATTACH;
591 }
592
593 /*
594 * events setup
595 */
596 for (i = 0; i < PSHOT_N_DDI_EVENTS; i++) {
597 rval = ddi_get_eventcookie(devi,
598 pshot_register_events[i].event_name,
599 &pshot_register_events[i].event_cookie);
600
601 if (pshot_debug)
602 cmn_err(CE_CONT, "pshot%d: event=%s:"
603 "ddi_get_eventcookie rval=%d\n",
604 instance,
605 pshot_register_events[i].event_name, rval);
606
607 if (rval == DDI_SUCCESS) {
608 rval = ddi_add_event_handler(devi,
609 pshot_register_events[i].event_cookie,
610 pshot_register_events[i].event_callback,
611 (void *)pshot,
612 &pshot->callback_cache[i]);
613
614 if (pshot_debug)
615 cmn_err(CE_CONT, "pshot%d: event=%s: "
616 "ddi_add_event_handler rval=%d\n",
617 instance,
618 pshot_register_events[i].event_name,
619 rval);
620 }
621 }
622
623 #ifdef DEBUG
624 if (pshot_event_test_enable) {
625 pshot_event_test((void *)pshot);
626 (void) timeout(pshot_event_test_post_one, (void *)pshot,
627 instance * drv_usectohz(60000000));
628 }
629 #endif
630
631 /*
632 * allocate an ndi event handle
633 */
634 if (ndi_event_alloc_hdl(devi, NULL, &pshot->ndi_event_hdl,
635 NDI_SLEEP) != NDI_SUCCESS) {
636 goto FAIL_ATTACH;
637 }
638
639 pshot->ndi_events.ndi_events_version = NDI_EVENTS_REV1;
640 pshot->ndi_events.ndi_n_events = PSHOT_N_NDI_EVENTS;
641 pshot->ndi_events.ndi_event_defs = pshot_ndi_event_defs;
642
643 if (ndi_event_bind_set(pshot->ndi_event_hdl, &pshot->ndi_events,
644 NDI_SLEEP) != NDI_SUCCESS) {
645 cmn_err(CE_CONT, "pshot%d bind set failed\n",
646 instance);
647 }
648
649 /*
650 * setup a test for nexus auto-attach iff we are
651 * a second level pshot node (parent == /SUNW,pshot)
652 * enable by setting "autoattach=1" in pshot.conf
653 */
654 if ((PARENT_IS_PSHOT(devi)) && (pshot_prop_autoattach != 0) &&
655 (ddi_get_instance(ddi_get_parent(devi))) == 0)
656 pshot_setup_autoattach(devi);
657
658 /*
659 * initialize internal state to idle: busy = 0,
660 * power level = -1
661 */
662 mutex_enter(&pshot->lock);
663 pshot->busy = 0;
664 pshot->busy_ioctl = 0;
665 pshot->level = -1;
666 pshot->state &= ~STRICT_PARENT;
667 pshot->state |= PM_SUPPORTED;
668 mutex_exit(&pshot->lock);
669
670 /*
671 * Create the "pm-want-child-notification?" property
672 * for the root node /devices/pshot
673 */
674 if (instance == 0) {
675 if (pshot_debug) {
676 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:\n\t"
677 " create the"
678 " \"pm-want-child-notification?\" property"
679 " for the root node\n", instance);
680 }
681 if (ddi_prop_create(DDI_DEV_T_NONE, devi, 0,
682 "pm-want-child-notification?", NULL, 0)
683 != DDI_PROP_SUCCESS) {
684 cmn_err(CE_WARN, "%s%d:\n\t"
685 " unable to create the"
686 " \"pm-want-child-notification?\""
687 " property", ddi_get_name(devi),
688 ddi_get_instance(devi));
689
690 goto FAIL_ATTACH;
691 }
692 }
693
694 /*
695 * Check if the pm-want-child-notification? property was
696 * created in pshot_bus_config_setup_nexus() by the parent.
697 * Set the STRICT_PARENT flag if not.
698 */
699 if (ddi_prop_exists(DDI_DEV_T_ANY, devi,
700 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
701 "pm-want-child-notification?") != 1) {
702 if (pshot_debug) {
703 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:"
704 " STRICT PARENT\n", instance);
705 }
706 mutex_enter(&pshot->lock);
707 pshot->state |= STRICT_PARENT;
708 mutex_exit(&pshot->lock);
709 } else {
710 if (pshot_debug) {
711 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:"
712 " INVOLVED PARENT\n", instance);
713 }
714 mutex_enter(&pshot->lock);
715 pshot->state &= ~STRICT_PARENT;
716 mutex_exit(&pshot->lock);
717 }
718
719 /*
720 * create the pm-components property: one component
721 * with 4 power levels.
722 * - skip for pshot@XXX,nopm and pshot@XXX,nopm_strict:
723 * "no-pm-components" property
724 */
725 if (ddi_prop_exists(DDI_DEV_T_ANY, devi,
726 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
727 "no-pm-components") == 0) {
728 if (pshot_debug) {
729 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:"
730 " create the \"pm_components\" property\n",
731 instance);
732 }
733 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
734 "pm-components", pm_comp, 5) != DDI_PROP_SUCCESS) {
735 cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t"
736 " unable to create the \"pm-components\""
737 " property", ddi_get_name(devi),
738 ddi_get_instance(devi));
739
740 goto FAIL_ATTACH;
741 }
742 } else {
743 if (pshot_debug) {
744 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:"
745 " NO-PM_COMPONENTS PARENT\n", instance);
746 }
747 mutex_enter(&pshot->lock);
748 pshot->state &= ~PM_SUPPORTED;
749 mutex_exit(&pshot->lock);
750 }
751
752 /*
753 * create the property needed to get DDI_SUSPEND
754 * and DDI_RESUME calls
755 */
756 if (pshot_debug) {
757 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:"
758 " create pm-hardware-state property\n",
759 instance);
760 }
761 if (ddi_prop_update_string(DDI_DEV_T_NONE, devi,
762 "pm-hardware-state", pm_hw_state) != DDI_PROP_SUCCESS) {
763 cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t"
764 " unable to create the \"pm-hardware-state\""
765 " property", ddi_get_name(devi),
766 ddi_get_instance(devi));
767
768 goto FAIL_ATTACH;
769 }
770
771 /*
772 * set power level to max via pm_raise_power(),
773 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
774 */
775 if (pshot->state & PM_SUPPORTED) {
776 if (pshot_debug) {
777 cmn_err(CE_CONT, "pshot%d: DDI_ATTACH:"
778 " raise power to MAXPWR\n", instance);
779 }
780 if (pm_raise_power(pshot->dip, 0, MAXPWR) !=
781 DDI_SUCCESS) {
782 cmn_err(CE_WARN, "%s%d: DDI_ATTACH:"
783 " pm_raise_power failed",
784 ddi_get_name(devi),
785 ddi_get_instance(devi));
786
787 goto FAIL_ATTACH;
788
789 }
790 }
791
792 if (pshot_log)
793 cmn_err(CE_CONT, "pshot%d attached\n", instance);
794 ddi_report_dev(devi);
795
796 return (DDI_SUCCESS);
797 /*NOTREACHED*/
798 FAIL_ATTACH:
799 ddi_remove_minor_node(devi, NULL);
800 mutex_destroy(&pshot->lock);
801 ddi_soft_state_free(pshot_softstatep, instance);
802 return (DDI_FAILURE);
803
804 case DDI_RESUME:
805 if (pshot_debug) {
806 cmn_err(CE_CONT, "pshot%d: DDI_RESUME: resuming\n",
807 instance);
808 }
809 pshot = ddi_get_soft_state(pshot_softstatep, instance);
810
811 /*
812 * set power level to max via pm_raise_power(),
813 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
814 */
815 if (pshot->state & PM_SUPPORTED) {
816 if (pshot_debug) {
817 cmn_err(CE_CONT, "pshot%d: DDI_RESUME:"
818 " raise power to MAXPWR\n", instance);
819 }
820 if (pm_raise_power(pshot->dip, 0, MAXPWR) !=
821 DDI_SUCCESS) {
822 cmn_err(CE_WARN, "%s%d: DDI_RESUME:"
823 " pm_raise_power failed",
824 ddi_get_name(devi),
825 ddi_get_instance(devi));
826 }
827 }
828
829 if (pshot_debug) {
830 cmn_err(CE_CONT, "pshot%d: DDI_RESUME: resumed\n",
831 instance);
832 }
833 return (DDI_SUCCESS);
834
835 default:
836 return (DDI_FAILURE);
837 }
838 }
839
840 static int
841 pshot_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
842 {
843 int instance = ddi_get_instance(devi);
844 int i, rval;
845 pshot_t *pshot = ddi_get_soft_state(pshot_softstatep, instance);
846 int level_tmp;
847
848 if (pshot == NULL)
849 return (DDI_FAILURE);
850
851 switch (cmd) {
852
853 case DDI_DETACH:
854 if (pshot_debug)
855 cmn_err(CE_CONT, "pshot%d: DDI_DETACH\n", instance);
856 /*
857 * power off component 0
858 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
859 */
860 if (pshot->state & PM_SUPPORTED) {
861 if (pshot_debug) {
862 cmn_err(CE_CONT, "pshot%d: DDI_DETACH:"
863 " power off\n", instance);
864 }
865 if (pm_lower_power(pshot->dip, 0, 0) != DDI_SUCCESS) {
866 cmn_err(CE_WARN, "%s%d: DDI_DETACH:\n\t"
867 "pm_lower_power failed for comp 0 to"
868 " level 0", ddi_get_name(devi),
869 ddi_get_instance(devi));
870
871 return (DDI_FAILURE);
872 }
873
874 /*
875 * Check if the power level is actually OFF.
876 * Issue pm_power_has_changed if not.
877 */
878 mutex_enter(&pshot->lock);
879 if (pshot->level != 0) {
880 if (pshot_debug) {
881 cmn_err(CE_NOTE, "pshot%d:"
882 " DDI_DETACH: power off via"
883 " pm_power_has_changed instead\n",
884 instance);
885 }
886 level_tmp = pshot->level;
887 pshot->level = 0;
888 if (pm_power_has_changed(pshot->dip, 0, 0) !=
889 DDI_SUCCESS) {
890 if (pshot_debug) {
891 cmn_err(CE_NOTE, "pshot%d:"
892 " DDI_DETACH:"
893 " pm_power_has_changed"
894 " failed\n", instance);
895 }
896 pshot->level = level_tmp;
897 mutex_exit(&pshot->lock);
898
899 return (DDI_FAILURE);
900 }
901 }
902 mutex_exit(&pshot->lock);
903 }
904
905 for (i = 0; i < PSHOT_N_DDI_EVENTS; i++) {
906 if (pshot->callback_cache[i] != NULL) {
907 rval = ddi_remove_event_handler(
908 pshot->callback_cache[i]);
909 ASSERT(rval == DDI_SUCCESS);
910 }
911 }
912
913 #ifdef DEBUG
914 for (i = 0; i < PSHOT_N_TEST_EVENTS; i++) {
915 if (pshot->test_callback_cache[i] != NULL) {
916 rval = ddi_remove_event_handler(
917 pshot->test_callback_cache[i]);
918 ASSERT(rval == DDI_SUCCESS);
919 }
920 }
921 #endif
922 rval = ndi_event_free_hdl(pshot->ndi_event_hdl);
923 ASSERT(rval == DDI_SUCCESS);
924
925 if (pshot_log)
926 cmn_err(CE_CONT, "pshot%d detached\n", instance);
927
928 ddi_remove_minor_node(devi, NULL);
929 mutex_destroy(&pshot->lock);
930 ddi_soft_state_free(pshot_softstatep, instance);
931 break;
932
933 case DDI_SUSPEND:
934 if (pshot_debug)
935 cmn_err(CE_CONT, "pshot%d: DDI_SUSPEND\n", instance);
936 /*
937 * fail the suspend if FAIL_SUSPEND_FLAG is set.
938 * clear the FAIL_SUSPEND_FLAG flag
939 */
940 mutex_enter(&pshot->lock);
941 if (pshot->state & FAIL_SUSPEND_FLAG) {
942 if (pshot_debug) {
943 cmn_err(CE_CONT, "pshot%d:"
944 " FAIL_SUSPEND_FLAG set, fail suspend\n",
945 ddi_get_instance(devi));
946 }
947 pshot->state &= ~FAIL_SUSPEND_FLAG;
948 rval = DDI_FAILURE;
949 } else {
950 rval = DDI_SUCCESS;
951 }
952 mutex_exit(&pshot->lock);
953
954 /*
955 * power OFF via pm_power_has_changed
956 */
957 mutex_enter(&pshot->lock);
958 if (pshot->state & PM_SUPPORTED) {
959 if (pshot_debug) {
960 cmn_err(CE_CONT, "pshot%d: DDI_SUSPEND:"
961 " power off via pm_power_has_changed\n",
962 instance);
963 }
964 level_tmp = pshot->level;
965 pshot->level = 0;
966 if (pm_power_has_changed(pshot->dip, 0, 0) !=
967 DDI_SUCCESS) {
968 if (pshot_debug) {
969 cmn_err(CE_NOTE, "pshot%d:"
970 " DDI_SUSPEND:"
971 " pm_power_has_changed failed\n",
972 instance);
973 }
974 pshot->level = level_tmp;
975 rval = DDI_FAILURE;
976 }
977 }
978 mutex_exit(&pshot->lock);
979 return (rval);
980
981 default:
982 break;
983 }
984
985 return (DDI_SUCCESS);
986 }
987
988
989 /*
990 * returns number of bits to represent <val>
991 */
992 static size_t
993 pshot_numbits(size_t val)
994 {
995 size_t bitcnt;
996
997 if (val == 0)
998 return (0);
999 for (bitcnt = 1; 1 << bitcnt < val; bitcnt++)
1000 ;
1001 return (bitcnt);
1002 }
1003
1004 /*
1005 * returns a minor number encoded with instance <inst> and an index <nodenum>
1006 * that identifies the minor node for this instance
1007 */
1008 static minor_t
1009 pshot_minor_encode(int inst, minor_t nodenum)
1010 {
1011 return (((minor_t)inst << PSHOT_NODENUM_BITS()) |
1012 (((1 << PSHOT_NODENUM_BITS()) - 1) & nodenum));
1013 }
1014
1015 /*
1016 * returns instance of <minor>
1017 */
1018 static int
1019 pshot_minor_decode_inst(minor_t minor)
1020 {
1021 return (minor >> PSHOT_NODENUM_BITS());
1022 }
1023
1024 /*
1025 * returns node number indexing a minor node for the instance in <minor>
1026 */
1027 static minor_t
1028 pshot_minor_decode_nodenum(minor_t minor)
1029 {
1030 return (minor & ((1 << PSHOT_NODENUM_BITS()) - 1));
1031 }
1032
1033
1034 /*
1035 * pshot_bus_introp: pshot convert an interrupt number to an
1036 * interrupt. NO OP for pseudo drivers.
1037 */
1038 /*ARGSUSED*/
1039 static int
1040 pshot_bus_introp(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
1041 ddi_intr_handle_impl_t *hdlp, void *result)
1042 {
1043 return (DDI_FAILURE);
1044 }
1045 static int
1046 pshot_ctl(dev_info_t *dip, dev_info_t *rdip,
1047 ddi_ctl_enum_t ctlop, void *arg, void *result)
1048 {
1049 int instance;
1050 pshot_t *pshot;
1051 char *childname;
1052 int childinstance;
1053 char *name;
1054 int circ;
1055 struct attachspec *as;
1056 struct detachspec *ds;
1057 int rval = DDI_SUCCESS;
1058 int no_pm_components_child;
1059
1060 name = ddi_get_name(dip);
1061 instance = ddi_get_instance(dip);
1062 pshot = ddi_get_soft_state(pshot_softstatep, instance);
1063 if (pshot == NULL) {
1064 return (ENXIO);
1065 }
1066
1067 switch (ctlop) {
1068 case DDI_CTLOPS_REPORTDEV:
1069 if (rdip == (dev_info_t *)0)
1070 return (DDI_FAILURE);
1071 cmn_err(CE_CONT, "?pshot-device: %s%d\n",
1072 ddi_get_name(rdip), ddi_get_instance(rdip));
1073 return (DDI_SUCCESS);
1074
1075 case DDI_CTLOPS_INITCHILD:
1076 {
1077 dev_info_t *child = (dev_info_t *)arg;
1078
1079 if (pshot_debug) {
1080 cmn_err(CE_CONT, "initchild %s%d/%s%d state 0x%x\n",
1081 ddi_get_name(dip), ddi_get_instance(dip),
1082 ddi_node_name(child), ddi_get_instance(child),
1083 DEVI(child)->devi_state);
1084 }
1085
1086 return (pshot_initchild(dip, child));
1087 }
1088
1089 case DDI_CTLOPS_UNINITCHILD:
1090 {
1091 dev_info_t *child = (dev_info_t *)arg;
1092
1093 if (pshot_debug) {
1094 cmn_err(CE_CONT, "uninitchild %s%d/%s%d state 0x%x\n",
1095 ddi_get_name(dip), ddi_get_instance(dip),
1096 ddi_node_name(child), ddi_get_instance(child),
1097 DEVI(child)->devi_state);
1098 }
1099
1100 return (pshot_uninitchild(dip, child));
1101 }
1102
1103 case DDI_CTLOPS_DMAPMAPC:
1104 case DDI_CTLOPS_REPORTINT:
1105 case DDI_CTLOPS_REGSIZE:
1106 case DDI_CTLOPS_NREGS:
1107 case DDI_CTLOPS_SIDDEV:
1108 case DDI_CTLOPS_SLAVEONLY:
1109 case DDI_CTLOPS_AFFINITY:
1110 case DDI_CTLOPS_POKE:
1111 case DDI_CTLOPS_PEEK:
1112 /*
1113 * These ops correspond to functions that "shouldn't" be called
1114 * by a pseudo driver. So we whine when we're called.
1115 */
1116 cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d\n",
1117 ddi_get_name(dip), ddi_get_instance(dip),
1118 ctlop, ddi_get_name(rdip), ddi_get_instance(rdip));
1119 return (DDI_FAILURE);
1120
1121 case DDI_CTLOPS_ATTACH:
1122 {
1123 dev_info_t *child = (dev_info_t *)rdip;
1124 childname = ddi_node_name(child);
1125 childinstance = ddi_get_instance(child);
1126 as = (struct attachspec *)arg;
1127
1128 no_pm_components_child = 0;
1129 if (ddi_prop_exists(DDI_DEV_T_ANY, child,
1130 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
1131 "no-pm-components") == 1) {
1132 no_pm_components_child = 1;
1133 }
1134 if (pshot_debug) {
1135 cmn_err(CE_CONT, "%s%d: ctl_attach %s%d [%d]\n",
1136 name, instance, childname, childinstance,
1137 no_pm_components_child);
1138 }
1139
1140 ndi_devi_enter(dip, &circ);
1141
1142 switch (as->when) {
1143 case DDI_PRE:
1144 /*
1145 * Mark nexus busy before a child attaches.
1146 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm
1147 * - pshot@XXX,nopm_strict)
1148 */
1149 if (!(pshot->state & PM_SUPPORTED))
1150 break;
1151 mutex_enter(&pshot->lock);
1152 ++(pshot->busy);
1153 if (pshot_debug_busy) {
1154 cmn_err(CE_CONT, "%s%d:"
1155 " ctl_attach_pre: busy for %s%d:"
1156 " busy = %d\n", name, instance,
1157 childname, childinstance,
1158 pshot->busy);
1159 }
1160 mutex_exit(&pshot->lock);
1161 rval = pm_busy_component(dip, 0);
1162 ASSERT(rval == DDI_SUCCESS);
1163 break;
1164 case DDI_POST:
1165 /*
1166 * Mark nexus idle after a child attaches.
1167 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm).
1168 * - also skip if this is not a stict parent and
1169 * - the child is a tape device or a no-pm-components
1170 * - nexus node.
1171 */
1172 if (!(pshot->state & PM_SUPPORTED) ||
1173 (strcmp(childname, "tape") == 0 &&
1174 !(pshot->state & STRICT_PARENT)) ||
1175 no_pm_components_child)
1176 break;
1177 mutex_enter(&pshot->lock);
1178 ASSERT(pshot->busy > 0);
1179 --pshot->busy;
1180 if (pshot_debug_busy) {
1181 cmn_err(CE_CONT, "%s%d:"
1182 " ctl_attach_post: idle for %s%d:"
1183 " busy = %d\n", name, instance,
1184 childname, childinstance,
1185 pshot->busy);
1186 }
1187 mutex_exit(&pshot->lock);
1188 rval = pm_idle_component(dip, 0);
1189 ASSERT(rval == DDI_SUCCESS);
1190 break;
1191 }
1192
1193 ndi_devi_exit(dip, circ);
1194
1195 return (rval);
1196 }
1197 case DDI_CTLOPS_DETACH:
1198 {
1199 dev_info_t *child = (dev_info_t *)rdip;
1200 childname = ddi_node_name(child);
1201 childinstance = ddi_get_instance(child);
1202 ds = (struct detachspec *)arg;
1203
1204 no_pm_components_child = 0;
1205 if (ddi_prop_exists(DDI_DEV_T_ANY, child,
1206 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
1207 "no-pm-components") == 1) {
1208 no_pm_components_child = 1;
1209 }
1210 if (pshot_debug) {
1211 cmn_err(CE_CONT,
1212 "%s%d: ctl_detach %s%d [%d]\n",
1213 name, instance, childname, childinstance,
1214 no_pm_components_child);
1215 }
1216
1217 ndi_devi_enter(dip, &circ);
1218
1219 switch (ds->when) {
1220 case DDI_PRE:
1221 /*
1222 * Mark nexus busy before a child detaches.
1223 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm
1224 * - pshot@XXX,nopm_strict), or if the child is a
1225 * - no-pm-components nexus node.
1226 */
1227 if (!(pshot->state & PM_SUPPORTED) ||
1228 (strcmp(childname, "tape") == 0 &&
1229 !(pshot->state & STRICT_PARENT)) ||
1230 no_pm_components_child)
1231 break;
1232 mutex_enter(&pshot->lock);
1233 ++(pshot->busy);
1234 if (pshot_debug_busy) {
1235 cmn_err(CE_CONT, "%s%d:"
1236 " ctl_detach_pre: busy for %s%d:"
1237 " busy = %d\n", name, instance,
1238 childname, childinstance,
1239 pshot->busy);
1240 }
1241 mutex_exit(&pshot->lock);
1242 rval = pm_busy_component(dip, 0);
1243 ASSERT(rval == DDI_SUCCESS);
1244
1245 break;
1246 case DDI_POST:
1247 /*
1248 * Mark nexus idle after a child detaches.
1249 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
1250 */
1251 if (!(pshot->state & PM_SUPPORTED))
1252 break;
1253 mutex_enter(&pshot->lock);
1254 ASSERT(pshot->busy > 0);
1255 --pshot->busy;
1256 if (pshot_debug_busy) {
1257 cmn_err(CE_CONT, "%s%d:"
1258 " ctl_detach_post: idle for %s%d:"
1259 " busy = %d\n", name, instance,
1260 childname, childinstance,
1261 pshot->busy);
1262 }
1263 mutex_exit(&pshot->lock);
1264 rval = pm_idle_component(dip, 0);
1265 ASSERT(rval == DDI_SUCCESS);
1266
1267 /*
1268 * Mark the driver idle if the NO_INVOL_FLAG
1269 * is set. This is needed to make sure the
1270 * parent is idle after the child detaches
1271 * without calling pm_lower_power().
1272 * Clear the NO_INVOL_FLAG.
1273 * - also mark idle if a tape device has detached
1274 */
1275 if (!(pshot->state & NO_INVOL_FLAG))
1276 break;
1277 mutex_enter(&pshot->lock);
1278 ASSERT(pshot->busy > 0);
1279 --pshot->busy;
1280 if (pshot_debug_busy) {
1281 cmn_err(CE_CONT, "%s%d:"
1282 " ctl_detach_post: NO_INVOL:"
1283 " idle for %s%d: busy = %d\n",
1284 name, instance, childname,
1285 childinstance, pshot->busy);
1286 }
1287 pshot->state &= ~NO_INVOL_FLAG;
1288 mutex_exit(&pshot->lock);
1289 rval = pm_idle_component(dip, 0);
1290 ASSERT(rval == DDI_SUCCESS);
1291
1292 break;
1293 }
1294
1295 ndi_devi_exit(dip, circ);
1296
1297 return (rval);
1298 }
1299
1300 case DDI_CTLOPS_BTOP:
1301 case DDI_CTLOPS_BTOPR:
1302 case DDI_CTLOPS_DVMAPAGESIZE:
1303 case DDI_CTLOPS_IOMIN:
1304 case DDI_CTLOPS_PTOB:
1305 default:
1306 /*
1307 * The ops that we pass up (default). We pass up memory
1308 * allocation oriented ops that we receive - these may be
1309 * associated with pseudo HBA drivers below us with target
1310 * drivers below them that use ddi memory allocation
1311 * interfaces like scsi_alloc_consistent_buf.
1312 */
1313 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
1314 }
1315 }
1316
1317 /*ARGSUSED0*/
1318 static int
1319 pshot_power(dev_info_t *dip, int cmpt, int level)
1320 {
1321 pshot_t *pshot;
1322 int instance = ddi_get_instance(dip);
1323 char *name = ddi_node_name(dip);
1324 int circ;
1325 int rv;
1326
1327 pshot = ddi_get_soft_state(pshot_softstatep, instance);
1328 if (pshot == NULL) {
1329
1330 return (DDI_FAILURE);
1331 }
1332
1333 ndi_devi_enter(dip, &circ);
1334
1335 /*
1336 * set POWER_FLAG when power() is called.
1337 * ioctl(DEVCT_PM_POWER) is a clear on read call.
1338 */
1339 mutex_enter(&pshot->lock);
1340 pshot->state |= POWER_FLAG;
1341 /*
1342 * refuse to power OFF if the component is busy
1343 */
1344 if (pshot->busy != 0 && pshot->level > level) {
1345 cmn_err(CE_WARN, "%s%d: power: REFUSING POWER LEVEL CHANGE"
1346 " (%d->%d), DEVICE NOT IDLE: busy = %d",
1347 name, instance, pshot->level, level, pshot->busy);
1348 rv = DDI_FAILURE;
1349 } else {
1350 if (pshot_debug) {
1351 cmn_err(CE_CONT, "%s%d: power: comp %d (%d->%d)\n",
1352 name, instance, cmpt, pshot->level, level);
1353 }
1354 pshot->level = level;
1355 rv = DDI_SUCCESS;
1356 }
1357 mutex_exit(&pshot->lock);
1358
1359 ndi_devi_exit(dip, circ);
1360
1361 return (rv);
1362 }
1363
1364 /*ARGSUSED0*/
1365 static int
1366 pshot_bus_power(dev_info_t *dip, void *impl_arg, pm_bus_power_op_t op,
1367 void *arg, void *result)
1368
1369 {
1370 int ret;
1371 int instance = ddi_get_instance(dip);
1372 char *name = ddi_node_name(dip);
1373 pshot_t *pshot;
1374 pm_bp_child_pwrchg_t *bpc;
1375 pm_bp_nexus_pwrup_t bpn;
1376 pm_bp_has_changed_t *bphc;
1377 int pwrup_res;
1378 int ret_failed = 0;
1379 int pwrup_res_failed = 0;
1380
1381 pshot = ddi_get_soft_state(pshot_softstatep, instance);
1382 if (pshot == NULL) {
1383
1384 return (DDI_FAILURE);
1385 }
1386
1387 switch (op) {
1388 case BUS_POWER_PRE_NOTIFICATION:
1389 bpc = (pm_bp_child_pwrchg_t *)arg;
1390 if (pshot_debug) {
1391 cmn_err(CE_CONT, "%s%d: pre_bus_power:"
1392 " %s%d comp %d (%d->%d)\n",
1393 name, instance, ddi_node_name(bpc->bpc_dip),
1394 ddi_get_instance(bpc->bpc_dip),
1395 bpc->bpc_comp, bpc->bpc_olevel,
1396 bpc->bpc_nlevel);
1397 }
1398
1399 /*
1400 * mark parent busy if old_level is either -1 or 0,
1401 * and new level is == MAXPWR
1402 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
1403 */
1404 if ((bpc->bpc_comp == 0 && bpc->bpc_nlevel == MAXPWR &&
1405 bpc->bpc_olevel <= 0) && (pshot->state & PM_SUPPORTED)) {
1406 mutex_enter(&pshot->lock);
1407 ++(pshot->busy);
1408 if (pshot_debug_busy) {
1409 cmn_err(CE_CONT,
1410 "%s%d: pre_bus_power:"
1411 " busy parent for %s%d (%d->%d): "
1412 " busy = %d\n",
1413 name, instance,
1414 ddi_node_name(bpc->bpc_dip),
1415 ddi_get_instance(bpc->bpc_dip),
1416 bpc->bpc_olevel, bpc->bpc_nlevel,
1417 pshot->busy);
1418 }
1419 mutex_exit(&pshot->lock);
1420 ret = pm_busy_component(dip, 0);
1421 ASSERT(ret == DDI_SUCCESS);
1422 }
1423
1424 /*
1425 * if new_level > 0, power up parent, if not already at
1426 * MAXPWR, via pm_busop_bus_power
1427 * - skip for the no-pm nexus (pshot@XXX,nopm)
1428 */
1429 if (bpc->bpc_comp == 0 && bpc->bpc_nlevel > 0 &&
1430 pshot->level < MAXPWR && (pshot->state & PM_SUPPORTED)) {
1431 /*
1432 * stuff the bpn struct
1433 */
1434 bpn.bpn_comp = 0;
1435 bpn.bpn_level = MAXPWR;
1436 bpn.bpn_private = bpc->bpc_private;
1437 bpn.bpn_dip = dip;
1438
1439 /*
1440 * ask pm to power parent up
1441 */
1442 if (pshot_debug) {
1443 cmn_err(CE_CONT, "%s%d: pre_bus_power:"
1444 " pm_busop_bus_power on parent for %s%d"
1445 " (%d->%d): enter", name, instance,
1446 ddi_node_name(bpc->bpc_dip),
1447 ddi_get_instance(bpc->bpc_dip),
1448 bpc->bpc_olevel, bpc->bpc_nlevel);
1449 }
1450 ret = pm_busop_bus_power(dip, impl_arg,
1451 BUS_POWER_NEXUS_PWRUP, (void *)&bpn,
1452 (void *)&pwrup_res);
1453
1454 /*
1455 * check the return status individually,
1456 * idle parent and exit if either failed.
1457 */
1458 if (ret != DDI_SUCCESS) {
1459 cmn_err(CE_WARN,
1460 "%s%d: pre_bus_power:"
1461 " pm_busop_bus_power FAILED (ret) FOR"
1462 " %s%d (%d->%d)",
1463 name, instance,
1464 ddi_node_name(bpc->bpc_dip),
1465 ddi_get_instance(bpc->bpc_dip),
1466 bpc->bpc_olevel, bpc->bpc_nlevel);
1467 ret_failed = 1;
1468 }
1469 if (pwrup_res != DDI_SUCCESS) {
1470 cmn_err(CE_WARN,
1471 "%s%d: pre_bus_power:"
1472 " pm_busop_bus_power FAILED (pwrup_res)"
1473 " FOR %s%d (%d->%d)",
1474 name, instance,
1475 ddi_node_name(bpc->bpc_dip),
1476 ddi_get_instance(bpc->bpc_dip),
1477 bpc->bpc_olevel, bpc->bpc_nlevel);
1478 pwrup_res_failed = 1;
1479 }
1480 if (ret_failed || pwrup_res_failed) {
1481 /*
1482 * decrement the busy count if it
1483 * had been incremented.
1484 */
1485 if ((bpc->bpc_comp == 0 &&
1486 bpc->bpc_nlevel == MAXPWR &&
1487 bpc->bpc_olevel <= 0) &&
1488 (pshot->state & PM_SUPPORTED)) {
1489 mutex_enter(&pshot->lock);
1490 ASSERT(pshot->busy > 0);
1491 --(pshot->busy);
1492 if (pshot_debug_busy) {
1493 cmn_err(CE_CONT, "%s%d:"
1494 " pm_busop_bus_power"
1495 " failed: idle parent for"
1496 " %s%d (%d->%d):"
1497 " busy = %d\n",
1498 name, instance,
1499 ddi_node_name(
1500 bpc->bpc_dip),
1501 ddi_get_instance(
1502 bpc->bpc_dip),
1503 bpc->bpc_olevel,
1504 bpc->bpc_nlevel,
1505 pshot->busy);
1506 }
1507 mutex_exit(&pshot->lock);
1508 ret = pm_idle_component(dip, 0);
1509 ASSERT(ret == DDI_SUCCESS);
1510 }
1511 return (DDI_FAILURE);
1512
1513 } else {
1514 if (pshot_debug) {
1515 cmn_err(CE_CONT,
1516 "%s%d: pre_bus_power:"
1517 " pm_busop_bus_power on parent"
1518 " for %s%d (%d->%d)\n",
1519 name, instance,
1520 ddi_node_name(bpc->bpc_dip),
1521 ddi_get_instance(bpc->bpc_dip),
1522 bpc->bpc_olevel, bpc->bpc_nlevel);
1523 }
1524 }
1525 }
1526 break;
1527
1528 case BUS_POWER_POST_NOTIFICATION:
1529 bpc = (pm_bp_child_pwrchg_t *)arg;
1530 if (pshot_debug) {
1531 cmn_err(CE_CONT, "%s%d: post_bus_power:"
1532 " %s%d comp %d (%d->%d) result %d\n",
1533 name, instance, ddi_node_name(bpc->bpc_dip),
1534 ddi_get_instance(bpc->bpc_dip),
1535 bpc->bpc_comp, bpc->bpc_olevel,
1536 bpc->bpc_nlevel, *(int *)result);
1537 }
1538
1539 /*
1540 * handle pm_busop_bus_power() failure case.
1541 * mark parent idle if had been marked busy.
1542 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
1543 */
1544 if (*(int *)result != DDI_SUCCESS) {
1545 cmn_err(CE_WARN,
1546 "pshot%d: post_bus_power_failed:"
1547 " pm_busop_bus_power FAILED FOR %s%d (%d->%d)",
1548 instance, ddi_node_name(bpc->bpc_dip),
1549 ddi_get_instance(bpc->bpc_dip),
1550 bpc->bpc_olevel, bpc->bpc_nlevel);
1551
1552 if ((bpc->bpc_comp == 0 && bpc->bpc_nlevel == MAXPWR &&
1553 bpc->bpc_olevel <= 0) &&
1554 (pshot->state & PM_SUPPORTED)) {
1555 mutex_enter(&pshot->lock);
1556 ASSERT(pshot->busy > 0);
1557 --(pshot->busy);
1558 if (pshot_debug_busy) {
1559 cmn_err(CE_CONT, "%s%d:"
1560 " post_bus_power_failed:"
1561 " idle parent for %s%d"
1562 " (%d->%d): busy = %d\n",
1563 name, instance,
1564 ddi_node_name(bpc->bpc_dip),
1565 ddi_get_instance(bpc->bpc_dip),
1566 bpc->bpc_olevel, bpc->bpc_nlevel,
1567 pshot->busy);
1568 }
1569 mutex_exit(&pshot->lock);
1570 ret = pm_idle_component(dip, 0);
1571 ASSERT(ret == DDI_SUCCESS);
1572 }
1573 }
1574
1575 /*
1576 * Mark nexus idle when a child's comp 0
1577 * is set to level 0 from level 1, 2, or 3 only.
1578 * And only if result arg == DDI_SUCCESS.
1579 * This will leave the parent busy when the child
1580 * does not call pm_lower_power() on detach after
1581 * unsetting the NO_LOWER_POWER flag.
1582 * If so, need to notify the parent to mark itself
1583 * idle anyway, else the no-involumtary-power-cycles
1584 * test cases will report false passes!
1585 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
1586 */
1587 if ((bpc->bpc_comp == 0 && bpc->bpc_nlevel == 0 &&
1588 !(bpc->bpc_olevel <= 0) &&
1589 *(int *)result == DDI_SUCCESS) &&
1590 (pshot->state & PM_SUPPORTED)) {
1591 mutex_enter(&pshot->lock);
1592 ASSERT(pshot->busy > 0);
1593 --(pshot->busy);
1594 if (pshot_debug_busy) {
1595 cmn_err(CE_CONT,
1596 "%s%d: post_bus_power:"
1597 " idle parent for %s%d (%d->%d):"
1598 " busy = %d\n", name, instance,
1599 ddi_node_name(bpc->bpc_dip),
1600 ddi_get_instance(bpc->bpc_dip),
1601 bpc->bpc_olevel, bpc->bpc_nlevel,
1602 pshot->busy);
1603 }
1604 mutex_exit(&pshot->lock);
1605 ret = pm_idle_component(dip, 0);
1606 ASSERT(ret == DDI_SUCCESS);
1607 }
1608 break;
1609
1610 case BUS_POWER_HAS_CHANGED:
1611 bphc = (pm_bp_has_changed_t *)arg;
1612 if (pshot_debug) {
1613 cmn_err(CE_CONT, "%s%d: has_changed_bus_power:"
1614 " %s%d comp %d (%d->%d) result %d\n",
1615 name, instance, ddi_node_name(bphc->bphc_dip),
1616 ddi_get_instance(bphc->bphc_dip),
1617 bphc->bphc_comp, bphc->bphc_olevel,
1618 bphc->bphc_nlevel, *(int *)result);
1619 }
1620
1621 /*
1622 * Mark nexus idle when a child's comp 0
1623 * is set to level 0 from levels 1, 2, or 3 only.
1624 *
1625 * If powering up child leaf/nexus nodes via
1626 * pm_power_has_changed() calls, first issue
1627 * DEVCTL_PM_BUSY_COMP ioctl to mark parent busy
1628 * before powering the parent up, then power up the
1629 * child node.
1630 * - skip if PM_SUPPORTED is not set (pshot@XXX,nopm)
1631 */
1632 if ((bphc->bphc_comp == 0 && bphc->bphc_nlevel == 0 &&
1633 !(bphc->bphc_olevel <= 0)) &&
1634 pshot->state & PM_SUPPORTED) {
1635 mutex_enter(&pshot->lock);
1636 ASSERT(pshot->busy > 0);
1637 --(pshot->busy);
1638 if (pshot_debug_busy) {
1639 cmn_err(CE_CONT,
1640 "%s%d: has_changed_bus_power:"
1641 " idle parent for %s%d (%d->%d):"
1642 " busy = %d\n", name, instance,
1643 ddi_node_name(bphc->bphc_dip),
1644 ddi_get_instance(bphc->bphc_dip),
1645 bphc->bphc_olevel,
1646 bphc->bphc_nlevel, pshot->busy);
1647 }
1648 mutex_exit(&pshot->lock);
1649 ret = pm_idle_component(dip, 0);
1650 ASSERT(ret == DDI_SUCCESS);
1651 }
1652 break;
1653
1654 default:
1655 return (pm_busop_bus_power(dip, impl_arg, op, arg, result));
1656
1657 }
1658
1659 return (DDI_SUCCESS);
1660 }
1661
1662 static int
1663 pshot_initchild(dev_info_t *dip, dev_info_t *child)
1664 {
1665 char name[64];
1666 char *bus_addr;
1667 char *c_nodename;
1668 int bus_id;
1669 dev_info_t *enum_child;
1670 int enum_base;
1671 int enum_extent;
1672
1673
1674 /* check for bus_enum node */
1675
1676 #ifdef NOT_USED
1677 if (impl_ddi_merge_child(child) != DDI_SUCCESS)
1678 return (DDI_FAILURE);
1679 #endif
1680
1681 enum_base = ddi_prop_get_int(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
1682 "busid_ebase", 0);
1683
1684 enum_extent = ddi_prop_get_int(DDI_DEV_T_ANY, child,
1685 DDI_PROP_DONTPASS, "busid_range", 0);
1686
1687 /*
1688 * bus enumeration node
1689 */
1690 if ((enum_base != 0) && (enum_extent != 0)) {
1691 c_nodename = ddi_node_name(child);
1692 bus_id = enum_base;
1693 for (; bus_id < enum_extent; bus_id++) {
1694 if (ndi_devi_alloc(dip, c_nodename, DEVI_PSEUDO_NODEID,
1695 &enum_child) != NDI_SUCCESS)
1696 return (DDI_FAILURE);
1697
1698 (void) sprintf(name, "%d", bus_id);
1699 if (ndi_prop_update_string(DDI_DEV_T_NONE, enum_child,
1700 "bus-addr", name) != DDI_PROP_SUCCESS) {
1701 (void) ndi_devi_free(enum_child);
1702 return (DDI_FAILURE);
1703 }
1704
1705 if (ndi_devi_online(enum_child, 0) !=
1706 DDI_SUCCESS) {
1707 (void) ndi_devi_free(enum_child);
1708 return (DDI_FAILURE);
1709 }
1710 }
1711 /*
1712 * fail the enumeration node itself
1713 */
1714 return (DDI_FAILURE);
1715 }
1716
1717 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 0, "bus-addr",
1718 &bus_addr) != DDI_PROP_SUCCESS) {
1719 cmn_err(CE_WARN, "pshot_initchild: bus-addr not defined (%s)",
1720 ddi_node_name(child));
1721 return (DDI_NOT_WELL_FORMED);
1722 }
1723
1724 if (strlen(bus_addr) == 0) {
1725 cmn_err(CE_WARN, "pshot_initchild: NULL bus-addr (%s)",
1726 ddi_node_name(child));
1727 ddi_prop_free(bus_addr);
1728 return (DDI_FAILURE);
1729 }
1730
1731 if (strncmp(bus_addr, "failinit", 8) == 0) {
1732 if (pshot_debug)
1733 cmn_err(CE_CONT,
1734 "pshot%d: %s forced INITCHILD failure\n",
1735 ddi_get_instance(dip), bus_addr);
1736 ddi_prop_free(bus_addr);
1737 return (DDI_FAILURE);
1738 }
1739
1740 if (pshot_log) {
1741 cmn_err(CE_CONT, "initchild %s%d/%s@%s\n",
1742 ddi_get_name(dip), ddi_get_instance(dip),
1743 ddi_node_name(child), bus_addr);
1744 }
1745
1746 ddi_set_name_addr(child, bus_addr);
1747 ddi_prop_free(bus_addr);
1748 return (DDI_SUCCESS);
1749 }
1750
1751 /*ARGSUSED*/
1752 static int
1753 pshot_uninitchild(dev_info_t *dip, dev_info_t *child)
1754 {
1755 ddi_set_name_addr(child, NULL);
1756 return (DDI_SUCCESS);
1757 }
1758
1759
1760 /*
1761 * devctl IOCTL support
1762 */
1763 /* ARGSUSED */
1764 static int
1765 pshot_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1766 {
1767 int instance;
1768 pshot_t *pshot;
1769
1770 if (otyp != OTYP_CHR)
1771 return (EINVAL);
1772
1773 instance = pshot_minor_decode_inst(getminor(*devp));
1774 if ((pshot = ddi_get_soft_state(pshot_softstatep, instance)) == NULL)
1775 return (ENXIO);
1776
1777 /*
1778 * Access is currently determined on a per-instance basis.
1779 * If we want per-node, then need to add state and lock members to
1780 * pshot_minor_t
1781 */
1782 mutex_enter(&pshot->lock);
1783 if (((flags & FEXCL) && (pshot->state & IS_OPEN)) ||
1784 (!(flags & FEXCL) && (pshot->state & IS_OPEN_EXCL))) {
1785 mutex_exit(&pshot->lock);
1786 return (EBUSY);
1787 }
1788 pshot->state |= IS_OPEN;
1789 if (flags & FEXCL)
1790 pshot->state |= IS_OPEN_EXCL;
1791
1792 if (pshot_debug)
1793 cmn_err(CE_CONT, "pshot%d open\n", instance);
1794
1795 mutex_exit(&pshot->lock);
1796 return (0);
1797 }
1798
1799 /*
1800 * pshot_close
1801 */
1802 /* ARGSUSED */
1803 static int
1804 pshot_close(dev_t dev, int flag, int otyp, cred_t *credp)
1805 {
1806 int instance;
1807 pshot_t *pshot;
1808
1809 if (otyp != OTYP_CHR)
1810 return (EINVAL);
1811
1812 instance = pshot_minor_decode_inst(getminor(dev));
1813 if ((pshot = ddi_get_soft_state(pshot_softstatep, instance)) == NULL)
1814 return (ENXIO);
1815
1816 mutex_enter(&pshot->lock);
1817 pshot->state &= ~(IS_OPEN | IS_OPEN_EXCL);
1818 mutex_exit(&pshot->lock);
1819 if (pshot_debug)
1820 cmn_err(CE_CONT, "pshot%d closed\n", instance);
1821 return (0);
1822 }
1823
1824
1825 /*
1826 * pshot_ioctl: redirects to appropriate command handler based on various
1827 * criteria
1828 */
1829 /* ARGSUSED */
1830 static int
1831 pshot_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1832 int *rvalp)
1833 {
1834 pshot_t *pshot;
1835 int instance;
1836 minor_t nodenum;
1837 char *nodename;
1838
1839 instance = pshot_minor_decode_inst(getminor(dev));
1840 if ((pshot = ddi_get_soft_state(pshot_softstatep, instance)) == NULL)
1841 return (ENXIO);
1842
1843 nodenum = pshot_minor_decode_nodenum(getminor(dev));
1844 nodename = pshot->nodes[nodenum].name;
1845
1846 if (pshot_debug)
1847 cmn_err(CE_CONT,
1848 "pshot%d ioctl: dev=%p, cmd=%x, arg=%p, mode=%x\n",
1849 instance, (void *)dev, cmd, (void *)arg, mode);
1850
1851 if (strcmp(nodename, PSHOT_NODENAME_DEVCTL) == 0)
1852 return (pshot_devctl(pshot, nodenum, cmd, arg, mode, credp,
1853 rvalp));
1854
1855 if (strcmp(nodename, PSHOT_NODENAME_TESTCTL) == 0)
1856 return (pshot_testctl(pshot, nodenum, cmd, arg, mode, credp,
1857 rvalp));
1858
1859 cmn_err(CE_WARN, "pshot_ioctl: unmatched nodename on minor %u",
1860 pshot->nodes[nodenum].minor);
1861 return (ENXIO);
1862 }
1863
1864
1865 /*
1866 * pshot_devctl: handle DEVCTL operations
1867 */
1868 /* ARGSUSED */
1869 static int
1870 pshot_devctl(pshot_t *pshot, minor_t nodenum, int cmd, intptr_t arg, int mode,
1871 cred_t *credp, int *rvalp)
1872 {
1873 dev_info_t *self;
1874 dev_info_t *child = NULL;
1875 struct devctl_iocdata *dcp;
1876 uint_t state;
1877 int rv = 0;
1878 uint_t flags;
1879 int instance;
1880 int i;
1881 int ret;
1882
1883 self = pshot->dip;
1884
1885 flags = (pshot_devctl_debug) ? NDI_DEVI_DEBUG : 0;
1886 instance = pshot->instance;
1887
1888 /*
1889 * We can use the generic implementation for these ioctls
1890 */
1891 for (i = 0; pshot_devctls[i].ioctl_int != 0; i++) {
1892 if (pshot_devctls[i].ioctl_int == cmd) {
1893 if (pshot_debug)
1894 cmn_err(CE_CONT, "pshot%d devctl: %s",
1895 instance, pshot_devctls[i].ioctl_char);
1896 }
1897 }
1898 switch (cmd) {
1899 case DEVCTL_DEVICE_GETSTATE:
1900 case DEVCTL_DEVICE_ONLINE:
1901 case DEVCTL_DEVICE_OFFLINE:
1902 case DEVCTL_DEVICE_REMOVE:
1903 case DEVCTL_BUS_GETSTATE:
1904 case DEVCTL_BUS_DEV_CREATE:
1905 rv = ndi_devctl_ioctl(self, cmd, arg, mode, flags);
1906 if (pshot_debug && rv != 0) {
1907 cmn_err(CE_CONT, "pshot%d ndi_devctl_ioctl:"
1908 " failed, rv = %d", instance, rv);
1909 }
1910
1911 return (rv);
1912 }
1913
1914 /*
1915 * read devctl ioctl data
1916 */
1917 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1918 return (EFAULT);
1919
1920 switch (cmd) {
1921
1922 case DEVCTL_DEVICE_RESET:
1923 if (pshot_debug)
1924 cmn_err(CE_CONT, "pshot%d devctl:"
1925 " DEVCTL_DEVICE_RESET\n", instance);
1926 rv = pshot_event(pshot, PSHOT_EVENT_TAG_DEV_RESET,
1927 child, (void *)self);
1928 ASSERT(rv == NDI_SUCCESS);
1929 break;
1930
1931 case DEVCTL_BUS_QUIESCE:
1932 if (pshot_debug)
1933 cmn_err(CE_CONT, "pshot%d devctl:"
1934 " DEVCTL_BUS_QUIESCE\n", instance);
1935 if (ndi_get_bus_state(self, &state) == NDI_SUCCESS) {
1936 if (state == BUS_QUIESCED) {
1937 break;
1938 }
1939 (void) ndi_set_bus_state(self, BUS_QUIESCED);
1940 }
1941 rv = pshot_event(pshot, PSHOT_EVENT_TAG_BUS_QUIESCE,
1942 child, (void *)self);
1943 ASSERT(rv == NDI_SUCCESS);
1944
1945 break;
1946
1947 case DEVCTL_BUS_UNQUIESCE:
1948 if (pshot_debug)
1949 cmn_err(CE_CONT, "pshot%d devctl:"
1950 " DEVCTL_BUS_UNQUIESCE\n", instance);
1951 if (ndi_get_bus_state(self, &state) == NDI_SUCCESS) {
1952 if (state == BUS_ACTIVE) {
1953 break;
1954 }
1955 }
1956
1957 /*
1958 * quiesce the bus through bus-specific means
1959 */
1960 (void) ndi_set_bus_state(self, BUS_ACTIVE);
1961 rv = pshot_event(pshot, PSHOT_EVENT_TAG_BUS_UNQUIESCE,
1962 child, (void *)self);
1963 ASSERT(rv == NDI_SUCCESS);
1964 break;
1965
1966 case DEVCTL_BUS_RESET:
1967 case DEVCTL_BUS_RESETALL:
1968 /*
1969 * no reset support for the pseudo bus
1970 * but if there were....
1971 */
1972 rv = pshot_event(pshot, PSHOT_EVENT_TAG_BUS_RESET,
1973 child, (void *)self);
1974 ASSERT(rv == NDI_SUCCESS);
1975 break;
1976
1977 /*
1978 * PM related ioctls
1979 */
1980 case DEVCTL_PM_BUSY_COMP:
1981 /*
1982 * mark component 0 busy.
1983 * Keep track of ioctl updates to the busy count
1984 * via pshot->busy_ioctl.
1985 */
1986 if (pshot_debug) {
1987 cmn_err(CE_CONT, "pshot%d devctl:"
1988 " DEVCTL_PM_BUSY_COMP\n", instance);
1989 }
1990 mutex_enter(&pshot->lock);
1991 ++(pshot->busy);
1992 ++(pshot->busy_ioctl);
1993 if (pshot_debug_busy) {
1994 cmn_err(CE_CONT, "pshot%d:"
1995 " DEVCTL_PM_BUSY_COMP comp 0 busy"
1996 " %d busy_ioctl %d\n", instance, pshot->busy,
1997 pshot->busy_ioctl);
1998 }
1999 mutex_exit(&pshot->lock);
2000 ret = pm_busy_component(pshot->dip, 0);
2001 ASSERT(ret == DDI_SUCCESS);
2002
2003 break;
2004
2005 case DEVCTL_PM_BUSY_COMP_TEST:
2006 /*
2007 * test bus's busy state
2008 */
2009 if (pshot_debug) {
2010 cmn_err(CE_CONT, "pshot%d devctl:"
2011 " DEVCTL_PM_BUSY_COMP_TEST\n", instance);
2012 }
2013 mutex_enter(&pshot->lock);
2014 state = pshot->busy;
2015 if (copyout(&state, dcp->cpyout_buf,
2016 sizeof (uint_t)) != 0) {
2017 cmn_err(CE_WARN, "pshot%d devctl:"
2018 " DEVCTL_PM_BUSY_COMP_TEST: copyout failed",
2019 instance);
2020 rv = EINVAL;
2021 }
2022 if (pshot_debug_busy) {
2023 cmn_err(CE_CONT, "pshot%d: DEVCTL_PM_BUSY_COMP_TEST:"
2024 " comp 0 busy %d busy_ioctl %d\n", instance,
2025 state, pshot->busy_ioctl);
2026 }
2027 mutex_exit(&pshot->lock);
2028 break;
2029
2030 case DEVCTL_PM_IDLE_COMP:
2031 /*
2032 * mark component 0 idle.
2033 * NOP if pshot->busy_ioctl <= 0.
2034 */
2035 if (pshot_debug) {
2036 cmn_err(CE_CONT, "pshot%d devctl:"
2037 " DEVCTL_PM_IDLE_COMP\n", instance);
2038 }
2039 mutex_enter(&pshot->lock);
2040 if (pshot->busy_ioctl > 0) {
2041 ASSERT(pshot->busy > 0);
2042 --(pshot->busy);
2043 --(pshot->busy_ioctl);
2044 if (pshot_debug_busy) {
2045 cmn_err(CE_CONT, "pshot%d:"
2046 " DEVCTL_PM_IDLE_COM: comp 0"
2047 " busy %d busy_ioctl %d\n", instance,
2048 pshot->busy, pshot->busy_ioctl);
2049 }
2050 mutex_exit(&pshot->lock);
2051 ret = pm_idle_component(pshot->dip, 0);
2052 ASSERT(ret == DDI_SUCCESS);
2053
2054 } else {
2055 mutex_exit(&pshot->lock);
2056 }
2057 break;
2058
2059 case DEVCTL_PM_RAISE_PWR:
2060 /*
2061 * raise component 0 to full power level MAXPWR via a
2062 * pm_raise_power() call
2063 */
2064 if (pshot_debug) {
2065 cmn_err(CE_CONT, "pshot%d devctl:"
2066 " DEVCTL_PM_RAISE_PWR\n", instance);
2067 }
2068 if (pm_raise_power(pshot->dip, 0, MAXPWR) != DDI_SUCCESS) {
2069 rv = EINVAL;
2070 } else {
2071 mutex_enter(&pshot->lock);
2072 if (pshot_debug) {
2073 cmn_err(CE_CONT, "pshot%d:"
2074 " DEVCTL_PM_RAISE_POWER: comp 0"
2075 " to level %d\n", instance, pshot->level);
2076 }
2077 mutex_exit(&pshot->lock);
2078 }
2079 break;
2080
2081 case DEVCTL_PM_LOWER_PWR:
2082 /*
2083 * pm_lower_power() call for negative testing
2084 * expected to fail.
2085 */
2086 if (pshot_debug) {
2087 cmn_err(CE_CONT, "pshot%d devctl:"
2088 " DEVCTL_PM_LOWER_PWR\n", instance);
2089 }
2090 if (pm_lower_power(pshot->dip, 0, 0) != DDI_SUCCESS) {
2091 rv = EINVAL;
2092 } else {
2093 mutex_enter(&pshot->lock);
2094 if (pshot_debug) {
2095 cmn_err(CE_CONT, "pshot%d:"
2096 " DEVCTL_PM_LOWER_POWER comp 0"
2097 " to level %d\n", instance, pshot->level);
2098 }
2099 mutex_exit(&pshot->lock);
2100 }
2101 break;
2102
2103 case DEVCTL_PM_CHANGE_PWR_LOW:
2104 /*
2105 * inform the PM framework that component 0 has changed
2106 * power level to 0 via a pm_power_has_changed() call
2107 */
2108 if (pshot_debug) {
2109 cmn_err(CE_CONT, "pshot%d devctl:"
2110 " DEVCTL_PM_CHANGE_PWR_LOW\n", instance);
2111 }
2112 mutex_enter(&pshot->lock);
2113 pshot->level = 0;
2114 if (pm_power_has_changed(pshot->dip, 0, 0) != DDI_SUCCESS) {
2115 rv = EINVAL;
2116 } else {
2117 if (pshot_debug) {
2118 cmn_err(CE_CONT, "pshot%d:"
2119 " DEVCTL_PM_CHANGE_PWR_LOW comp 0 to"
2120 " level %d\n", instance, pshot->level);
2121 }
2122 }
2123 mutex_exit(&pshot->lock);
2124 break;
2125
2126 case DEVCTL_PM_CHANGE_PWR_HIGH:
2127 /*
2128 * inform the PM framework that component 0 has changed
2129 * power level to MAXPWR via a pm_power_has_changed() call
2130 */
2131 if (pshot_debug) {
2132 cmn_err(CE_CONT, "pshot%d devctl:"
2133 " DEVCTL_PM_CHANGE_PWR_HIGH\n", instance);
2134 }
2135 mutex_enter(&pshot->lock);
2136 pshot->level = MAXPWR;
2137 if (pm_power_has_changed(pshot->dip, 0, MAXPWR)
2138 != DDI_SUCCESS) {
2139 rv = EINVAL;
2140 } else {
2141 if (pshot_debug) {
2142 cmn_err(CE_CONT, "pshot%d:"
2143 " DEVCTL_PM_CHANGE_PWR_HIGH comp 0 to"
2144 " level %d\n", instance, pshot->level);
2145 }
2146 }
2147 mutex_exit(&pshot->lock);
2148 break;
2149
2150 case DEVCTL_PM_POWER:
2151 /*
2152 * test if the pshot_power() routine has been called,
2153 * then clear
2154 */
2155 if (pshot_debug) {
2156 cmn_err(CE_CONT, "pshot%d devctl:"
2157 " DEVCTL_PM_POWER\n", instance);
2158 }
2159 mutex_enter(&pshot->lock);
2160 state = (pshot->state & POWER_FLAG) ? 1 : 0;
2161 if (copyout(&state, dcp->cpyout_buf,
2162 sizeof (uint_t)) != 0) {
2163 cmn_err(CE_WARN, "pshot%d devctl:"
2164 " DEVCTL_PM_POWER: copyout failed",
2165 instance);
2166 rv = EINVAL;
2167 }
2168 if (pshot_debug) {
2169 cmn_err(CE_CONT, "pshot%d: DEVCTL_PM_POWER:"
2170 " POWER_FLAG = %d\n", instance, state);
2171 }
2172 pshot->state &= ~POWER_FLAG;
2173 mutex_exit(&pshot->lock);
2174 break;
2175
2176 case DEVCTL_PM_FAIL_SUSPEND:
2177 /*
2178 * fail DDI_SUSPEND
2179 */
2180 if (pshot_debug) {
2181 cmn_err(CE_CONT, "pshot%d devctl:"
2182 " DEVCTL_PM_FAIL_SUSPEND\n", instance);
2183 }
2184 mutex_enter(&pshot->lock);
2185 pshot->state |= FAIL_SUSPEND_FLAG;
2186 mutex_exit(&pshot->lock);
2187 if (pshot_debug) {
2188 cmn_err(CE_CONT, "pshot%d: DEVCTL_PM_FAIL_SUSPEND\n",
2189 instance);
2190 }
2191 break;
2192
2193 case DEVCTL_PM_BUS_STRICT_TEST:
2194 /*
2195 * test the STRICT_PARENT flag:
2196 * set => STRICT PARENT
2197 * not set => INVOLVED PARENT
2198 */
2199 mutex_enter(&pshot->lock);
2200 state = (pshot->state & STRICT_PARENT) ? 1 : 0;
2201 if (copyout(&state, dcp->cpyout_buf,
2202 sizeof (uint_t)) != 0) {
2203 cmn_err(CE_WARN, "pshot%d devctl:"
2204 " DEVCTL_PM_BUS_STRICT_TEST: copyout failed",
2205 instance);
2206 rv = EINVAL;
2207 }
2208 if (pshot_debug) {
2209 cmn_err(CE_CONT, "pshot%d devctl:"
2210 " DEVCTL_PM_BUS_STRICT_TEST: type = %s\n",
2211 instance, ((state == 0) ? "INVOLVED" : "STRICT"));
2212 }
2213 mutex_exit(&pshot->lock);
2214 break;
2215
2216 case DEVCTL_PM_BUS_NO_INVOL:
2217 /*
2218 * Set the NO_INVOL_FLAG flag to
2219 * notify the driver that the child will not
2220 * call pm_lower_power() on detach.
2221 * The driver needs to mark itself idle twice
2222 * during DDI_CTLOPS_DETACH (post).
2223 */
2224 if (pshot_debug) {
2225 cmn_err(CE_CONT, "pshot%d devctl:"
2226 " DEVCTL_PM_BUS_NO_INVOL\n", instance);
2227 }
2228 mutex_enter(&pshot->lock);
2229 pshot->state |= NO_INVOL_FLAG;
2230 mutex_exit(&pshot->lock);
2231 break;
2232
2233 default:
2234 rv = ENOTTY;
2235 }
2236
2237 ndi_dc_freehdl(dcp);
2238 return (rv);
2239 }
2240
2241
2242 /*
2243 * pshot_testctl: handle other test operations
2244 * - If <cmd> is a DEVCTL cmd, then <arg> is a dev_t indicating which
2245 * child to direct the DEVCTL to, if applicable;
2246 * furthermore, any cmd here can be sent by layered ioctls (unlike
2247 * those to pshot_devctl() which must come from userland)
2248 */
2249 /* ARGSUSED */
2250 static int
2251 pshot_testctl(pshot_t *pshot, minor_t nodenum, int cmd, intptr_t arg, int mode,
2252 cred_t *credp, int *rvalp)
2253 {
2254 dev_info_t *self;
2255 dev_info_t *child = NULL;
2256 uint_t state;
2257 int rv = 0;
2258 int instance;
2259 int i;
2260
2261 /* uint_t flags; */
2262
2263 /* flags = (pshot_devctl_debug) ? NDI_DEVI_DEBUG : 0; */
2264 self = pshot->dip;
2265 instance = pshot->instance;
2266
2267 if (cmd & DEVCTL_IOC) {
2268 child = e_ddi_hold_devi_by_dev((dev_t)arg, 0);
2269 }
2270
2271 for (i = 0; pshot_devctls[i].ioctl_int != 0; i++) {
2272 if (pshot_devctls[i].ioctl_int == cmd) {
2273 if (pshot_debug)
2274 cmn_err(CE_CONT, "pshot%d devctl: %s",
2275 instance, pshot_devctls[i].ioctl_char);
2276 }
2277 }
2278 switch (cmd) {
2279 case DEVCTL_DEVICE_RESET:
2280 if (pshot_debug)
2281 cmn_err(CE_CONT, "pshot%d testctl:"
2282 " DEVCTL_PM_POWER\n", instance);
2283 rv = pshot_event(pshot, PSHOT_EVENT_TAG_DEV_RESET,
2284 child, (void *)self);
2285 ASSERT(rv == NDI_SUCCESS);
2286 break;
2287
2288 case DEVCTL_BUS_QUIESCE:
2289 if (pshot_debug)
2290 cmn_err(CE_CONT, "pshot%d testctl:"
2291 " DEVCTL_PM_POWER\n", instance);
2292 if (ndi_get_bus_state(self, &state) == NDI_SUCCESS) {
2293 if (state == BUS_QUIESCED) {
2294 break;
2295 }
2296 (void) ndi_set_bus_state(self, BUS_QUIESCED);
2297 }
2298 rv = pshot_event(pshot, PSHOT_EVENT_TAG_BUS_QUIESCE,
2299 child, (void *)self);
2300 ASSERT(rv == NDI_SUCCESS);
2301
2302 break;
2303
2304 case DEVCTL_BUS_UNQUIESCE:
2305 if (pshot_debug)
2306 cmn_err(CE_CONT, "pshot%d testctl:"
2307 " DEVCTL_PM_POWER\n", instance);
2308 if (ndi_get_bus_state(self, &state) == NDI_SUCCESS) {
2309 if (state == BUS_ACTIVE) {
2310 break;
2311 }
2312 }
2313
2314 /*
2315 * quiesce the bus through bus-specific means
2316 */
2317 (void) ndi_set_bus_state(self, BUS_ACTIVE);
2318 rv = pshot_event(pshot, PSHOT_EVENT_TAG_BUS_UNQUIESCE,
2319 child, (void *)self);
2320 ASSERT(rv == NDI_SUCCESS);
2321 break;
2322
2323 case DEVCTL_BUS_RESET:
2324 case DEVCTL_BUS_RESETALL:
2325 /*
2326 * no reset support for the pseudo bus
2327 * but if there were....
2328 */
2329 rv = pshot_event(pshot, PSHOT_EVENT_TAG_BUS_RESET,
2330 child, (void *)self);
2331 ASSERT(rv == NDI_SUCCESS);
2332 break;
2333
2334 default:
2335 rv = ENOTTY;
2336 }
2337
2338 if (child != NULL)
2339 ddi_release_devi(child);
2340 return (rv);
2341 }
2342
2343
2344 static int
2345 pshot_get_eventcookie(dev_info_t *dip, dev_info_t *rdip,
2346 char *eventname, ddi_eventcookie_t *event_cookiep)
2347 {
2348 int instance = ddi_get_instance(dip);
2349 pshot_t *pshot = ddi_get_soft_state(pshot_softstatep, instance);
2350
2351 if (pshot_debug)
2352 cmn_err(CE_CONT, "pshot%d: "
2353 "pshot_get_eventcookie:\n\t"
2354 "dip = 0x%p rdip = 0x%p (%s/%d) eventname = %s\n",
2355 instance, (void *)dip, (void *)rdip,
2356 ddi_node_name(rdip), ddi_get_instance(rdip),
2357 eventname);
2358
2359
2360 return (ndi_event_retrieve_cookie(pshot->ndi_event_hdl,
2361 rdip, eventname, event_cookiep, NDI_EVENT_NOPASS));
2362 }
2363
2364 static int
2365 pshot_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
2366 ddi_eventcookie_t cookie,
2367 void (*callback)(), void *arg, ddi_callback_id_t *cb_id)
2368 {
2369 int instance = ddi_get_instance(dip);
2370 pshot_t *pshot = ddi_get_soft_state(pshot_softstatep, instance);
2371
2372 if (pshot_debug)
2373 cmn_err(CE_CONT, "pshot%d: "
2374 "pshot_add_eventcall:\n\t"
2375 "dip = 0x%p rdip = 0x%p (%s%d)\n\tcookie = 0x%p (%s)\n\t"
2376 "cb = 0x%p, arg = 0x%p\n",
2377 instance, (void *)dip, (void *)rdip,
2378 ddi_node_name(rdip), ddi_get_instance(rdip), (void *)cookie,
2379 NDI_EVENT_NAME(cookie), (void *)callback, arg);
2380
2381 /* add callback to our event handle */
2382 return (ndi_event_add_callback(pshot->ndi_event_hdl, rdip,
2383 cookie, callback, arg, NDI_SLEEP, cb_id));
2384 }
2385
2386 static int
2387 pshot_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
2388 {
2389
2390 ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)cb_id;
2391
2392 int instance = ddi_get_instance(dip);
2393 pshot_t *pshot = ddi_get_soft_state(pshot_softstatep, instance);
2394
2395 ASSERT(cb);
2396
2397 if (pshot_debug)
2398 cmn_err(CE_CONT, "pshot%d: "
2399 "pshot_remove_eventcall:\n\t"
2400 "dip = 0x%p rdip = 0x%p (%s%d)\n\tcookie = 0x%p (%s)\n",
2401 instance, (void *)dip, (void *)cb->ndi_evtcb_dip,
2402 ddi_node_name(cb->ndi_evtcb_dip),
2403 ddi_get_instance(cb->ndi_evtcb_dip),
2404 (void *)cb->ndi_evtcb_cookie,
2405 NDI_EVENT_NAME(cb->ndi_evtcb_cookie));
2406
2407 return (ndi_event_remove_callback(pshot->ndi_event_hdl, cb_id));
2408 }
2409
2410 static int
2411 pshot_post_event(dev_info_t *dip, dev_info_t *rdip,
2412 ddi_eventcookie_t cookie, void *impl_data)
2413 {
2414 int instance = ddi_get_instance(dip);
2415 pshot_t *pshot = ddi_get_soft_state(pshot_softstatep, instance);
2416
2417 if (pshot_debug) {
2418 if (rdip) {
2419 cmn_err(CE_CONT, "pshot%d: "
2420 "pshot_post_event:\n\t"
2421 "dip = 0x%p rdip = 0x%p (%s%d\n\t"
2422 "cookie = 0x%p (%s)\n\tbus_impl = 0x%p\n",
2423 instance, (void *)dip, (void *)rdip,
2424 ddi_node_name(rdip), ddi_get_instance(rdip),
2425 (void *)cookie,
2426 NDI_EVENT_NAME(cookie), impl_data);
2427 } else {
2428 cmn_err(CE_CONT, "pshot%d: "
2429 "pshot_post_event:\n\t"
2430 "dip = 0x%p cookie = 0x%p (%s) bus_impl = 0x%p\n",
2431 instance, (void *)dip, (void *)cookie,
2432 NDI_EVENT_NAME(cookie), impl_data);
2433 }
2434 }
2435
2436 /* run callbacks for this event */
2437 return (ndi_event_run_callbacks(pshot->ndi_event_hdl, rdip,
2438 cookie, impl_data));
2439 }
2440
2441 /*
2442 * the nexus driver will generate events
2443 * that need to go to children
2444 */
2445 static int
2446 pshot_event(pshot_t *pshot, int event_tag, dev_info_t *child,
2447 void *bus_impldata)
2448 {
2449 ddi_eventcookie_t cookie = ndi_event_tag_to_cookie(
2450 pshot->ndi_event_hdl, event_tag);
2451
2452 if (pshot_debug) {
2453 if (child) {
2454 cmn_err(CE_CONT, "pshot%d: "
2455 "pshot_event: event_tag = 0x%x (%s)\n\t"
2456 "child = 0x%p (%s%d) bus_impl = 0x%p (%s%d)\n",
2457 pshot->instance, event_tag,
2458 ndi_event_tag_to_name(pshot->ndi_event_hdl,
2459 event_tag),
2460 (void *)child, ddi_node_name(child),
2461 ddi_get_instance(child), bus_impldata,
2462 ddi_node_name((dev_info_t *)bus_impldata),
2463 ddi_get_instance((dev_info_t *)bus_impldata));
2464 } else {
2465 cmn_err(CE_CONT, "pshot%d: "
2466 "pshot_event: event_tag = 0x%x (%s)\n\t"
2467 "child = NULL, bus_impl = 0x%p (%s%d)\n",
2468 pshot->instance, event_tag,
2469 ndi_event_tag_to_name(pshot->ndi_event_hdl,
2470 event_tag),
2471 bus_impldata,
2472 ddi_node_name((dev_info_t *)bus_impldata),
2473 ddi_get_instance((dev_info_t *)bus_impldata));
2474 }
2475 }
2476
2477 return (ndi_event_run_callbacks(pshot->ndi_event_hdl,
2478 child, cookie, bus_impldata));
2479 }
2480
2481
2482 /*
2483 * the pshot driver event notification callback
2484 */
2485 static void
2486 pshot_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie,
2487 void *arg, void *bus_impldata)
2488 {
2489 pshot_t *pshot = (pshot_t *)arg;
2490 int event_tag;
2491
2492 /* look up the event */
2493 event_tag = NDI_EVENT_TAG(cookie);
2494
2495 if (pshot_debug) {
2496 cmn_err(CE_CONT, "pshot%d: "
2497 "pshot_event_cb:\n\t"
2498 "dip = 0x%p cookie = 0x%p (%s), tag = 0x%x\n\t"
2499 "arg = 0x%p bus_impl = 0x%p (%s%d)\n",
2500 pshot->instance, (void *)dip, (void *)cookie,
2501 NDI_EVENT_NAME(cookie), event_tag, arg, bus_impldata,
2502 ddi_node_name((dev_info_t *)bus_impldata),
2503 ddi_get_instance((dev_info_t *)bus_impldata));
2504 }
2505
2506 switch (event_tag) {
2507 case PSHOT_EVENT_TAG_OFFLINE:
2508 case PSHOT_EVENT_TAG_BUS_RESET:
2509 case PSHOT_EVENT_TAG_BUS_QUIESCE:
2510 case PSHOT_EVENT_TAG_BUS_UNQUIESCE:
2511 /* notify all subscribers of the this event */
2512 (void) ndi_event_run_callbacks(pshot->ndi_event_hdl,
2513 NULL, cookie, bus_impldata);
2514 if (pshot_debug) {
2515 cmn_err(CE_CONT, "pshot%d: event=%s\n\t"
2516 "pshot_event_cb\n", pshot->instance,
2517 NDI_EVENT_NAME(cookie));
2518 }
2519 /*FALLTHRU*/
2520 case PSHOT_EVENT_TAG_TEST_POST:
2521 case PSHOT_EVENT_TAG_DEV_RESET:
2522 default:
2523 return;
2524 }
2525 }
2526
2527 static int
2528 pshot_bus_config(dev_info_t *parent, uint_t flags,
2529 ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
2530 {
2531 int rval;
2532 char *devname;
2533 char *devstr, *cname, *caddr;
2534 int devstrlen;
2535 int circ;
2536 pshot_t *pshot;
2537 int instance = ddi_get_instance(parent);
2538
2539 if (pshot_debug) {
2540 flags |= NDI_DEVI_DEBUG;
2541 cmn_err(CE_CONT,
2542 "pshot%d: bus_config %s flags=0x%x\n",
2543 ddi_get_instance(parent),
2544 (op == BUS_CONFIG_ONE) ? (char *)arg : "", flags);
2545 }
2546
2547 pshot = ddi_get_soft_state(pshot_softstatep, instance);
2548 if (pshot == NULL) {
2549
2550 return (NDI_FAILURE);
2551 }
2552
2553 /*
2554 * Hold the nexus across the bus_config
2555 */
2556 ndi_devi_enter(parent, &circ);
2557
2558 switch (op) {
2559 case BUS_CONFIG_ONE:
2560
2561 /*
2562 * lookup and hold child device, create if not found
2563 */
2564 devname = (char *)arg;
2565 devstrlen = strlen(devname) + 1;
2566 devstr = i_ddi_strdup(devname, KM_SLEEP);
2567 i_ddi_parse_name(devstr, &cname, &caddr, NULL);
2568
2569 /*
2570 * The framework ensures that the node has
2571 * a name but each nexus is responsible for
2572 * the bus address name space. This driver
2573 * requires that a bus address be specified,
2574 * as will most nexus drivers.
2575 */
2576 ASSERT(cname && strlen(cname) > 0);
2577 if (caddr == NULL || strlen(caddr) == 0) {
2578 cmn_err(CE_WARN,
2579 "pshot%d: malformed name %s (no bus address)",
2580 ddi_get_instance(parent), devname);
2581 kmem_free(devstr, devstrlen);
2582 ndi_devi_exit(parent, circ);
2583 return (NDI_FAILURE);
2584 }
2585
2586 /*
2587 * Handle a few special cases for testing purposes
2588 */
2589 rval = pshot_bus_config_test_specials(parent,
2590 devname, cname, caddr);
2591
2592 if (rval == NDI_SUCCESS) {
2593 /*
2594 * Set up either a leaf or nexus device
2595 */
2596 if (strcmp(cname, "pshot") == 0) {
2597 rval = pshot_bus_config_setup_nexus(parent,
2598 cname, caddr);
2599 } else {
2600 rval = pshot_bus_config_setup_leaf(parent,
2601 cname, caddr);
2602 }
2603 }
2604
2605 kmem_free(devstr, devstrlen);
2606 break;
2607
2608 case BUS_CONFIG_DRIVER:
2609 case BUS_CONFIG_ALL:
2610 rval = NDI_SUCCESS;
2611 break;
2612
2613 default:
2614 rval = NDI_FAILURE;
2615 break;
2616 }
2617
2618 if (rval == NDI_SUCCESS)
2619 rval = ndi_busop_bus_config(parent, flags, op, arg, childp, 0);
2620
2621 ndi_devi_exit(parent, circ);
2622
2623 if (pshot_debug)
2624 cmn_err(CE_CONT, "pshot%d: bus_config %s\n",
2625 ddi_get_instance(parent),
2626 (rval == NDI_SUCCESS) ? "ok" : "failed");
2627
2628 return (rval);
2629 }
2630
2631 static int
2632 pshot_bus_unconfig(dev_info_t *parent, uint_t flags,
2633 ddi_bus_config_op_t op, void *arg)
2634 {
2635 major_t major;
2636 int rval = NDI_SUCCESS;
2637 int circ;
2638
2639 if (pshot_debug) {
2640 flags |= NDI_DEVI_DEBUG;
2641 cmn_err(CE_CONT,
2642 "pshot%d: bus_unconfig %s flags=0x%x\n",
2643 ddi_get_instance(parent),
2644 (op == BUS_UNCONFIG_ONE) ? (char *)arg : "", flags);
2645 }
2646
2647 /*
2648 * Hold the nexus across the bus_unconfig
2649 */
2650 ndi_devi_enter(parent, &circ);
2651
2652 switch (op) {
2653 case BUS_UNCONFIG_ONE:
2654 /*
2655 * Nothing special required here
2656 */
2657 if (pshot_debug) {
2658 cmn_err(CE_CONT, "pshot%d: bus_unconfig:"
2659 " BUS_UNCONFIG_ONE\n", ddi_get_instance(parent));
2660 }
2661 break;
2662
2663 case BUS_UNCONFIG_DRIVER:
2664 if (pshot_debug > 0) {
2665 major = (major_t)(uintptr_t)arg;
2666 cmn_err(CE_CONT,
2667 "pshot%d: BUS_UNCONFIG_DRIVER: %s\n",
2668 ddi_get_instance(parent),
2669 ddi_major_to_name(major));
2670 }
2671 break;
2672
2673 case BUS_UNCONFIG_ALL:
2674 if (pshot_debug) {
2675 cmn_err(CE_CONT, "pshot%d: bus_unconfig:"
2676 " BUS_UNCONFIG_ALL\n", ddi_get_instance(parent));
2677 }
2678 break;
2679
2680 default:
2681 if (pshot_debug) {
2682 cmn_err(CE_CONT, "pshot%d: bus_unconfig: DEFAULT\n",
2683 ddi_get_instance(parent));
2684 }
2685 rval = NDI_FAILURE;
2686 }
2687
2688 if (rval == NDI_SUCCESS)
2689 rval = ndi_busop_bus_unconfig(parent, flags, op, arg);
2690
2691 ndi_devi_exit(parent, circ);
2692
2693 if (pshot_debug)
2694 cmn_err(CE_CONT, "pshot%d: bus_unconfig %s\n",
2695 ddi_get_instance(parent),
2696 (rval == NDI_SUCCESS) ? "ok" : "failed");
2697
2698 return (rval);
2699 }
2700
2701 static dev_info_t *
2702 pshot_findchild(dev_info_t *pdip, char *cname, char *caddr)
2703 {
2704 dev_info_t *dip;
2705 char *addr;
2706
2707 ASSERT(cname != NULL && caddr != NULL);
2708 ASSERT(DEVI_BUSY_OWNED(pdip));
2709
2710 for (dip = ddi_get_child(pdip); dip != NULL;
2711 dip = ddi_get_next_sibling(dip)) {
2712 if (strcmp(cname, ddi_node_name(dip)) != 0)
2713 continue;
2714
2715 if ((addr = ddi_get_name_addr(dip)) == NULL) {
2716 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
2717 "bus-addr", &addr) == DDI_PROP_SUCCESS) {
2718 if (strcmp(caddr, addr) == 0) {
2719 ddi_prop_free(addr);
2720 return (dip);
2721 }
2722 ddi_prop_free(addr);
2723 }
2724 } else {
2725 if (strcmp(caddr, addr) == 0)
2726 return (dip);
2727 }
2728 }
2729
2730 return (NULL);
2731 }
2732
2733 static void
2734 pshot_nexus_properties(dev_info_t *parent, dev_info_t *child, char *cname,
2735 char *caddr)
2736 {
2737 char *extension;
2738
2739 /*
2740 * extract the address extension
2741 */
2742 extension = strstr(caddr, ",");
2743 if (extension != NULL) {
2744 ++extension;
2745 } else {
2746 extension = "null";
2747 }
2748
2749 /*
2750 * Create the "pm-want-child-notification?" property for all
2751 * nodes that do not have the "pm_strict" or "nopm_strict"
2752 * extension
2753 */
2754 if (strcmp(extension, "pm_strict") != 0 &&
2755 strcmp(extension, "nopm_strict") != 0) {
2756 if (ddi_prop_exists(DDI_DEV_T_ANY, child,
2757 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
2758 "pm-want-child-notification?") == 0) {
2759 if (pshot_debug) {
2760 cmn_err(CE_CONT, "pshot%d:"
2761 " nexus_properties:\n\tcreate the"
2762 " \"pm-want-child-notification?\""
2763 " property for %s@%s\n",
2764 ddi_get_instance(parent), cname, caddr);
2765 }
2766 if (ddi_prop_create(DDI_DEV_T_NONE, child, 0,
2767 "pm-want-child-notification?", NULL, 0)
2768 != DDI_PROP_SUCCESS) {
2769 cmn_err(CE_WARN, "pshot%d:"
2770 " nexus_properties:\n\tunable to create"
2771 " the \"pm-want-child-notification?\""
2772 " property for %s@%s",
2773 ddi_get_instance(parent), cname, caddr);
2774 }
2775 }
2776 }
2777
2778 /*
2779 * Create the "no-pm-components" property for all nodes
2780 * with extension "nopm" or "nopm_strict"
2781 */
2782 if (strcmp(extension, "nopm") == 0 ||
2783 strcmp(extension, "nopm_strict") == 0) {
2784 if (ddi_prop_exists(DDI_DEV_T_ANY, child,
2785 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
2786 "no-pm-components") == 0) {
2787 if (pshot_debug) {
2788 cmn_err(CE_CONT, "pshot%d:"
2789 " nexus_properties:\n\tcreate the"
2790 " \"no-pm-components\""
2791 " property for %s@%s\n",
2792 ddi_get_instance(parent), cname, caddr);
2793 }
2794 if (ddi_prop_create(DDI_DEV_T_NONE, child, 0,
2795 "no-pm-components", NULL, 0)
2796 != DDI_PROP_SUCCESS) {
2797 cmn_err(CE_WARN, "pshot%d:"
2798 " nexus_properties:\n\tunable to create"
2799 " the \"no-pm-components\""
2800 " property for %s@%s",
2801 ddi_get_instance(parent), cname, caddr);
2802 }
2803 }
2804 }
2805 }
2806
2807 static void
2808 pshot_leaf_properties(dev_info_t *parent, dev_info_t *child, char *cname,
2809 char *caddr)
2810 {
2811 char *extension;
2812
2813 /*
2814 * extract the address extension
2815 */
2816 extension = strstr(caddr, ",");
2817 if (extension != NULL) {
2818 ++extension;
2819 } else {
2820 extension = "null";
2821 }
2822
2823 /*
2824 * Create the "no-involuntary-power-cycles" property for
2825 * all leaf nodes with extension "no_invol"
2826 */
2827 if (strcmp(extension, "no_invol") == 0) {
2828 if (ddi_prop_exists(DDI_DEV_T_ANY, child,
2829 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
2830 "no-involuntary-power-cycles") == 0) {
2831 if (pshot_debug) {
2832 cmn_err(CE_CONT, "pshot%d:"
2833 " leaf_properties:\n\tcreate the"
2834 " \"no-involuntary-power-cycles\""
2835 " property for %s@%s\n",
2836 ddi_get_instance(parent), cname, caddr);
2837 }
2838 if (ddi_prop_create(DDI_DEV_T_NONE, child,
2839 DDI_PROP_CANSLEEP,
2840 "no-involuntary-power-cycles", NULL, 0)
2841 != DDI_PROP_SUCCESS) {
2842 cmn_err(CE_WARN, "pshot%d:"
2843 " leaf_properties:\n\tunable to create the"
2844 " \"no-involuntary-power-cycles\""
2845 " property for %s@%s",
2846 ddi_get_instance(parent), cname, caddr);
2847 }
2848 }
2849 }
2850
2851 /*
2852 * Create the "dependency-property" property for all leaf
2853 * nodes with extension "dep_prop"
2854 * to be used with the PM_ADD_DEPENDENT_PROPERTY ioctl
2855 */
2856 if (strcmp(extension, "dep_prop") == 0) {
2857 if (ddi_prop_exists(DDI_DEV_T_ANY, child,
2858 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
2859 "dependency-property") == 0) {
2860 if (pshot_debug) {
2861 cmn_err(CE_CONT, "pshot%d:"
2862 " leaf_properties:\n\tcreate the"
2863 " \"dependency-property\""
2864 " property for %s@%s\n",
2865 ddi_get_instance(parent), cname, caddr);
2866 }
2867 if (ddi_prop_create(DDI_DEV_T_NONE, child,
2868 DDI_PROP_CANSLEEP, "dependency-property", NULL, 0)
2869 != DDI_PROP_SUCCESS) {
2870 cmn_err(CE_WARN, "pshot%d:"
2871 " leaf_properties:\n\tunable to create the"
2872 " \"dependency-property\" property for"
2873 " %s@%s", ddi_get_instance(parent),
2874 cname, caddr);
2875 }
2876 }
2877 }
2878 }
2879
2880 /*
2881 * BUS_CONFIG_ONE: setup a child nexus instance.
2882 */
2883 static int
2884 pshot_bus_config_setup_nexus(dev_info_t *parent, char *cname, char *caddr)
2885 {
2886 dev_info_t *child;
2887 int rval;
2888
2889 ASSERT(parent != 0);
2890 ASSERT(cname != NULL);
2891 ASSERT(caddr != NULL);
2892
2893 child = pshot_findchild(parent, cname, caddr);
2894 if (child) {
2895 if (pshot_debug) {
2896 cmn_err(CE_CONT,
2897 "pshot%d: bus_config one %s@%s found\n",
2898 ddi_get_instance(parent), cname, caddr);
2899 }
2900
2901 /*
2902 * create the "pm-want-child-notification?" property
2903 * for this child, if it doesn't already exist
2904 */
2905 (void) pshot_nexus_properties(parent, child, cname, caddr);
2906
2907 return (NDI_SUCCESS);
2908 }
2909
2910 ndi_devi_alloc_sleep(parent, cname, DEVI_SID_NODEID, &child);
2911 ASSERT(child != NULL);
2912
2913 if (ndi_prop_update_string(DDI_DEV_T_NONE, child,
2914 "bus-addr", caddr) != DDI_PROP_SUCCESS) {
2915 cmn_err(CE_WARN, "pshot%d: _prop_update %s@%s failed",
2916 ddi_get_instance(parent), cname, caddr);
2917 (void) ndi_devi_free(child);
2918 return (NDI_FAILURE);
2919 }
2920
2921 rval = ndi_devi_bind_driver(child, 0);
2922 if (rval != NDI_SUCCESS) {
2923 cmn_err(CE_WARN, "pshot%d: bind_driver %s failed",
2924 ddi_get_instance(parent), cname);
2925 (void) ndi_devi_free(child);
2926 return (NDI_FAILURE);
2927 }
2928
2929 /*
2930 * create the "pm-want-child-notification?" property
2931 */
2932 (void) pshot_nexus_properties(parent, child, cname, caddr);
2933
2934 return (NDI_SUCCESS);
2935 }
2936
2937 /*
2938 * BUS_CONFIG_ONE: setup a child leaf device instance.
2939 * for testing purposes, we will create nodes of a variety of types.
2940 */
2941 static int
2942 pshot_bus_config_setup_leaf(dev_info_t *parent, char *cname, char *caddr)
2943 {
2944 dev_info_t *child;
2945 char *compat_name;
2946 char *nodetype;
2947 int rval;
2948 int i;
2949
2950 ASSERT(parent != 0);
2951 ASSERT(cname != NULL);
2952 ASSERT(caddr != NULL);
2953
2954 /*
2955 * if we already have a node with this name, return it
2956 */
2957 if ((child = pshot_findchild(parent, cname, caddr)) != NULL) {
2958 /*
2959 * create the "no-involuntary-power-cycles" or
2960 * the "dependency-property" property, if they
2961 * don't already exit
2962 */
2963 (void) pshot_leaf_properties(parent, child, cname, caddr);
2964
2965 return (NDI_SUCCESS);
2966 }
2967
2968 ndi_devi_alloc_sleep(parent, cname, DEVI_SID_NODEID, &child);
2969 ASSERT(child != NULL);
2970
2971 if (ndi_prop_update_string(DDI_DEV_T_NONE, child, "bus-addr",
2972 caddr) != DDI_PROP_SUCCESS) {
2973 (void) ndi_devi_free(child);
2974 return (NDI_FAILURE);
2975 }
2976
2977 /*
2978 * test compatible naming
2979 * if the child nodename is "cdisk", attach the list of compatible
2980 * named disks
2981 */
2982 if (strcmp(cname, pshot_compat_diskname) == 0) {
2983 if ((ndi_prop_update_string_array(DDI_DEV_T_NONE,
2984 child, "compatible", (char **)pshot_compat_psramdisks,
2985 5)) != DDI_PROP_SUCCESS) {
2986 (void) ndi_devi_free(child);
2987 return (NDI_FAILURE);
2988 }
2989 } else {
2990 for (i = 0; i < pshot_devices_len && pshot_devices[i].name;
2991 i++) {
2992 if (strcmp(cname, pshot_devices[i].name) == 0) {
2993 compat_name = pshot_devices[i].compat;
2994 nodetype = pshot_devices[i].nodetype;
2995 if (pshot_debug) {
2996 cmn_err(CE_CONT, "pshot%d: %s %s %s\n",
2997 ddi_get_instance(parent), cname,
2998 compat_name, nodetype);
2999 }
3000 if ((ndi_prop_update_string_array(
3001 DDI_DEV_T_NONE, child, "compatible",
3002 &compat_name, 1)) != DDI_PROP_SUCCESS) {
3003 (void) ndi_devi_free(child);
3004 return (NDI_FAILURE);
3005 }
3006 if ((ndi_prop_update_string(
3007 DDI_DEV_T_NONE, child, "node-type",
3008 nodetype)) != DDI_PROP_SUCCESS) {
3009 (void) ndi_devi_free(child);
3010 return (NDI_FAILURE);
3011 }
3012 }
3013 }
3014 }
3015
3016 rval = ndi_devi_bind_driver(child, 0);
3017 if (rval != NDI_SUCCESS) {
3018 cmn_err(CE_WARN, "pshot%d: bind_driver %s failed",
3019 ddi_get_instance(parent), cname);
3020 (void) ndi_devi_free(child);
3021 return (NDI_FAILURE);
3022 }
3023
3024 /*
3025 * create the "no-involuntary-power-cycles" or
3026 * the "dependency-property" property
3027 */
3028 (void) pshot_leaf_properties(parent, child, cname, caddr);
3029
3030 return (NDI_SUCCESS);
3031 }
3032
3033 /*
3034 * Handle some special cases for testing bus_config via pshot
3035 *
3036 * Match these special address formats to behavior:
3037 *
3038 * err.* - induce bus_config error
3039 * delay - induce 1 second of bus_config delay time
3040 * delay,n - induce n seconds of bus_config delay time
3041 * wait - induce 1 second of bus_config wait time
3042 * wait,n - induce n seconds of bus_config wait time
3043 * failinit.* - induce error at INITCHILD
3044 * failprobe.* - induce error at probe
3045 * failattach.* - induce error at attach
3046 */
3047 /*ARGSUSED*/
3048 static int
3049 pshot_bus_config_test_specials(dev_info_t *parent, char *devname,
3050 char *cname, char *caddr)
3051 {
3052 char *p;
3053 int n;
3054
3055 if (strncmp(caddr, "err", 3) == 0) {
3056 if (pshot_debug)
3057 cmn_err(CE_CONT,
3058 "pshot%d: %s forced failure\n",
3059 ddi_get_instance(parent), devname);
3060 return (NDI_FAILURE);
3061 }
3062
3063 /*
3064 * The delay and wait strings have the same effect.
3065 * The "wait[,]" support should be removed once the
3066 * devfs test suites are fixed.
3067 * NOTE: delay should not be called from interrupt context
3068 */
3069 ASSERT(!servicing_interrupt());
3070
3071 if (strncmp(caddr, "delay,", 6) == 0) {
3072 p = caddr+6;
3073 n = stoi(&p);
3074 if (*p != 0)
3075 n = 1;
3076 if (pshot_debug)
3077 cmn_err(CE_CONT,
3078 "pshot%d: %s delay %d second\n",
3079 ddi_get_instance(parent), devname, n);
3080 delay(drv_sectohz(n));
3081 } else if (strncmp(caddr, "delay", 5) == 0) {
3082 if (pshot_debug)
3083 cmn_err(CE_CONT,
3084 "pshot%d: %s delay 1 second\n",
3085 ddi_get_instance(parent), devname);
3086 delay(drv_sectohz(1));
3087 } else if (strncmp(caddr, "wait,", 5) == 0) {
3088 p = caddr+5;
3089 n = stoi(&p);
3090 if (*p != 0)
3091 n = 1;
3092 if (pshot_debug)
3093 cmn_err(CE_CONT,
3094 "pshot%d: %s wait %d second\n",
3095 ddi_get_instance(parent), devname, n);
3096 delay(drv_sectohz(n));
3097 } else if (strncmp(caddr, "wait", 4) == 0) {
3098 if (pshot_debug)
3099 cmn_err(CE_CONT,
3100 "pshot%d: %s wait 1 second\n",
3101 ddi_get_instance(parent), devname);
3102 delay(drv_sectohz(1));
3103 }
3104
3105 return (NDI_SUCCESS);
3106 }
3107
3108 /*
3109 * translate nodetype name to actual value
3110 */
3111 static char *
3112 pshot_str2nt(char *str)
3113 {
3114 int i;
3115
3116 for (i = 0; pshot_nodetypes[i].name; i++) {
3117 if (strcmp(pshot_nodetypes[i].name, str) == 0)
3118 return (pshot_nodetypes[i].val);
3119 }
3120 return (NULL);
3121 }
3122
3123 /*
3124 * grows array pointed to by <dstp>, with <src> data
3125 * <dstlen> = # elements of the original <*dstp>
3126 * <srclen> = # elements of <src>
3127 *
3128 * on success, returns 0 and a pointer to the new array through <dstp> with
3129 * <srclen> + <dstlen> number of elements;
3130 * else returns non-zero
3131 *
3132 * a NULL <*dstp> is OK (a NULL <dstp> is not) and so is a zero <dstlen>
3133 */
3134 static int
3135 pshot_devices_grow(pshot_device_t **dstp, size_t dstlen,
3136 const pshot_device_t *src, size_t srclen)
3137 {
3138 size_t i;
3139 pshot_device_t *newdst;
3140
3141 newdst = kmem_alloc((srclen + dstlen) * sizeof (*src),
3142 KM_SLEEP);
3143
3144 /* keep old pointers and dup new ones */
3145 if (*dstp)
3146 bcopy(*dstp, newdst, dstlen * sizeof (*src));
3147 for (i = 0; i < srclen; i++) {
3148 newdst[i + dstlen].name =
3149 i_ddi_strdup(src[i].name, KM_SLEEP);
3150
3151 newdst[i + dstlen].nodetype =
3152 i_ddi_strdup(src[i].nodetype, KM_SLEEP);
3153
3154 newdst[i + dstlen].compat =
3155 i_ddi_strdup(src[i].compat, KM_SLEEP);
3156 }
3157
3158 /* do last */
3159 if (*dstp)
3160 kmem_free(*dstp, dstlen * sizeof (*src));
3161 *dstp = newdst;
3162 return (0);
3163 }
3164
3165 /*
3166 * free a pshot_device_t array <dp> with <len> elements
3167 * null pointers within the elements are ok
3168 */
3169 static void
3170 pshot_devices_free(pshot_device_t *dp, size_t len)
3171 {
3172 size_t i;
3173
3174 for (i = 0; i < len; i++) {
3175 if (dp[i].name)
3176 kmem_free(dp[i].name, strlen(dp[i].name) + 1);
3177 if (dp[i].nodetype)
3178 kmem_free(dp[i].nodetype, strlen(dp[i].nodetype) + 1);
3179 if (dp[i].compat)
3180 kmem_free(dp[i].compat, strlen(dp[i].compat) + 1);
3181 }
3182 kmem_free(dp, len * sizeof (*dp));
3183 }
3184
3185 /*
3186 * returns an array of pshot_device_t parsed from <dip>'s properties
3187 *
3188 * property structure (i.e. pshot.conf) for pshot:
3189 *
3190 * corresponding | pshot_device_t array elements
3191 * pshot_device_t |
3192 * member by prop name | [0] [1] [2]
3193 * ----------------------|--------------|-------------|-----------------------
3194 * <PSHOT_PROP_DEVNAME> ="disk", "tape", "testdev";
3195 * <PSHOT_PROP_DEVNT> ="DDI_NT_BLOCK","DDI_NT_TAPE","ddi_testdev_nodetype";
3196 * <PSHOT_PROP_DEVCOMPAT>="testdrv", "testdrv", "testdrv";
3197 *
3198 *
3199 * if any of these properties are specified, then:
3200 * - all the members must be specified
3201 * - the number of elements for each string array property must be the same
3202 * - no empty strings allowed
3203 * - nodetypes (PSHOT_PROP_DEVNT) must be the nodetype name as specified in
3204 * sys/sunddi.h
3205 *
3206 * NOTE: the pshot_nodetypes[] table should be kept in sync with the list
3207 * of ddi nodetypes. It's not normally critical to always be in sync so
3208 * keeping this up-to-date can usually be done "on-demand".
3209 *
3210 * if <flags> & PSHOT_DEV_ANYNT, then custom nodetype strings are allowed.
3211 * these will be duplicated verbatim
3212 */
3213 static pshot_device_t *
3214 pshot_devices_from_props(dev_info_t *dip, size_t *lenp, int flags)
3215 {
3216 pshot_device_t *devarr = NULL;
3217 char **name_arr = NULL, **nt_arr = NULL, **compat_arr = NULL;
3218 uint_t name_arr_len, nt_arr_len, compat_arr_len;
3219 uint_t i;
3220 char *str;
3221
3222 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip, 0,
3223 PSHOT_PROP_DEVNAME, &name_arr, &name_arr_len) !=
3224 DDI_PROP_SUCCESS)
3225 name_arr = NULL;
3226
3227 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip, 0,
3228 PSHOT_PROP_DEVNT, &nt_arr, &nt_arr_len) !=
3229 DDI_PROP_SUCCESS)
3230 nt_arr = NULL;
3231
3232 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip, 0,
3233 PSHOT_PROP_DEVCOMPAT, &compat_arr, &compat_arr_len) !=
3234 DDI_PROP_SUCCESS)
3235 compat_arr = NULL;
3236
3237 /*
3238 * warn about any incorrect usage, if specified
3239 */
3240 if (!(name_arr || nt_arr || compat_arr))
3241 return (NULL);
3242
3243 if (!(name_arr && nt_arr && compat_arr) ||
3244 (name_arr_len != nt_arr_len) ||
3245 (name_arr_len != compat_arr_len))
3246 goto FAIL;
3247
3248 for (i = 0; i < name_arr_len; i++) {
3249 if (*name_arr[i] == '\0' ||
3250 *nt_arr[i] == '\0' ||
3251 *compat_arr[i] == '\0')
3252 goto FAIL;
3253 }
3254
3255 devarr = kmem_zalloc(name_arr_len * sizeof (*devarr), KM_SLEEP);
3256 for (i = 0; i < name_arr_len; i++) {
3257 devarr[i].name = i_ddi_strdup(name_arr[i], KM_SLEEP);
3258 devarr[i].compat = i_ddi_strdup(compat_arr[i], KM_SLEEP);
3259
3260 if ((str = pshot_str2nt(nt_arr[i])) == NULL)
3261 if (flags & PSHOT_DEV_ANYNT)
3262 str = nt_arr[i];
3263 else
3264 goto FAIL;
3265 devarr[i].nodetype = i_ddi_strdup(str, KM_SLEEP);
3266 }
3267 ddi_prop_free(name_arr);
3268 ddi_prop_free(nt_arr);
3269 ddi_prop_free(compat_arr);
3270
3271 /* set <*lenp> ONLY on success */
3272 *lenp = name_arr_len;
3273
3274 return (devarr);
3275 /*NOTREACHED*/
3276 FAIL:
3277 cmn_err(CE_WARN, "malformed device specification property");
3278 if (name_arr)
3279 ddi_prop_free(name_arr);
3280 if (nt_arr)
3281 ddi_prop_free(nt_arr);
3282 if (compat_arr)
3283 ddi_prop_free(compat_arr);
3284 if (devarr)
3285 pshot_devices_free(devarr, name_arr_len);
3286 return (NULL);
3287 }
3288
3289 /*
3290 * if global <pshot_devices> was not set up already (i.e. is NULL):
3291 * sets up global <pshot_devices> and <pshot_devices_len>,
3292 * using device properties from <dip> and global <pshot_stock_devices>.
3293 * device properties, if any, overrides pshot_stock_devices.
3294 *
3295 * returns 0 on success (or if pshot_devices already set up)
3296 *
3297 * INTERNAL LOCKING: <pshot_devices_lock>
3298 */
3299 static int
3300 pshot_devices_setup(dev_info_t *dip)
3301 {
3302 pshot_device_t *newdevs = NULL;
3303 size_t newdevs_len = 0;
3304 int rv = 0;
3305
3306 mutex_enter(&pshot_devices_lock);
3307 if (pshot_devices != NULL)
3308 goto FAIL;
3309
3310 ASSERT(pshot_devices_len == 0);
3311
3312 newdevs = pshot_devices_from_props(dip, &newdevs_len, PSHOT_DEV_ANYNT);
3313 rv = pshot_devices_grow(&newdevs, newdevs_len, pshot_stock_devices,
3314 PSHOT_N_STOCK_DEVICES);
3315 if (rv != 0) {
3316 cmn_err(CE_WARN, "pshot_devices_setup: pshot_devices_grow "
3317 "failed");
3318 goto FAIL;
3319 }
3320 newdevs_len += PSHOT_N_STOCK_DEVICES;
3321
3322 pshot_devices = newdevs;
3323 pshot_devices_len = newdevs_len;
3324 rv = 0;
3325 FAIL:
3326 if (rv && newdevs)
3327 pshot_devices_free(newdevs, newdevs_len);
3328 mutex_exit(&pshot_devices_lock);
3329 return (rv);
3330 }
3331
3332
3333 #ifdef NOTNEEDED
3334 /* ARGSUSED */
3335 static int
3336 pshot_probe_family(dev_info_t *self, ddi_probe_method_t probe_how,
3337 dev_info_t **return_dip)
3338 {
3339 char name[64];
3340 uint_t bus_id;
3341 dev_info_t *child;
3342
3343 for (bus_id = 10; bus_id < 20; bus_id++) {
3344 (void) sprintf(name, "%d", bus_id);
3345 if ((ndi_devi_alloc(self, "psramd", DEVI_SID_NODEID,
3346 &child)) != NDI_SUCCESS) {
3347 return (DDI_FAILURE);
3348 }
3349
3350 if (ndi_prop_update_string(DDI_DEV_T_NONE, child,
3351 "bus-addr", name) != DDI_PROP_SUCCESS) {
3352 (void) ndi_devi_free(child);
3353 if (return_dip != NULL)
3354 *return_dip = (dev_info_t *)NULL;
3355 return (DDI_FAILURE);
3356 }
3357
3358 if (ndi_devi_online(child, 0) != NDI_SUCCESS) {
3359 return (DDI_FAILURE);
3360 }
3361 }
3362 return (DDI_SUCCESS);
3363 }
3364
3365 static int
3366 strtoi(char *str)
3367 {
3368 int c;
3369 int val;
3370
3371 for (val = 0, c = *str++; c >= '0' && c <= '9'; c = *str++) {
3372 val *= 10;
3373 val += c - '0';
3374 }
3375 return (val);
3376 }
3377
3378 #endif
3379
3380 static void
3381 pshot_setup_autoattach(dev_info_t *devi)
3382 {
3383 dev_info_t *l1child, *l2child;
3384 int rv;
3385
3386 rv = ndi_devi_alloc(devi, "pshot", DEVI_SID_NODEID, &l1child);
3387 if (rv == NDI_SUCCESS) {
3388 (void) ndi_prop_update_string(DDI_DEV_T_NONE, l1child,
3389 "bus-addr", "0");
3390 rv = ndi_devi_alloc(l1child, "port", DEVI_SID_NODEID,
3391 &l2child);
3392 if (rv == NDI_SUCCESS)
3393 (void) ndi_prop_update_string(DDI_DEV_T_NONE,
3394 l2child, "bus-addr", "99");
3395 }
3396
3397 rv = ndi_devi_alloc(devi, "port", DEVI_SID_NODEID, &l1child);
3398 if (rv == NDI_SUCCESS)
3399 (void) ndi_prop_update_string(DDI_DEV_T_NONE, l1child,
3400 "bus-addr", "99");
3401
3402 rv = ndi_devi_alloc(devi, "gen_drv", DEVI_SID_NODEID, &l1child);
3403 if (rv == NDI_SUCCESS)
3404 (void) ndi_prop_update_string(DDI_DEV_T_NONE, l1child,
3405 "bus-addr", "99");
3406
3407 rv = ndi_devi_alloc(devi, "no_driver", DEVI_SID_NODEID, &l1child);
3408 if (rv == NDI_SUCCESS)
3409 (void) ndi_devi_alloc(l1child, "no_driver", DEVI_SID_NODEID,
3410 &l2child);
3411 }
3412
3413 #ifdef PRUNE_SNUBS
3414
3415 #define PRUNE_THIS_NODE(d) (((d)->devi_node_name != NULL) && \
3416 (DEVI_PROM_NODE((d)->devi_nodeid)) && \
3417 ((d)->devi_addr == NULL))
3418 /*
3419 * test code to remove OBP nodes that have not attached
3420 */
3421 static void
3422 prune_snubs(const char *name)
3423 {
3424 struct dev_info *nex_dip, *cdip, *cndip;
3425 int maj;
3426 int rv;
3427
3428 maj = ddi_name_to_major((char *)name);
3429 if (maj != -1) {
3430 nex_dip = (struct dev_info *)devnamesp[maj].dn_head;
3431 while (nex_dip != NULL) {
3432 cndip = ddi_get_child(nex_dip);
3433 while ((cdip = cndip) != NULL) {
3434 cndip = cdip->devi_sibling;
3435 if (PRUNE_THIS_NODE(cdip)) {
3436 cmn_err(CE_NOTE,
3437 "parent %s@%s pruning node %s",
3438 nex_dip->devi_node_name,
3439 nex_dip->devi_addr,
3440 cdip->devi_node_name);
3441 rv = ndi_devi_offline(cdip,
3442 NDI_DEVI_REMOVE);
3443 if (rv != NDI_SUCCESS)
3444 cmn_err(CE_NOTE,
3445 "failed to prune node, "
3446 "err %d", rv);
3447 }
3448 }
3449 nex_dip = nex_dip->devi_next;
3450 }
3451 }
3452 }
3453
3454 #endif /* PRUBE_SNUBS */
3455
3456 #ifdef KERNEL_DEVICE_TREE_WALKER
3457 static kthread_id_t pwt;
3458 static kmutex_t pwl;
3459 static kcondvar_t pwcv;
3460
3461 static void
3462 pshot_walk_tree()
3463 {
3464 static int pshot_devnode(dev_info_t *dip, void * arg);
3465
3466 dev_info_t *root = ddi_root_node();
3467 ddi_walk_devs(root, pshot_devnode, NULL);
3468 }
3469
3470 static void
3471 pshot_walk_thread()
3472 {
3473 static void pshot_timeout(void *arg);
3474 static kthread_id_t pwt;
3475
3476 pwt = curthread;
3477 mutex_init(&pwl, NULL, MUTEX_DRIVER, NULL);
3478 cv_init(&pwcv, NULL, CV_DRIVER, NULL);
3479
3480 while (1) {
3481 pshot_walk_tree();
3482 mutex_enter(&pwl);
3483 (void) timeout(pshot_timeout, NULL, drv_sectohz(5));
3484 cv_wait(&pwcv, &pwl);
3485 mutex_exit(&pwl);
3486 }
3487 }
3488
3489 static void
3490 pshot_timeout(void *arg)
3491 {
3492 mutex_enter(&pwl);
3493 cv_signal(&pwcv);
3494 mutex_exit(&pwl);
3495 }
3496
3497 static int
3498 pshot_devnode(dev_info_t *dip, void *arg)
3499 {
3500 dev_info_t *f_dip;
3501
3502 if (dip != ddi_root_node()) {
3503 f_dip = ndi_devi_find((dev_info_t *)DEVI(dip)->devi_parent,
3504 DEVI(dip)->devi_node_name, DEVI(dip)->devi_addr);
3505 if (f_dip != dip) {
3506 cmn_err(CE_NOTE, "!pshot_devnode: failed lookup"
3507 "node (%s/%s@%s)\n",
3508 DEVI(DEVI(dip)->devi_parent)->devi_node_name,
3509 (DEVI(dip)->devi_node_name ?
3510 DEVI(dip)->devi_node_name : "NULL"),
3511 (DEVI(dip)->devi_addr ? DEVI(dip)->devi_addr :
3512 "NULL"));
3513 }
3514 }
3515 return (DDI_WALK_CONTINUE);
3516 }
3517 #endif /* KERNEL_DEVICE_TREE_WALKER */
3518
3519 #ifdef DEBUG
3520 static void
3521 pshot_event_cb_test(dev_info_t *dip, ddi_eventcookie_t cookie,
3522 void *arg, void *bus_impldata)
3523 {
3524 pshot_t *softstate = (pshot_t *)arg;
3525 int event_tag;
3526
3527 /* look up the event */
3528 event_tag = NDI_EVENT_TAG(cookie);
3529 cmn_err(CE_CONT, "pshot_event_cb_test:\n\t"
3530 "dip = 0x%p cookie = 0x%p (%s), tag = %d\n\t"
3531 "arg = 0x%p bus_impl = 0x%p\n",
3532 (void *)dip, (void *)cookie, NDI_EVENT_NAME(cookie),
3533 event_tag, (void *)softstate, (void *)bus_impldata);
3534
3535 }
3536
3537 static void
3538 pshot_event_test(void *arg)
3539 {
3540 pshot_t *pshot = (pshot_t *)arg;
3541 ndi_event_hdl_t hdl;
3542 ndi_event_set_t events;
3543 int i, rval;
3544
3545 (void) ndi_event_alloc_hdl(pshot->dip, NULL, &hdl, NDI_SLEEP);
3546
3547 events.ndi_events_version = NDI_EVENTS_REV1;
3548 events.ndi_n_events = PSHOT_N_TEST_EVENTS;
3549 events.ndi_event_defs = pshot_test_events;
3550
3551 cmn_err(CE_CONT, "pshot: binding set of 8 events\n");
3552 delay(drv_sectohz(1));
3553 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3554 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3555
3556 cmn_err(CE_CONT, "pshot: binding the same set of 8 events\n");
3557 delay(drv_sectohz(1));
3558 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3559 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3560
3561 cmn_err(CE_CONT, "pshot: unbinding all events\n");
3562 delay(drv_sectohz(1));
3563 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3564 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3565
3566
3567 cmn_err(CE_CONT, "pshot: binding one highlevel event\n");
3568 delay(drv_sectohz(1));
3569 events.ndi_n_events = 1;
3570 events.ndi_event_defs = pshot_test_events_high;
3571 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3572 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3573
3574 cmn_err(CE_CONT, "pshot: binding the same set of 8 events\n");
3575 delay(drv_sectohz(1));
3576 events.ndi_n_events = PSHOT_N_TEST_EVENTS;
3577 events.ndi_event_defs = pshot_test_events;
3578 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3579 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3580
3581 cmn_err(CE_CONT, "pshot: unbinding one highlevel event\n");
3582 delay(drv_sectohz(1));
3583 events.ndi_n_events = 1;
3584 events.ndi_event_defs = pshot_test_events_high;
3585 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3586 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3587
3588 cmn_err(CE_CONT, "pshot: binding one highlevel event\n");
3589 delay(drv_sectohz(1));
3590 events.ndi_n_events = 1;
3591 events.ndi_event_defs = pshot_test_events_high;
3592 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3593 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3594
3595 cmn_err(CE_CONT, "pshot: unbinding one highlevel event\n");
3596 delay(drv_sectohz(1));
3597 events.ndi_n_events = 1;
3598 events.ndi_event_defs = pshot_test_events_high;
3599 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3600 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3601
3602 cmn_err(CE_CONT, "pshot: binding the same set of 8 events\n");
3603 delay(drv_sectohz(1));
3604 events.ndi_n_events = PSHOT_N_TEST_EVENTS;
3605 events.ndi_event_defs = pshot_test_events;
3606 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3607 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3608
3609 cmn_err(CE_CONT, "pshot: unbinding first 2 events\n");
3610 delay(drv_sectohz(1));
3611 events.ndi_n_events = 2;
3612 events.ndi_event_defs = pshot_test_events;
3613 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3614 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3615
3616 cmn_err(CE_CONT, "pshot: unbinding first 2 events again\n");
3617 delay(drv_sectohz(1));
3618 events.ndi_n_events = 2;
3619 events.ndi_event_defs = pshot_test_events;
3620 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3621 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3622
3623 cmn_err(CE_CONT, "pshot: unbinding middle 2 events\n");
3624 delay(drv_sectohz(1));
3625 events.ndi_n_events = 2;
3626 events.ndi_event_defs = &pshot_test_events[4];
3627 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3628 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3629
3630 cmn_err(CE_CONT, "pshot: binding those 2 events back\n");
3631 delay(drv_sectohz(1));
3632 events.ndi_n_events = 2;
3633 events.ndi_event_defs = &pshot_test_events[4];
3634 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3635 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3636
3637 cmn_err(CE_CONT, "pshot: unbinding 2 events\n");
3638 delay(drv_sectohz(1));
3639 events.ndi_n_events = 2;
3640 events.ndi_event_defs = &pshot_test_events[4];
3641 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3642 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3643
3644 cmn_err(CE_CONT, "pshot: unbinding all events\n");
3645 delay(drv_sectohz(1));
3646 events.ndi_n_events = PSHOT_N_TEST_EVENTS;
3647 events.ndi_event_defs = pshot_test_events;
3648 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3649 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3650
3651 cmn_err(CE_CONT, "pshot: unbinding 1 event\n");
3652 delay(drv_sectohz(1));
3653 events.ndi_n_events = 1;
3654 events.ndi_event_defs = &pshot_test_events[2];
3655 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3656 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3657
3658 cmn_err(CE_CONT, "pshot: unbinding 1 event\n");
3659 delay(drv_sectohz(1));
3660 events.ndi_n_events = 1;
3661 events.ndi_event_defs = &pshot_test_events[3];
3662 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3663 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3664
3665 cmn_err(CE_CONT, "pshot: unbinding 1 event\n");
3666 delay(drv_sectohz(1));
3667 events.ndi_n_events = 1;
3668 events.ndi_event_defs = &pshot_test_events[6];
3669 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3670 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3671
3672 cmn_err(CE_CONT, "pshot: unbinding 1 event\n");
3673 delay(drv_sectohz(1));
3674 events.ndi_n_events = 1;
3675 events.ndi_event_defs = &pshot_test_events[7];
3676 rval = ndi_event_unbind_set(hdl, &events, NDI_SLEEP);
3677 cmn_err(CE_CONT, "pshot: ndi_event_unbind_set rval = %d\n", rval);
3678
3679 events.ndi_n_events = PSHOT_N_TEST_EVENTS;
3680 events.ndi_event_defs = pshot_test_events;
3681
3682 cmn_err(CE_CONT, "pshot: binding set of 8 events\n");
3683 delay(drv_sectohz(1));
3684 rval = ndi_event_bind_set(hdl, &events, NDI_SLEEP);
3685 cmn_err(CE_CONT, "pshot: ndi_event_bind_set rval = %d\n", rval);
3686
3687 cmn_err(CE_CONT, "pshot: adding 8 callbacks\n");
3688 delay(drv_sectohz(1));
3689 for (i = 0; i < 8; i++) {
3690 rval = ndi_event_add_callback(hdl, pshot->dip,
3691 ndi_event_tag_to_cookie(hdl,
3692 pshot_test_events[i].ndi_event_tag),
3693 pshot_event_cb_test,
3694 (void *)(uintptr_t)pshot_test_events[i].ndi_event_tag,
3695 NDI_SLEEP, &pshot->test_callback_cache[i]);
3696 ASSERT(rval == NDI_SUCCESS);
3697 }
3698
3699 cmn_err(CE_CONT, "pshot: event callbacks\n");
3700
3701 for (i = 10; i < 18; i++) {
3702 ddi_eventcookie_t cookie = ndi_event_tag_to_cookie(hdl, i);
3703
3704 rval = ndi_event_run_callbacks(hdl, pshot->dip, cookie,
3705 (void *)hdl);
3706
3707 cmn_err(CE_CONT, "pshot: callback, tag=%d rval=%d\n",
3708 i, rval);
3709 delay(drv_sectohz(1));
3710 }
3711
3712 cmn_err(CE_CONT, "pshot: redo event callbacks\n");
3713
3714 for (i = 10; i < 18; i++) {
3715 ddi_eventcookie_t cookie = ndi_event_tag_to_cookie(hdl, i);
3716
3717 rval = ndi_event_run_callbacks(hdl,
3718 pshot->dip, cookie, (void *)hdl);
3719
3720 cmn_err(CE_CONT, "pshot: callback, tag=%d rval=%d\n",
3721 i, rval);
3722 delay(drv_sectohz(1));
3723 }
3724
3725 cmn_err(CE_CONT, "pshot: removing 8 callbacks\n");
3726 delay(drv_sectohz(1));
3727
3728 for (i = 0; i < 8; i++) {
3729 (void) ndi_event_remove_callback(hdl,
3730 pshot->test_callback_cache[i]);
3731
3732 pshot->test_callback_cache[i] = 0;
3733 }
3734
3735 cmn_err(CE_CONT, "pshot: freeing handle with bound set\n");
3736 delay(drv_sectohz(1));
3737
3738 rval = ndi_event_free_hdl(hdl);
3739
3740 ASSERT(rval == NDI_SUCCESS);
3741
3742 }
3743
3744 void
3745 pshot_event_test_post_one(void *arg)
3746 {
3747 pshot_t *pshot = (pshot_t *)arg;
3748 int rval;
3749 ddi_eventcookie_t cookie;
3750
3751 cmn_err(CE_CONT, "pshot%d: pshot_event_post_one event\n",
3752 pshot->instance);
3753
3754 if (ddi_get_eventcookie(pshot->dip, PSHOT_EVENT_NAME_BUS_TEST_POST,
3755 &cookie) != DDI_SUCCESS) {
3756 cmn_err(CE_NOTE, "pshot_bus_test_post cookie not found");
3757 return;
3758 }
3759
3760 rval = ndi_post_event(pshot->dip, pshot->dip, cookie, NULL);
3761
3762 cmn_err(CE_CONT, "pshot%d: pshot_event_post_one rval=%d\n",
3763 pshot->instance, rval);
3764
3765 (void) timeout(pshot_event_test_post_one, (void *)pshot,
3766 pshot->instance * drv_usectohz(60000000));
3767
3768 }
3769 #endif /* DEBUG */