xref: /titanic_52/usr/src/uts/common/xen/io/xpvd.c (revision c0dd49bdd68c0d758a67d56f07826f3b45cfc664)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  *	Host to hypervisor virtual devices nexus driver
29  *
30  * TODO:
31  * - Add watchpoints on vbd/vif and enumerate/offline on watch callback
32  * - Add DR IOCTLs
33  * - Filter/restrict property lookups into xenstore
34  */
35 
36 #include <sys/conf.h>
37 #include <sys/kmem.h>
38 #include <sys/debug.h>
39 #include <sys/modctl.h>
40 #include <sys/autoconf.h>
41 #include <sys/ddi_impldefs.h>
42 #include <sys/ddi_subrdefs.h>
43 #include <sys/ddi.h>
44 #include <sys/sunddi.h>
45 #include <sys/sunndi.h>
46 #include <sys/avintr.h>
47 #include <sys/psm.h>
48 #include <sys/spl.h>
49 #include <sys/promif.h>
50 #include <sys/list.h>
51 #include <sys/bootconf.h>
52 #include <sys/bootsvcs.h>
53 #include <util/sscanf.h>
54 #include <sys/mach_intr.h>
55 #include <sys/bootinfo.h>
56 #ifdef XPV_HVM_DRIVER
57 #include <sys/xpv_support.h>
58 #include <sys/hypervisor.h>
59 #include <sys/archsystm.h>
60 #include <sys/cpu.h>
61 #include <public/xen.h>
62 #include <public/event_channel.h>
63 #include <public/io/xenbus.h>
64 #else
65 #include <sys/hypervisor.h>
66 #include <sys/evtchn_impl.h>
67 #include <sys/xen_mmu.h>
68 #endif
69 #include <xen/sys/xenbus_impl.h>
70 #include <xen/sys/xendev.h>
71 
72 /*
73  * DDI dev_ops entrypoints
74  */
75 static int xpvd_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
76 static int xpvd_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
77 static int xpvd_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
78 
79 
80 /*
81  * NDI bus_ops entrypoints
82  */
83 static int xpvd_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *,
84 	void *);
85 static int xpvd_intr_ops(dev_info_t *, dev_info_t *, ddi_intr_op_t,
86 	ddi_intr_handle_impl_t *, void *);
87 static int xpvd_prop_op(dev_t, dev_info_t *, dev_info_t *, ddi_prop_op_t,
88 	int, char *, caddr_t, int *);
89 static int xpvd_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t,
90 	void *, dev_info_t **);
91 static int xpvd_bus_unconfig(dev_info_t *, uint_t, ddi_bus_config_op_t,
92     void *);
93 static int xpvd_get_eventcookie(dev_info_t *, dev_info_t *,
94     char *, ddi_eventcookie_t *);
95 static int xpvd_add_eventcall(dev_info_t *, dev_info_t *,
96     ddi_eventcookie_t, void (*)(dev_info_t *,
97     ddi_eventcookie_t, void *, void *),
98     void *, ddi_callback_id_t *);
99 static int xpvd_remove_eventcall(dev_info_t *, ddi_callback_id_t);
100 static int xpvd_post_event(dev_info_t *, dev_info_t *,
101     ddi_eventcookie_t, void *);
102 
103 /*
104  * misc functions
105  */
106 static int xpvd_enable_intr(dev_info_t *, ddi_intr_handle_impl_t *, int);
107 static void xpvd_disable_intr(dev_info_t *, ddi_intr_handle_impl_t *, int);
108 static int xpvd_removechild(dev_info_t *);
109 static int xpvd_initchild(dev_info_t *);
110 static int xpvd_name_child(dev_info_t *, char *, int);
111 static boolean_t i_xpvd_parse_devname(char *, xendev_devclass_t *,
112     domid_t *, int *);
113 
114 
115 /* Extern declarations */
116 extern int (*psm_intr_ops)(dev_info_t *, ddi_intr_handle_impl_t *,
117     psm_intr_op_t, int *);
118 
119 struct bus_ops xpvd_bus_ops = {
120 	BUSO_REV,
121 	i_ddi_bus_map,
122 	NULL,
123 	NULL,
124 	NULL,
125 	i_ddi_map_fault,
126 	ddi_dma_map,
127 	ddi_dma_allochdl,
128 	ddi_dma_freehdl,
129 	ddi_dma_bindhdl,
130 	ddi_dma_unbindhdl,
131 	ddi_dma_flush,
132 	ddi_dma_win,
133 	ddi_dma_mctl,
134 	xpvd_ctlops,
135 	xpvd_prop_op,
136 	xpvd_get_eventcookie,
137 	xpvd_add_eventcall,
138 	xpvd_remove_eventcall,
139 	xpvd_post_event,
140 	0,		/* (*bus_intr_ctl)(); */
141 	xpvd_bus_config,
142 	xpvd_bus_unconfig,
143 	NULL,		/* (*bus_fm_init)(); */
144 	NULL,		/* (*bus_fm_fini)(); */
145 	NULL,		/* (*bus_fm_access_enter)(); */
146 	NULL,		/* (*bus_fm_access_exit)(); */
147 	NULL,		/* (*bus_power)(); */
148 	xpvd_intr_ops	/* (*bus_intr_op)(); */
149 };
150 
151 struct dev_ops xpvd_ops = {
152 	DEVO_REV,		/* devo_rev */
153 	0,			/* refcnt  */
154 	xpvd_info,		/* info */
155 	nulldev,		/* identify */
156 	nulldev,		/* probe */
157 	xpvd_attach,		/* attach */
158 	xpvd_detach,		/* detach */
159 	nulldev,		/* reset */
160 	(struct cb_ops *)0,	/* driver operations */
161 	&xpvd_bus_ops,		/* bus operations */
162 	NULL,			/* power */
163 	ddi_quiesce_not_needed,		/* quiesce */
164 };
165 
166 
167 dev_info_t *xpvd_dip;
168 
169 #define	CF_DBG		0x1
170 #define	ALL_DBG		0xff
171 
172 static ndi_event_definition_t xpvd_ndi_event_defs[] = {
173 	{ 0, XS_OE_STATE, EPL_KERNEL, NDI_EVENT_POST_TO_TGT },
174 	{ 1, XS_HP_STATE, EPL_KERNEL, NDI_EVENT_POST_TO_TGT },
175 };
176 
177 #define	XENDEV_N_NDI_EVENTS \
178 	(sizeof (xpvd_ndi_event_defs) / sizeof (xpvd_ndi_event_defs[0]))
179 
180 static ndi_event_set_t xpvd_ndi_events = {
181 	NDI_EVENTS_REV1, XENDEV_N_NDI_EVENTS, xpvd_ndi_event_defs
182 };
183 
184 static ndi_event_hdl_t xpvd_ndi_event_handle;
185 
186 /*
187  * Hypervisor interrupt capabilities
188  */
189 #define	XENDEV_INTR_CAPABILITIES \
190 	(DDI_INTR_FLAG_EDGE | DDI_INTR_FLAG_MASKABLE | DDI_INTR_FLAG_PENDING)
191 
192 /*
193  * Module linkage information for the kernel.
194  */
195 
196 static struct modldrv modldrv = {
197 	&mod_driverops, /* Type of module */
198 	"virtual device nexus driver",
199 	&xpvd_ops,	/* driver ops */
200 };
201 
202 static struct modlinkage modlinkage = {
203 	MODREV_1,
204 	(void *)&modldrv,
205 	NULL
206 };
207 
208 int
209 _init(void)
210 {
211 	return (mod_install(&modlinkage));
212 }
213 
214 int
215 _fini(void)
216 {
217 	return (mod_remove(&modlinkage));
218 }
219 
220 int
221 _info(struct modinfo *modinfop)
222 {
223 	return (mod_info(&modlinkage, modinfop));
224 }
225 
226 /* ARGSUSED */
227 static int
228 xpvd_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
229 {
230 	switch (cmd) {
231 	default:
232 		return (DDI_FAILURE);
233 
234 	case DDI_INFO_DEVT2INSTANCE:
235 		*result = (void *)0;
236 		return (DDI_SUCCESS);
237 
238 	case DDI_INFO_DEVT2DEVINFO:
239 		*result = (void *)xpvd_dip;
240 		return (DDI_SUCCESS);
241 	}
242 }
243 
244 /*ARGSUSED*/
245 static int
246 xpvd_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
247 {
248 	extern void xvdi_watch_devices(int);
249 #ifdef XPV_HVM_DRIVER
250 	extern dev_info_t *xpv_dip;
251 
252 	if (xpv_dip == NULL) {
253 		if (ddi_hold_installed_driver(ddi_name_to_major("xpv")) ==
254 		    NULL) {
255 			cmn_err(CE_WARN, "Couldn't initialize xpv framework");
256 			return (DDI_FAILURE);
257 		}
258 	}
259 #endif /* XPV_HVM_DRIVER */
260 
261 	if (ndi_event_alloc_hdl(devi, 0, &xpvd_ndi_event_handle,
262 	    NDI_SLEEP) != NDI_SUCCESS) {
263 		xpvd_dip = NULL;
264 		return (DDI_FAILURE);
265 	}
266 	if (ndi_event_bind_set(xpvd_ndi_event_handle, &xpvd_ndi_events,
267 	    NDI_SLEEP) != NDI_SUCCESS) {
268 		(void) ndi_event_free_hdl(xpvd_ndi_event_handle);
269 		xpvd_dip = NULL;
270 		return (DDI_FAILURE);
271 	}
272 
273 #ifdef XPV_HVM_DRIVER
274 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, devi, DDI_NO_AUTODETACH, 1);
275 
276 	/*
277 	 * Report our version to dom0.
278 	 */
279 	if (xenbus_printf(XBT_NULL, "guest/xpvd", "version", "%d",
280 	    HVMPV_XPVD_VERS))
281 		cmn_err(CE_WARN, "xpvd: couldn't write version\n");
282 #endif /* XPV_HVM_DRIVER */
283 
284 	/* watch both frontend and backend for new devices */
285 	if (DOMAIN_IS_INITDOMAIN(xen_info))
286 		(void) xs_register_xenbus_callback(xvdi_watch_devices);
287 	else
288 		xvdi_watch_devices(XENSTORE_UP);
289 
290 	xpvd_dip = devi;
291 	ddi_report_dev(devi);
292 
293 	return (DDI_SUCCESS);
294 }
295 
296 /*ARGSUSED*/
297 static int
298 xpvd_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
299 {
300 	return (DDI_FAILURE);
301 }
302 
303 /*
304  * xpvd_prop_op()
305  *
306  * Query xenstore for the value of properties if DDI_PROP_NOTPROM
307  * is not set.  Xenstore property values are represented as ascii strings.
308  */
309 static int
310 xpvd_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
311     ddi_prop_op_t prop_op, int mod_flags, char *name, caddr_t valuep,
312     int *lengthp)
313 {
314 	caddr_t buff;
315 	struct xendev_ppd *pdp;
316 	void *prop_str;
317 	size_t prop_len;
318 	unsigned int len;
319 	int rv;
320 
321 	pdp = (struct xendev_ppd *)ddi_get_parent_data(ch_dip);
322 
323 	if ((pdp == NULL) || !(mod_flags & (DDI_PROP_CANSLEEP)) ||
324 	    (mod_flags & DDI_PROP_NOTPROM) || (pdp->xd_xsdev.nodename == NULL))
325 		goto toss_off;
326 	/*
327 	 * First try reading the property off the the frontend. if that
328 	 * fails, try and read it from the backend node.  If that
329 	 * also fails, pass the request on the DDI framework
330 	 */
331 	prop_str = NULL;
332 	if ((xenbus_read(XBT_NULL, pdp->xd_xsdev.nodename, name, &prop_str,
333 	    &len) == 0) && (prop_str != NULL) && (strlen(prop_str) != 0))
334 		goto got_xs_prop;
335 
336 	prop_str = NULL;
337 	if ((pdp->xd_xsdev.otherend != NULL) &&
338 	    (xenbus_read(XBT_NULL, pdp->xd_xsdev.otherend, name, &prop_str,
339 	    &len) == 0) && (prop_str != NULL) && (strlen(prop_str) != 0))
340 		goto got_xs_prop;
341 
342 toss_off:
343 	return (ddi_bus_prop_op(dev, dip, ch_dip, prop_op,
344 	    mod_flags | DDI_PROP_NOTPROM, name, valuep, lengthp));
345 
346 got_xs_prop:
347 	prop_len = strlen(prop_str) + 1;
348 	rv = DDI_PROP_SUCCESS;
349 
350 	switch (prop_op) {
351 	case PROP_LEN:
352 		*lengthp = prop_len;
353 		break;
354 
355 	case PROP_LEN_AND_VAL_ALLOC:
356 		buff = kmem_alloc((size_t)prop_len, KM_SLEEP);
357 		*(caddr_t *)valuep = (caddr_t)buff;
358 		break;
359 	case PROP_LEN_AND_VAL_BUF:
360 		buff = (caddr_t)valuep;
361 		if (*lengthp < prop_len)
362 			rv = DDI_PROP_BUF_TOO_SMALL;
363 		break;
364 	default:
365 		rv = DDI_PROP_INVAL_ARG;
366 		break;
367 	}
368 
369 	if ((rv == DDI_PROP_SUCCESS) && (prop_len > 0)) {
370 		bcopy(prop_str, buff, prop_len);
371 		*lengthp = prop_len;
372 	}
373 	kmem_free(prop_str, len);
374 	return (rv);
375 }
376 
377 
378 /*
379  * return address of the device's interrupt spec structure.
380  */
381 /*ARGSUSED*/
382 struct intrspec *
383 xpvd_get_ispec(dev_info_t *rdip, uint_t inumber)
384 {
385 	struct xendev_ppd *pdp;
386 
387 	ASSERT(inumber == 0);
388 
389 	if ((pdp = ddi_get_parent_data(rdip)) == NULL)
390 		return (NULL);
391 
392 	return (&pdp->xd_ispec);
393 }
394 
395 /*
396  * return (and determine) the interrupt priority of the device.
397  */
398 /*ARGSUSED*/
399 static int
400 xpvd_get_priority(dev_info_t *dip, int inum, int *pri)
401 {
402 	struct xendev_ppd *pdp;
403 	struct intrspec *ispec;
404 	int	*intpriorities;
405 	uint_t	num_intpriorities;
406 
407 	DDI_INTR_NEXDBG((CE_CONT, "xpvd_get_priority: dip = 0x%p\n",
408 	    (void *)dip));
409 
410 	ASSERT(inum == 0);
411 
412 	if ((pdp = ddi_get_parent_data(dip)) == NULL)
413 		return (DDI_FAILURE);
414 
415 	ispec = &pdp->xd_ispec;
416 
417 	/*
418 	 * Set the default priority based on the device class.  The
419 	 * "interrupt-priorities" property can be used to override
420 	 * the default.
421 	 */
422 	if (ispec->intrspec_pri == 0) {
423 		ispec->intrspec_pri = xendev_devclass_ipl(pdp->xd_devclass);
424 		if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
425 		    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
426 		    "interrupt-priorities", &intpriorities,
427 		    &num_intpriorities) == DDI_PROP_SUCCESS) {
428 			ispec->intrspec_pri = intpriorities[0];
429 			ddi_prop_free(intpriorities);
430 		}
431 	}
432 	*pri = ispec->intrspec_pri;
433 	return (DDI_SUCCESS);
434 }
435 
436 
437 /*
438  * xpvd_intr_ops: bus_intr_op() function for interrupt support
439  */
440 /* ARGSUSED */
441 static int
442 xpvd_intr_ops(dev_info_t *pdip, dev_info_t *rdip, ddi_intr_op_t intr_op,
443     ddi_intr_handle_impl_t *hdlp, void *result)
444 {
445 	int priority = 0;
446 	struct intrspec *ispec;
447 	struct xendev_ppd *pdp;
448 
449 	DDI_INTR_NEXDBG((CE_CONT,
450 	    "xpvd_intr_ops: pdip 0x%p, rdip 0x%p, op %x handle 0x%p\n",
451 	    (void *)pdip, (void *)rdip, intr_op, (void *)hdlp));
452 
453 	/* Process the request */
454 	switch (intr_op) {
455 	case DDI_INTROP_SUPPORTED_TYPES:
456 		/* Fixed supported by default */
457 		*(int *)result = DDI_INTR_TYPE_FIXED;
458 		break;
459 
460 	case DDI_INTROP_NINTRS:
461 		*(int *)result = 1;
462 		break;
463 
464 	case DDI_INTROP_ALLOC:
465 		/*
466 		 * FIXED interrupts: just return available interrupts
467 		 */
468 		if (hdlp->ih_type == DDI_INTR_TYPE_FIXED) {
469 			/*
470 			 * event channels are edge-triggered, maskable,
471 			 * and support int pending.
472 			 */
473 			hdlp->ih_cap |= XENDEV_INTR_CAPABILITIES;
474 			*(int *)result = 1;	/* DDI_INTR_TYPE_FIXED */
475 		} else {
476 			return (DDI_FAILURE);
477 		}
478 		break;
479 
480 	case DDI_INTROP_FREE:
481 		ispec = xpvd_get_ispec(rdip, (int)hdlp->ih_inum);
482 		if (ispec == NULL)
483 			return (DDI_FAILURE);
484 		ispec->intrspec_pri = 0; /* mark as un-initialized */
485 		break;
486 
487 	case DDI_INTROP_GETPRI:
488 		if (xpvd_get_priority(rdip, hdlp->ih_inum, &priority) !=
489 		    DDI_SUCCESS)
490 			return (DDI_FAILURE);
491 		DDI_INTR_NEXDBG((CE_CONT, "xpvd_intr_ops: priority = 0x%x\n",
492 		    priority));
493 		*(int *)result = priority;
494 		break;
495 
496 	case DDI_INTROP_SETPRI:
497 		/* Validate the interrupt priority passed */
498 		if (*(int *)result > LOCK_LEVEL)
499 			return (DDI_FAILURE);
500 
501 		/* Ensure that PSM is all initialized */
502 		if (psm_intr_ops == NULL)
503 			return (DDI_FAILURE);
504 
505 		/* Change the priority */
506 		if ((*psm_intr_ops)(rdip, hdlp, PSM_INTR_OP_SET_PRI, result) ==
507 		    PSM_FAILURE)
508 			return (DDI_FAILURE);
509 
510 		ispec = xpvd_get_ispec(rdip, (int)hdlp->ih_inum);
511 		if (ispec == NULL)
512 			return (DDI_FAILURE);
513 		ispec->intrspec_pri = *(int *)result;
514 		break;
515 
516 	case DDI_INTROP_ADDISR:
517 		/* update ispec */
518 		ispec = xpvd_get_ispec(rdip, (int)hdlp->ih_inum);
519 		if (ispec == NULL)
520 			return (DDI_FAILURE);
521 		ispec->intrspec_func = hdlp->ih_cb_func;
522 
523 		break;
524 
525 	case DDI_INTROP_REMISR:
526 		ispec = xpvd_get_ispec(rdip, (int)hdlp->ih_inum);
527 		pdp = (struct xendev_ppd *)ddi_get_parent_data(rdip);
528 
529 		ASSERT(pdp != NULL);
530 		ASSERT(pdp->xd_evtchn != INVALID_EVTCHN);
531 
532 		if (ispec) {
533 			ispec->intrspec_vec = 0;
534 			ispec->intrspec_func = (uint_t (*)()) 0;
535 		}
536 		pdp->xd_evtchn = INVALID_EVTCHN;
537 		break;
538 
539 	case DDI_INTROP_GETCAP:
540 		if (hdlp->ih_type ==  DDI_INTR_TYPE_FIXED) {
541 			/*
542 			 * event channels are edge-triggered, maskable,
543 			 * and support int pending.
544 			 */
545 			*(int *)result = XENDEV_INTR_CAPABILITIES;
546 		} else {
547 			*(int *)result = 0;
548 			return (DDI_FAILURE);
549 		}
550 		DDI_INTR_NEXDBG((CE_CONT, "xpvd: GETCAP returned = %x\n",
551 		    *(int *)result));
552 		break;
553 	case DDI_INTROP_SETCAP:
554 		DDI_INTR_NEXDBG((CE_CONT, "xpvd_intr_ops: SETCAP cap=0x%x\n",
555 		    *(int *)result));
556 		if (psm_intr_ops == NULL)
557 			return (DDI_FAILURE);
558 
559 		if ((*psm_intr_ops)(rdip, hdlp, PSM_INTR_OP_SET_CAP, result)) {
560 			DDI_INTR_NEXDBG((CE_CONT, "GETCAP: psm_intr_ops"
561 			    " returned failure\n"));
562 			return (DDI_FAILURE);
563 		}
564 		break;
565 
566 	case DDI_INTROP_ENABLE:
567 		if (psm_intr_ops == NULL)
568 			return (DDI_FAILURE);
569 
570 		if (xpvd_enable_intr(rdip, hdlp, (int)hdlp->ih_inum) !=
571 		    DDI_SUCCESS)
572 			return (DDI_FAILURE);
573 
574 		DDI_INTR_NEXDBG((CE_CONT, "xpvd_intr_ops: ENABLE vec=0x%x\n",
575 		    hdlp->ih_vector));
576 		break;
577 
578 	case DDI_INTROP_DISABLE:
579 		if (psm_intr_ops == NULL)
580 			return (DDI_FAILURE);
581 		xpvd_disable_intr(rdip, hdlp, hdlp->ih_inum);
582 		DDI_INTR_NEXDBG((CE_CONT, "xpvd_intr_ops: DISABLE vec = %x\n",
583 		    hdlp->ih_vector));
584 		break;
585 
586 	case DDI_INTROP_BLOCKENABLE:
587 	case DDI_INTROP_BLOCKDISABLE:
588 		return (DDI_FAILURE);
589 
590 	case DDI_INTROP_SETMASK:
591 	case DDI_INTROP_CLRMASK:
592 #ifdef XPV_HVM_DRIVER
593 		return (DDI_ENOTSUP);
594 #else
595 		/*
596 		 * Handle this here
597 		 */
598 		if (hdlp->ih_type != DDI_INTR_TYPE_FIXED)
599 			return (DDI_FAILURE);
600 		if (intr_op == DDI_INTROP_SETMASK) {
601 			ec_disable_irq(hdlp->ih_vector);
602 		} else {
603 			ec_enable_irq(hdlp->ih_vector);
604 		}
605 		break;
606 #endif
607 	case DDI_INTROP_GETPENDING:
608 #ifdef XPV_HVM_DRIVER
609 		return (DDI_ENOTSUP);
610 #else
611 		if (hdlp->ih_type != DDI_INTR_TYPE_FIXED)
612 			return (DDI_FAILURE);
613 		*(int *)result = ec_pending_irq(hdlp->ih_vector);
614 		DDI_INTR_NEXDBG((CE_CONT, "xpvd: GETPENDING returned = %x\n",
615 		    *(int *)result));
616 		break;
617 #endif
618 
619 	case DDI_INTROP_NAVAIL:
620 		*(int *)result = 1;
621 		DDI_INTR_NEXDBG((CE_CONT, "xpvd: NAVAIL returned = %x\n",
622 		    *(int *)result));
623 		break;
624 
625 	default:
626 		return (i_ddi_intr_ops(pdip, rdip, intr_op, hdlp, result));
627 	}
628 
629 	return (DDI_SUCCESS);
630 }
631 
632 
633 static int
634 xpvd_enable_intr(dev_info_t *rdip, ddi_intr_handle_impl_t *hdlp, int inum)
635 {
636 	int		vector;
637 	ihdl_plat_t	*ihdl_plat_datap = (ihdl_plat_t *)hdlp->ih_private;
638 
639 	DDI_INTR_NEXDBG((CE_CONT, "xpvd_enable_intr: hdlp %p inum %x\n",
640 	    (void *)hdlp, inum));
641 
642 	ihdl_plat_datap->ip_ispecp = xpvd_get_ispec(rdip, inum);
643 	if (ihdl_plat_datap->ip_ispecp == NULL)
644 		return (DDI_FAILURE);
645 
646 	/* translate the interrupt if needed */
647 	(void) (*psm_intr_ops)(rdip, hdlp, PSM_INTR_OP_XLATE_VECTOR, &vector);
648 	DDI_INTR_NEXDBG((CE_CONT, "xpvd_enable_intr: priority=%x vector=%x\n",
649 	    hdlp->ih_pri, vector));
650 
651 	/* Add the interrupt handler */
652 	if (!add_avintr((void *)hdlp, hdlp->ih_pri, hdlp->ih_cb_func,
653 	    DEVI(rdip)->devi_name, vector, hdlp->ih_cb_arg1,
654 	    hdlp->ih_cb_arg2, NULL, rdip))
655 		return (DDI_FAILURE);
656 
657 	/* Note this really is an irq. */
658 	hdlp->ih_vector = (ushort_t)vector;
659 
660 	return (DDI_SUCCESS);
661 }
662 
663 
664 static void
665 xpvd_disable_intr(dev_info_t *rdip, ddi_intr_handle_impl_t *hdlp, int inum)
666 {
667 	int		vector;
668 	ihdl_plat_t	*ihdl_plat_datap = (ihdl_plat_t *)hdlp->ih_private;
669 
670 	DDI_INTR_NEXDBG((CE_CONT, "xpvd_disable_intr: \n"));
671 	ihdl_plat_datap->ip_ispecp = xpvd_get_ispec(rdip, inum);
672 	if (ihdl_plat_datap->ip_ispecp == NULL)
673 		return;
674 
675 	/* translate the interrupt if needed */
676 	(void) (*psm_intr_ops)(rdip, hdlp, PSM_INTR_OP_XLATE_VECTOR, &vector);
677 
678 	/* Disable the interrupt handler */
679 	rem_avintr((void *)hdlp, hdlp->ih_pri, hdlp->ih_cb_func, vector);
680 	ihdl_plat_datap->ip_ispecp = NULL;
681 }
682 
683 /*ARGSUSED*/
684 static int
685 xpvd_ctlops(dev_info_t *dip, dev_info_t *rdip,
686 	ddi_ctl_enum_t ctlop, void *arg, void *result)
687 {
688 	switch (ctlop) {
689 	case DDI_CTLOPS_REPORTDEV:
690 		if (rdip == (dev_info_t *)0)
691 			return (DDI_FAILURE);
692 		cmn_err(CE_CONT, "?%s@%s, %s%d\n", ddi_node_name(rdip),
693 		    ddi_get_name_addr(rdip), ddi_driver_name(rdip),
694 		    ddi_get_instance(rdip));
695 		return (DDI_SUCCESS);
696 
697 	case DDI_CTLOPS_INITCHILD:
698 		return (xpvd_initchild((dev_info_t *)arg));
699 
700 	case DDI_CTLOPS_UNINITCHILD:
701 		return (xpvd_removechild((dev_info_t *)arg));
702 
703 	case DDI_CTLOPS_SIDDEV:
704 		return (DDI_SUCCESS);
705 
706 	case DDI_CTLOPS_REGSIZE:
707 	case DDI_CTLOPS_NREGS:
708 		return (DDI_FAILURE);
709 
710 	case DDI_CTLOPS_POWER: {
711 		return (ddi_ctlops(dip, rdip, ctlop, arg, result));
712 	}
713 
714 	default:
715 		return (ddi_ctlops(dip, rdip, ctlop, arg, result));
716 	}
717 
718 	/* NOTREACHED */
719 
720 }
721 
722 /*
723  * Assign the address portion of the node name
724  */
725 static int
726 xpvd_name_child(dev_info_t *child, char *addr, int addrlen)
727 {
728 	int *domain, *vdev;
729 	uint_t ndomain, nvdev;
730 	char *prop_str;
731 
732 	/*
733 	 * i_xpvd_parse_devname() knows the formats used by this
734 	 * routine.  If this code changes, so must that.
735 	 */
736 
737 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
738 	    "domain", &domain, &ndomain) != DDI_PROP_SUCCESS)
739 		return (DDI_FAILURE);
740 	ASSERT(ndomain == 1);
741 
742 	/*
743 	 * Use "domain" and "vdev" properties (backend drivers).
744 	 */
745 	if (*domain != DOMID_SELF) {
746 		if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child,
747 		    DDI_PROP_DONTPASS, "vdev", &vdev, &nvdev)
748 		    != DDI_PROP_SUCCESS) {
749 			ddi_prop_free(domain);
750 			return (DDI_FAILURE);
751 		}
752 		ASSERT(nvdev == 1);
753 
754 		(void) snprintf(addr, addrlen, "%d,%d", domain[0], vdev[0]);
755 		ddi_prop_free(vdev);
756 		ddi_prop_free(domain);
757 		return (DDI_SUCCESS);
758 	}
759 	ddi_prop_free(domain);
760 
761 	/*
762 	 * Use "unit-address" property (frontend/softdev drivers).
763 	 */
764 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
765 	    "unit-address", &prop_str) != DDI_PROP_SUCCESS)
766 		return (DDI_FAILURE);
767 	(void) strlcpy(addr, prop_str, addrlen);
768 	ddi_prop_free(prop_str);
769 	return (DDI_SUCCESS);
770 }
771 
772 static int
773 xpvd_initchild(dev_info_t *child)
774 {
775 	char addr[80];
776 
777 	/*
778 	 * Pseudo nodes indicate a prototype node with per-instance
779 	 * properties to be merged into the real h/w device node.
780 	 */
781 	if (ndi_dev_is_persistent_node(child) == 0) {
782 		ddi_set_parent_data(child, NULL);
783 
784 		/*
785 		 * Try to merge the properties from this prototype
786 		 * node into real h/w nodes.
787 		 */
788 		if (ndi_merge_node(child, xpvd_name_child) == DDI_SUCCESS) {
789 			/*
790 			 * Merged ok - return failure to remove the node.
791 			 */
792 			ddi_set_name_addr(child, NULL);
793 			return (DDI_FAILURE);
794 		}
795 
796 		/*
797 		 * The child was not merged into a h/w node,
798 		 * but there's not much we can do with it other
799 		 * than return failure to cause the node to be removed.
800 		 */
801 		cmn_err(CE_WARN, "!%s@%s: %s.conf properties not merged",
802 		    ddi_get_name(child), ddi_get_name_addr(child),
803 		    ddi_get_name(child));
804 		ddi_set_name_addr(child, NULL);
805 		return (DDI_NOT_WELL_FORMED);
806 	}
807 
808 	if (xvdi_init_dev(child) != DDI_SUCCESS)
809 		return (DDI_FAILURE);
810 
811 	if (xpvd_name_child(child, addr, sizeof (addr)) != DDI_SUCCESS) {
812 		xvdi_uninit_dev(child);
813 		return (DDI_FAILURE);
814 	}
815 	ddi_set_name_addr(child, addr);
816 
817 	return (DDI_SUCCESS);
818 }
819 
820 static int
821 xpvd_removechild(dev_info_t *dip)
822 {
823 	xvdi_uninit_dev(dip);
824 
825 	ddi_set_name_addr(dip, NULL);
826 
827 	/*
828 	 * Strip the node to properly convert it back to prototype
829 	 * form.
830 	 */
831 	ddi_remove_minor_node(dip, NULL);
832 
833 	return (DDI_SUCCESS);
834 }
835 
836 static int
837 xpvd_bus_unconfig(dev_info_t *parent, uint_t flag, ddi_bus_config_op_t op,
838     void *device_name)
839 {
840 	return (ndi_busop_bus_unconfig(parent, flag, op, device_name));
841 }
842 
843 /*
844  * Given the name of a child of xpvd, determine the device class,
845  * domain and vdevnum to which it refers.
846  */
847 static boolean_t
848 i_xpvd_parse_devname(char *name, xendev_devclass_t *devclassp,
849     domid_t *domp, int *vdevp)
850 {
851 	int len = strlen(name) + 1;
852 	char *device_name = i_ddi_strdup(name, KM_SLEEP);
853 	char *cname = NULL, *caddr = NULL;
854 	boolean_t ret;
855 
856 	i_ddi_parse_name(device_name, &cname, &caddr, NULL);
857 
858 	if ((cname == NULL) || (strlen(cname) == 0) ||
859 	    (caddr == NULL) || (strlen(caddr) == 0)) {
860 		ret = B_FALSE;
861 		goto done;
862 	}
863 
864 	*devclassp = xendev_nodename_to_devclass(cname);
865 	if (*devclassp < 0) {
866 		ret = B_FALSE;
867 		goto done;
868 	}
869 
870 	/*
871 	 * Parsing the address component requires knowledge of how
872 	 * xpvd_name_child() works.  If that code changes, so must
873 	 * this.
874 	 */
875 
876 	/* Backend format is "<domain>,<vdev>". */
877 	if (sscanf(caddr, "%hu,%d", domp, vdevp) == 2) {
878 		ret = B_TRUE;
879 		goto done;
880 	}
881 
882 	/* Frontend format is "<vdev>". */
883 	*domp = DOMID_SELF;
884 	if (sscanf(caddr, "%d", vdevp) == 1)
885 		ret = B_TRUE;
886 done:
887 	kmem_free(device_name, len);
888 	return (ret);
889 }
890 
891 /*
892  * xpvd_bus_config()
893  *
894  * BUS_CONFIG_ONE:
895  *	Enumerate the exact instance of a driver.
896  *
897  * BUS_CONFIG_ALL:
898  *	Enumerate all the instances of all the possible children (seen before
899  *	and never seen before).
900  *
901  * BUS_CONFIG_DRIVER:
902  *	Enumerate all the instances of a particular driver.
903  */
904 static int
905 xpvd_bus_config(dev_info_t *parent, uint_t flag, ddi_bus_config_op_t op,
906 	void *arg, dev_info_t **childp)
907 {
908 	int circ;
909 	char *cname = NULL;
910 
911 	ndi_devi_enter(parent, &circ);
912 
913 	switch (op) {
914 	case BUS_CONFIG_ONE: {
915 		xendev_devclass_t devclass;
916 		domid_t dom;
917 		int vdev;
918 
919 		if (!i_xpvd_parse_devname(arg, &devclass, &dom, &vdev)) {
920 			ndi_devi_exit(parent, circ);
921 			return (NDI_FAILURE);
922 		}
923 
924 		*childp = xvdi_find_dev(parent, devclass, dom, vdev);
925 		if (*childp == NULL)
926 			*childp = xvdi_create_dev(parent, devclass, dom, vdev);
927 
928 		ndi_devi_exit(parent, circ);
929 
930 		if (*childp == NULL)
931 			return (NDI_FAILURE);
932 		else
933 			return (ndi_busop_bus_config(parent, flag,
934 			    op, arg, childp, 0));
935 	}
936 
937 	case BUS_CONFIG_DRIVER: {
938 		xendev_devclass_t devclass = XEN_INVAL;
939 
940 		cname = ddi_major_to_name((major_t)(uintptr_t)arg);
941 		if (cname != NULL)
942 			devclass = xendev_nodename_to_devclass(cname);
943 
944 		if (devclass == XEN_INVAL) {
945 			ndi_devi_exit(parent, circ);
946 			return (NDI_FAILURE);
947 		} else {
948 			xendev_enum_class(parent, devclass);
949 			ndi_devi_exit(parent, circ);
950 			return (ndi_busop_bus_config(parent, flag, op,
951 			    arg, childp, 0));
952 		}
953 		/* NOTREACHED */
954 	}
955 
956 	case BUS_CONFIG_ALL:
957 		xendev_enum_all(parent, B_FALSE);
958 		ndi_devi_exit(parent, circ);
959 
960 		return (ndi_busop_bus_config(parent, flag, op,
961 		    arg, childp, 0));
962 
963 	default:
964 		ndi_devi_exit(parent, circ);
965 		return (NDI_FAILURE);
966 	}
967 }
968 
969 /*ARGSUSED*/
970 static int
971 xpvd_get_eventcookie(dev_info_t *dip, dev_info_t *rdip,
972     char *eventname, ddi_eventcookie_t *cookie)
973 {
974 	return (ndi_event_retrieve_cookie(xpvd_ndi_event_handle,
975 	    rdip, eventname, cookie, NDI_EVENT_NOPASS));
976 }
977 
978 /*ARGSUSED*/
979 static int
980 xpvd_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
981     ddi_eventcookie_t cookie, void (*callback)(dev_info_t *dip,
982     ddi_eventcookie_t cookie, void *arg, void *bus_impldata),
983     void *arg, ddi_callback_id_t *cb_id)
984 {
985 	return (ndi_event_add_callback(xpvd_ndi_event_handle,
986 	    rdip, cookie, callback, arg, NDI_SLEEP, cb_id));
987 }
988 
989 /*ARGSUSED*/
990 static int
991 xpvd_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
992 {
993 	return (ndi_event_remove_callback(xpvd_ndi_event_handle,
994 	    cb_id));
995 }
996 
997 /*ARGSUSED*/
998 static int
999 xpvd_post_event(dev_info_t *dip, dev_info_t *rdip,
1000     ddi_eventcookie_t cookie, void *bus_impldata)
1001 {
1002 	return (ndi_event_run_callbacks(xpvd_ndi_event_handle, rdip,
1003 	    cookie, bus_impldata));
1004 }
1005