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