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