1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 /* 28 * The tvhci driver can be used to exercise the mpxio framework together 29 * with tphci/tclient. 30 */ 31 32 #include <sys/conf.h> 33 #include <sys/file.h> 34 #include <sys/ddi.h> 35 #include <sys/sunddi.h> 36 #include <sys/scsi/scsi.h> 37 #include <sys/scsi/impl/scsi_reset_notify.h> 38 #include <sys/sunmdi.h> 39 #include <sys/mdi_impldefs.h> 40 #include <sys/disp.h> 41 42 /* cb_ops entry points */ 43 static int tvhci_open(dev_t *, int, int, cred_t *); 44 static int tvhci_close(dev_t, int, int, cred_t *); 45 static int tvhci_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 46 static int tvhci_attach(dev_info_t *, ddi_attach_cmd_t); 47 static int tvhci_detach(dev_info_t *, ddi_detach_cmd_t); 48 static int tvhci_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 49 50 /* bus_ops entry points */ 51 static int tvhci_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, 52 void *); 53 static int tvhci_initchild(dev_info_t *, dev_info_t *); 54 static int tvhci_uninitchild(dev_info_t *, dev_info_t *); 55 static int tvhci_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t, void *, 56 dev_info_t **); 57 static int tvhci_bus_unconfig(dev_info_t *, uint_t, ddi_bus_config_op_t, 58 void *); 59 static int tvhci_intr_op(dev_info_t *dip, dev_info_t *rdip, 60 ddi_intr_op_t op, ddi_intr_handle_impl_t *hdlp, void *result); 61 62 /* vhci ops */ 63 static int tvhci_pi_init(dev_info_t *, mdi_pathinfo_t *, int); 64 static int tvhci_pi_uninit(dev_info_t *, mdi_pathinfo_t *, int); 65 static int tvhci_pi_state_change(dev_info_t *, mdi_pathinfo_t *, 66 mdi_pathinfo_state_t, uint32_t, int); 67 static int tvhci_failover(dev_info_t *, dev_info_t *, int); 68 69 static void *tvhci_state; 70 struct tvhci_state { 71 dev_info_t *dip; 72 }; 73 74 static mdi_vhci_ops_t tvhci_opinfo = { 75 MDI_VHCI_OPS_REV, 76 tvhci_pi_init, 77 tvhci_pi_uninit, 78 tvhci_pi_state_change, 79 tvhci_failover 80 }; 81 82 static struct cb_ops tvhci_cb_ops = { 83 tvhci_open, /* open */ 84 tvhci_close, /* close */ 85 nodev, /* strategy */ 86 nodev, /* print */ 87 nodev, /* dump */ 88 nodev, /* read */ 89 nodev, /* write */ 90 tvhci_ioctl, /* ioctl */ 91 nodev, /* devmap */ 92 nodev, /* mmap */ 93 nodev, /* segmap */ 94 nochpoll, /* chpoll */ 95 ddi_prop_op, /* cb_prop_op */ 96 0, /* streamtab */ 97 D_NEW | D_MP, /* cb_flag */ 98 CB_REV, /* rev */ 99 nodev, /* aread */ 100 nodev /* awrite */ 101 }; 102 103 static struct bus_ops tvhci_bus_ops = { 104 BUSO_REV, /* busops_rev */ 105 nullbusmap, /* bus_map */ 106 NULL, /* bus_get_intrspec */ 107 NULL, /* bus_add_interspec */ 108 NULL, /* bus_remove_interspec */ 109 i_ddi_map_fault, /* bus_map_fault */ 110 ddi_no_dma_map, /* bus_dma_map */ 111 ddi_no_dma_allochdl, /* bus_dma_allochdl */ 112 NULL, /* bus_dma_freehdl */ 113 NULL, /* bus_dma_bindhdl */ 114 NULL, /* bus_dma_unbindhdl */ 115 NULL, /* bus_dma_flush */ 116 NULL, /* bus_dma_win */ 117 NULL, /* bus_dma_ctl */ 118 tvhci_ctl, /* bus_ctl */ 119 ddi_bus_prop_op, /* bus_prop_op */ 120 NULL, /* bus_get_eventcookie */ 121 NULL, /* bus_add_eventcall */ 122 NULL, /* bus_remove_event */ 123 NULL, /* bus_post_event */ 124 NULL, /* bus_intr_ctl */ 125 tvhci_bus_config, /* bus_config */ 126 tvhci_bus_unconfig, /* bus_unconfig */ 127 NULL, /* bus_fm_init */ 128 NULL, /* bus_fm_fini */ 129 NULL, /* bus_fm_access_enter */ 130 NULL, /* bus_fm_access_exit */ 131 NULL, /* bus_power */ 132 tvhci_intr_op /* bus_intr_op */ 133 }; 134 135 static struct dev_ops tvhci_ops = { 136 DEVO_REV, 137 0, 138 tvhci_getinfo, 139 nulldev, /* identify */ 140 nulldev, /* probe */ 141 tvhci_attach, /* attach and detach are mandatory */ 142 tvhci_detach, 143 nodev, /* reset */ 144 &tvhci_cb_ops, /* cb_ops */ 145 &tvhci_bus_ops, /* bus_ops */ 146 NULL, /* power */ 147 ddi_quiesce_not_needed, /* quiesce */ 148 }; 149 150 extern struct mod_ops mod_driverops; 151 152 static struct modldrv modldrv = { 153 &mod_driverops, 154 "test vhci driver", 155 &tvhci_ops 156 }; 157 158 static struct modlinkage modlinkage = { 159 MODREV_1, 160 &modldrv, 161 NULL 162 }; 163 164 int 165 _init(void) 166 { 167 int rval; 168 169 if ((rval = ddi_soft_state_init(&tvhci_state, 170 sizeof (struct tvhci_state), 2)) != 0) { 171 return (rval); 172 } 173 174 if ((rval = mod_install(&modlinkage)) != 0) { 175 ddi_soft_state_fini(&tvhci_state); 176 } 177 return (rval); 178 } 179 180 181 int 182 _fini(void) 183 { 184 int rval; 185 186 /* 187 * don't start cleaning up until we know that the module remove 188 * has worked -- if this works, then we know that each instance 189 * has successfully been detached 190 */ 191 if ((rval = mod_remove(&modlinkage)) != 0) { 192 return (rval); 193 } 194 195 ddi_soft_state_fini(&tvhci_state); 196 197 return (rval); 198 } 199 200 int 201 _info(struct modinfo *modinfop) 202 { 203 return (mod_info(&modlinkage, modinfop)); 204 } 205 206 /* ARGSUSED */ 207 static int 208 tvhci_open(dev_t *devp, int flag, int otype, cred_t *credp) 209 { 210 struct tvhci_state *vhci; 211 212 if (otype != OTYP_CHR) { 213 return (EINVAL); 214 } 215 216 vhci = ddi_get_soft_state(tvhci_state, getminor(*devp)); 217 if (vhci == NULL) { 218 return (ENXIO); 219 } 220 221 return (0); 222 } 223 224 225 /* ARGSUSED */ 226 static int 227 tvhci_close(dev_t dev, int flag, int otype, cred_t *credp) 228 { 229 struct tvhci_state *vhci; 230 if (otype != OTYP_CHR) { 231 return (EINVAL); 232 } 233 234 vhci = ddi_get_soft_state(tvhci_state, getminor(dev)); 235 if (vhci == NULL) { 236 return (ENXIO); 237 } 238 239 return (0); 240 } 241 242 /* ARGSUSED */ 243 static int 244 tvhci_ioctl(dev_t dev, int cmd, intptr_t data, int mode, 245 cred_t *credp, int *rval) 246 { 247 return (0); 248 } 249 250 /* 251 * attach the module 252 */ 253 static int 254 tvhci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 255 { 256 char *vclass; 257 int instance, vhci_regis = 0; 258 struct tvhci_state *vhci = NULL; 259 dev_info_t *pdip; 260 261 instance = ddi_get_instance(dip); 262 263 switch (cmd) { 264 case DDI_ATTACH: 265 break; 266 267 case DDI_RESUME: 268 case DDI_PM_RESUME: 269 return (0); /* nothing to do */ 270 271 default: 272 return (DDI_FAILURE); 273 } 274 275 /* 276 * Allocate vhci data structure. 277 */ 278 if (ddi_soft_state_zalloc(tvhci_state, instance) != DDI_SUCCESS) { 279 return (DDI_FAILURE); 280 } 281 282 vhci = ddi_get_soft_state(tvhci_state, instance); 283 ASSERT(vhci != NULL); 284 vhci->dip = dip; 285 286 /* parent must be /pshot */ 287 pdip = ddi_get_parent(dip); 288 if (strcmp(ddi_driver_name(pdip), "pshot") != 0 || 289 ddi_get_parent(pdip) != ddi_root_node()) { 290 cmn_err(CE_NOTE, "tvhci must be under /pshot/"); 291 goto attach_fail; 292 } 293 294 /* 295 * XXX add mpxio-disable property. need to remove the check 296 * from the framework 297 */ 298 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, 299 "mpxio-disable", "no"); 300 301 /* bus_addr is the <vhci_class> */ 302 vclass = ddi_get_name_addr(dip); 303 if (vclass == NULL || vclass[1] == '\0') { 304 cmn_err(CE_NOTE, "tvhci invalid vhci class"); 305 goto attach_fail; 306 } 307 308 /* 309 * Attach this instance with the mpxio framework 310 */ 311 if (mdi_vhci_register(vclass, dip, &tvhci_opinfo, 0) != MDI_SUCCESS) { 312 cmn_err(CE_WARN, "%s mdi_vhci_register failed", 313 ddi_node_name(dip)); 314 goto attach_fail; 315 } 316 vhci_regis++; 317 318 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 319 instance, DDI_NT_SCSI_NEXUS, 0) != DDI_SUCCESS) { 320 cmn_err(CE_NOTE, "%s ddi_create_minor_node failed", 321 ddi_node_name(dip)); 322 goto attach_fail; 323 } 324 325 (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1); 326 ddi_report_dev(dip); 327 return (DDI_SUCCESS); 328 329 attach_fail: 330 if (vhci_regis) 331 (void) mdi_vhci_unregister(dip, 0); 332 333 ddi_soft_state_free(tvhci_state, instance); 334 return (DDI_FAILURE); 335 } 336 337 338 /*ARGSUSED*/ 339 static int 340 tvhci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 341 { 342 int instance = ddi_get_instance(dip); 343 344 switch (cmd) { 345 case DDI_DETACH: 346 break; 347 348 case DDI_SUSPEND: 349 case DDI_PM_SUSPEND: 350 return (0); /* nothing to do */ 351 352 default: 353 return (DDI_FAILURE); 354 } 355 356 if (mdi_vhci_unregister(dip, 0) != MDI_SUCCESS) 357 return (DDI_FAILURE); 358 359 ddi_remove_minor_node(dip, NULL); 360 ddi_soft_state_free(tvhci_state, instance); 361 362 return (DDI_SUCCESS); 363 } 364 365 /* 366 * tvhci_getinfo() 367 * Given the device number, return the devinfo pointer or the 368 * instance number. 369 * Note: always succeed DDI_INFO_DEVT2INSTANCE, even before attach. 370 */ 371 372 /*ARGSUSED*/ 373 static int 374 tvhci_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 375 { 376 struct tvhci_state *vhci; 377 int instance = getminor((dev_t)arg); 378 379 switch (cmd) { 380 case DDI_INFO_DEVT2DEVINFO: 381 vhci = ddi_get_soft_state(tvhci_state, instance); 382 if (vhci != NULL) 383 *result = vhci->dip; 384 else { 385 *result = NULL; 386 return (DDI_FAILURE); 387 } 388 break; 389 390 case DDI_INFO_DEVT2INSTANCE: 391 *result = (void *)(uintptr_t)instance; 392 break; 393 394 default: 395 return (DDI_FAILURE); 396 } 397 398 return (DDI_SUCCESS); 399 } 400 401 /*ARGSUSED*/ 402 static int 403 tvhci_pi_init(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags) 404 { 405 return (MDI_SUCCESS); 406 } 407 408 /*ARGSUSED*/ 409 static int 410 tvhci_pi_uninit(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags) 411 { 412 return (MDI_SUCCESS); 413 } 414 415 /*ARGSUSED*/ 416 static int 417 tvhci_pi_state_change(dev_info_t *vdip, mdi_pathinfo_t *pip, 418 mdi_pathinfo_state_t state, uint32_t ext_state, int flags) 419 { 420 return (MDI_SUCCESS); 421 } 422 423 /*ARGSUSED*/ 424 static int 425 tvhci_failover(dev_info_t *vdip, dev_info_t *cdip, int flags) 426 { 427 return (MDI_SUCCESS); 428 } 429 430 /* 431 * Interrupt stuff. NO OP for pseudo drivers. 432 */ 433 /*ARGSUSED*/ 434 static int 435 tvhci_intr_op(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t op, 436 ddi_intr_handle_impl_t *hdlp, void *result) 437 { 438 return (DDI_FAILURE); 439 } 440 441 /*ARGSUSED*/ 442 static int 443 tvhci_ctl(dev_info_t *dip, dev_info_t *rdip, 444 ddi_ctl_enum_t ctlop, void *arg, void *result) 445 { 446 switch (ctlop) { 447 case DDI_CTLOPS_REPORTDEV: 448 if (rdip == (dev_info_t *)0) 449 return (DDI_FAILURE); 450 cmn_err(CE_CONT, "?tvhci-device: %s%d\n", 451 ddi_get_name(rdip), ddi_get_instance(rdip)); 452 return (DDI_SUCCESS); 453 454 case DDI_CTLOPS_INITCHILD: 455 { 456 dev_info_t *child = (dev_info_t *)arg; 457 return (tvhci_initchild(dip, child)); 458 } 459 460 case DDI_CTLOPS_UNINITCHILD: 461 { 462 dev_info_t *child = (dev_info_t *)arg; 463 return (tvhci_uninitchild(dip, child)); 464 } 465 466 case DDI_CTLOPS_DMAPMAPC: 467 case DDI_CTLOPS_REPORTINT: 468 case DDI_CTLOPS_REGSIZE: 469 case DDI_CTLOPS_NREGS: 470 case DDI_CTLOPS_SIDDEV: 471 case DDI_CTLOPS_SLAVEONLY: 472 case DDI_CTLOPS_AFFINITY: 473 case DDI_CTLOPS_POKE: 474 case DDI_CTLOPS_PEEK: 475 /* 476 * These ops correspond to functions that "shouldn't" be called 477 * by a pseudo driver. So we whine when we're called. 478 */ 479 cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d\n", 480 ddi_get_name(dip), ddi_get_instance(dip), 481 ctlop, ddi_get_name(rdip), ddi_get_instance(rdip)); 482 return (DDI_FAILURE); 483 484 case DDI_CTLOPS_ATTACH: 485 case DDI_CTLOPS_BTOP: 486 case DDI_CTLOPS_BTOPR: 487 case DDI_CTLOPS_DETACH: 488 case DDI_CTLOPS_DVMAPAGESIZE: 489 case DDI_CTLOPS_IOMIN: 490 case DDI_CTLOPS_POWER: 491 case DDI_CTLOPS_PTOB: 492 default: 493 /* 494 * The ops that we pass up (default). We pass up memory 495 * allocation oriented ops that we receive - these may be 496 * associated with pseudo HBA drivers below us with target 497 * drivers below them that use ddi memory allocation 498 * interfaces like scsi_alloc_consistent_buf. 499 */ 500 return (ddi_ctlops(dip, rdip, ctlop, arg, result)); 501 } 502 } 503 504 /* set devi_addr to "g<guid>" */ 505 static int 506 tvhci_initchild(dev_info_t *dip, dev_info_t *child) 507 { 508 _NOTE(ARGUNUSED(dip)) 509 char *guid, *addr; 510 511 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS, 512 MDI_CLIENT_GUID_PROP, &guid) != DDI_SUCCESS) { 513 cmn_err(CE_NOTE, "tvhci_initchild - no guid property"); 514 return (DDI_FAILURE); 515 } 516 517 addr = kmem_alloc(MAXNAMELEN, KM_SLEEP); 518 (void) snprintf(addr, MAXNAMELEN, "g%s", guid); 519 ddi_set_name_addr(child, addr); 520 521 kmem_free(addr, MAXNAMELEN); 522 ddi_prop_free(guid); 523 return (DDI_SUCCESS); 524 } 525 526 /*ARGSUSED*/ 527 static int 528 tvhci_uninitchild(dev_info_t *dip, dev_info_t *child) 529 { 530 ddi_set_name_addr(child, NULL); 531 return (DDI_SUCCESS); 532 } 533 534 /* form paddr by cname@<phci_inst>,<guid> */ 535 static char * 536 tvh_get_phci_devname(char *cname, char *guid, 537 dev_info_t *pdip, char *pname, int len) 538 { 539 (void) snprintf(pname, len, "%s@%d,%s", 540 cname, ddi_get_instance(pdip), guid); 541 return (pname); 542 } 543 544 /* 545 * Return a pointer to the guid part of the devnm. 546 * devnm format is "nodename@busaddr", busaddr format is "gGUID". 547 */ 548 static char * 549 tvhci_devnm_to_guid(char *devnm) 550 { 551 char *cp = devnm; 552 553 if (devnm == NULL) 554 return (NULL); 555 556 while (*cp != '\0' && *cp != '@') 557 cp++; 558 if (*cp == '@' && *(cp + 1) == 'g') 559 return (cp + 2); 560 return (NULL); 561 } 562 563 static int 564 tvhci_bus_config(dev_info_t *pdip, uint_t flags, ddi_bus_config_op_t op, 565 void *arg, dev_info_t **child) 566 { 567 char *guid; 568 569 if (op == BUS_CONFIG_ONE || op == BUS_UNCONFIG_ONE) 570 guid = tvhci_devnm_to_guid((char *)arg); 571 else 572 guid = NULL; 573 574 if (mdi_vhci_bus_config(pdip, flags, op, arg, child, guid) 575 == MDI_SUCCESS) 576 return (NDI_SUCCESS); 577 else 578 return (NDI_FAILURE); 579 } 580 581 static int 582 tvhci_bus_unconfig(dev_info_t *parent, uint_t flags, 583 ddi_bus_config_op_t op, void *arg) 584 { 585 return (ndi_busop_bus_unconfig(parent, flags, op, arg)); 586 } 587