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