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 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * The tphci driver can be used to exercise the mpxio framework together 30 * with tvhci/tclient. 31 */ 32 33 #include <sys/conf.h> 34 #include <sys/file.h> 35 #include <sys/open.h> 36 #include <sys/stat.h> 37 #include <sys/modctl.h> 38 #include <sys/ddi.h> 39 #include <sys/sunddi.h> 40 #include <sys/sunndi.h> 41 #include <sys/sunmdi.h> 42 #include <sys/disp.h> 43 44 /* cb_ops entry points */ 45 static int tphci_open(dev_t *, int, int, cred_t *); 46 static int tphci_close(dev_t, int, int, cred_t *); 47 static int tphci_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 48 static int tphci_attach(dev_info_t *, ddi_attach_cmd_t); 49 static int tphci_detach(dev_info_t *, ddi_detach_cmd_t); 50 static int tphci_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 51 52 /* bus_ops entry points */ 53 static int tphci_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, 54 void *); 55 static int tphci_initchild(dev_info_t *, dev_info_t *); 56 static int tphci_uninitchild(dev_info_t *, dev_info_t *); 57 static int tphci_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t, void *, 58 dev_info_t **); 59 static int tphci_bus_unconfig(dev_info_t *, uint_t, ddi_bus_config_op_t, 60 void *); 61 static int tphci_intr_op(dev_info_t *dip, dev_info_t *rdip, 62 ddi_intr_op_t op, ddi_intr_handle_impl_t *hdlp, void *result); 63 64 65 static void *tphci_state; 66 struct tphci_state { 67 dev_info_t *dip; 68 }; 69 70 static struct cb_ops tphci_cb_ops = { 71 tphci_open, /* open */ 72 tphci_close, /* close */ 73 nodev, /* strategy */ 74 nodev, /* print */ 75 nodev, /* dump */ 76 nodev, /* read */ 77 nodev, /* write */ 78 tphci_ioctl, /* ioctl */ 79 nodev, /* devmap */ 80 nodev, /* mmap */ 81 nodev, /* segmap */ 82 nochpoll, /* chpoll */ 83 ddi_prop_op, /* cb_prop_op */ 84 0, /* streamtab */ 85 D_NEW | D_MP, /* cb_flag */ 86 CB_REV, /* rev */ 87 nodev, /* aread */ 88 nodev /* awrite */ 89 }; 90 91 static struct bus_ops tphci_bus_ops = { 92 BUSO_REV, /* busops_rev */ 93 nullbusmap, /* bus_map */ 94 NULL, /* bus_get_intrspec */ 95 NULL, /* bus_add_interspec */ 96 NULL, /* bus_remove_interspec */ 97 i_ddi_map_fault, /* bus_map_fault */ 98 ddi_no_dma_map, /* bus_dma_map */ 99 ddi_no_dma_allochdl, /* bus_dma_allochdl */ 100 NULL, /* bus_dma_freehdl */ 101 NULL, /* bus_dma_bindhdl */ 102 NULL, /* bus_dma_unbindhdl */ 103 NULL, /* bus_dma_flush */ 104 NULL, /* bus_dma_win */ 105 NULL, /* bus_dma_ctl */ 106 tphci_ctl, /* bus_ctl */ 107 ddi_bus_prop_op, /* bus_prop_op */ 108 NULL, /* bus_get_eventcookie */ 109 NULL, /* bus_add_eventcall */ 110 NULL, /* bus_remove_event */ 111 NULL, /* bus_post_event */ 112 NULL, /* bus_intr_ctl */ 113 tphci_bus_config, /* bus_config */ 114 tphci_bus_unconfig, /* bus_unconfig */ 115 NULL, /* bus_fm_init */ 116 NULL, /* bus_fm_fini */ 117 NULL, /* bus_fm_access_enter */ 118 NULL, /* bus_fm_access_exit */ 119 NULL, /* bus_power */ 120 tphci_intr_op /* bus_intr_op */ 121 }; 122 123 static struct dev_ops tphci_ops = { 124 DEVO_REV, 125 0, 126 tphci_getinfo, 127 nulldev, /* identify */ 128 nulldev, /* probe */ 129 tphci_attach, /* attach and detach are mandatory */ 130 tphci_detach, 131 nodev, /* reset */ 132 &tphci_cb_ops, /* cb_ops */ 133 &tphci_bus_ops, /* bus_ops */ 134 NULL /* power */ 135 }; 136 137 extern struct mod_ops mod_driverops; 138 139 static struct modldrv modldrv = { 140 &mod_driverops, 141 "test phci driver %I%", 142 &tphci_ops 143 }; 144 145 static struct modlinkage modlinkage = { 146 MODREV_1, 147 &modldrv, 148 NULL 149 }; 150 151 int 152 _init(void) 153 { 154 int rval; 155 156 if ((rval = ddi_soft_state_init(&tphci_state, 157 sizeof (struct tphci_state), 2)) != 0) { 158 return (rval); 159 } 160 161 if ((rval = mod_install(&modlinkage)) != 0) { 162 ddi_soft_state_fini(&tphci_state); 163 } 164 return (rval); 165 } 166 167 168 int 169 _fini(void) 170 { 171 int rval; 172 173 /* 174 * don't start cleaning up until we know that the module remove 175 * has worked -- if this works, then we know that each instance 176 * has successfully been detached 177 */ 178 if ((rval = mod_remove(&modlinkage)) != 0) { 179 return (rval); 180 } 181 182 ddi_soft_state_fini(&tphci_state); 183 184 return (rval); 185 } 186 187 int 188 _info(struct modinfo *modinfop) 189 { 190 return (mod_info(&modlinkage, modinfop)); 191 } 192 193 /* ARGSUSED */ 194 static int 195 tphci_open(dev_t *devp, int flag, int otype, cred_t *credp) 196 { 197 struct tphci_state *phci; 198 199 if (otype != OTYP_CHR) { 200 return (EINVAL); 201 } 202 203 phci = ddi_get_soft_state(tphci_state, getminor(*devp)); 204 if (phci == NULL) { 205 return (ENXIO); 206 } 207 208 return (0); 209 } 210 211 212 /* ARGSUSED */ 213 static int 214 tphci_close(dev_t dev, int flag, int otype, cred_t *credp) 215 { 216 struct tphci_state *phci; 217 if (otype != OTYP_CHR) { 218 return (EINVAL); 219 } 220 221 phci = ddi_get_soft_state(tphci_state, getminor(dev)); 222 if (phci == NULL) { 223 return (ENXIO); 224 } 225 226 return (0); 227 } 228 229 /* ARGSUSED */ 230 static int 231 tphci_ioctl(dev_t dev, int cmd, intptr_t data, int mode, 232 cred_t *credp, int *rval) 233 { 234 return (0); 235 } 236 237 /* 238 * attach the module 239 */ 240 static int 241 tphci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 242 { 243 char *vclass; 244 int instance, phci_regis = 0; 245 struct tphci_state *phci = NULL; 246 247 instance = ddi_get_instance(dip); 248 249 switch (cmd) { 250 case DDI_ATTACH: 251 break; 252 253 case DDI_RESUME: 254 case DDI_PM_RESUME: 255 return (0); /* nothing to do */ 256 257 default: 258 return (DDI_FAILURE); 259 } 260 261 /* 262 * Allocate phci data structure. 263 */ 264 if (ddi_soft_state_zalloc(tphci_state, instance) != DDI_SUCCESS) { 265 return (DDI_FAILURE); 266 } 267 268 phci = ddi_get_soft_state(tphci_state, instance); 269 ASSERT(phci != NULL); 270 phci->dip = dip; 271 272 /* bus_addr has the form #,<vhci_class> */ 273 vclass = strchr(ddi_get_name_addr(dip), ','); 274 if (vclass == NULL || vclass[1] == '\0') { 275 cmn_err(CE_NOTE, "tphci invalid bus_addr %s", 276 ddi_get_name_addr(dip)); 277 goto attach_fail; 278 } 279 280 /* 281 * Attach this instance with the mpxio framework 282 */ 283 if (mdi_phci_register(vclass + 1, dip, 0) != MDI_SUCCESS) { 284 cmn_err(CE_WARN, "%s mdi_phci_register failed", 285 ddi_node_name(dip)); 286 goto attach_fail; 287 } 288 phci_regis++; 289 290 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 291 instance, DDI_NT_SCSI_NEXUS, 0) != DDI_SUCCESS) { 292 cmn_err(CE_NOTE, "%s ddi_create_minor_node failed", 293 ddi_node_name(dip)); 294 goto attach_fail; 295 } 296 297 (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1); 298 ddi_report_dev(dip); 299 return (DDI_SUCCESS); 300 301 attach_fail: 302 if (phci_regis) 303 (void) mdi_phci_unregister(dip, 0); 304 305 ddi_soft_state_free(tphci_state, instance); 306 return (DDI_FAILURE); 307 } 308 309 310 /*ARGSUSED*/ 311 static int 312 tphci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 313 { 314 int instance = ddi_get_instance(dip); 315 316 switch (cmd) { 317 case DDI_DETACH: 318 break; 319 320 case DDI_SUSPEND: 321 case DDI_PM_SUSPEND: 322 return (0); /* nothing to do */ 323 324 default: 325 return (DDI_FAILURE); 326 } 327 328 if (mdi_phci_unregister(dip, 0) != MDI_SUCCESS) 329 return (DDI_FAILURE); 330 331 ddi_remove_minor_node(dip, NULL); 332 ddi_soft_state_free(tphci_state, instance); 333 334 return (DDI_SUCCESS); 335 } 336 337 /* 338 * tphci_getinfo() 339 * Given the device number, return the devinfo pointer or the 340 * instance number. 341 * Note: always succeed DDI_INFO_DEVT2INSTANCE, even before attach. 342 */ 343 344 /*ARGSUSED*/ 345 static int 346 tphci_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 347 { 348 struct tphci_state *phci; 349 int instance = getminor((dev_t)arg); 350 351 switch (cmd) { 352 case DDI_INFO_DEVT2DEVINFO: 353 phci = ddi_get_soft_state(tphci_state, instance); 354 if (phci != NULL) 355 *result = phci->dip; 356 else { 357 *result = NULL; 358 return (DDI_FAILURE); 359 } 360 break; 361 362 case DDI_INFO_DEVT2INSTANCE: 363 *result = (void *)(uintptr_t)instance; 364 break; 365 366 default: 367 return (DDI_FAILURE); 368 } 369 370 return (DDI_SUCCESS); 371 } 372 373 /* 374 * Interrupt stuff. NO OP for pseudo drivers. 375 */ 376 /*ARGSUSED*/ 377 static int 378 tphci_intr_op(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t op, 379 ddi_intr_handle_impl_t *hdlp, void *result) 380 { 381 return (DDI_FAILURE); 382 } 383 384 static int 385 tphci_ctl(dev_info_t *dip, dev_info_t *rdip, 386 ddi_ctl_enum_t ctlop, void *arg, void *result) 387 { 388 switch (ctlop) { 389 case DDI_CTLOPS_REPORTDEV: 390 if (rdip == (dev_info_t *)0) 391 return (DDI_FAILURE); 392 cmn_err(CE_CONT, "?tphci-device: %s%d\n", 393 ddi_get_name(rdip), ddi_get_instance(rdip)); 394 return (DDI_SUCCESS); 395 396 case DDI_CTLOPS_INITCHILD: 397 { 398 dev_info_t *child = (dev_info_t *)arg; 399 return (tphci_initchild(dip, child)); 400 } 401 402 case DDI_CTLOPS_UNINITCHILD: 403 { 404 dev_info_t *child = (dev_info_t *)arg; 405 return (tphci_uninitchild(dip, child)); 406 } 407 408 case DDI_CTLOPS_DMAPMAPC: 409 case DDI_CTLOPS_REPORTINT: 410 case DDI_CTLOPS_REGSIZE: 411 case DDI_CTLOPS_NREGS: 412 case DDI_CTLOPS_SIDDEV: 413 case DDI_CTLOPS_SLAVEONLY: 414 case DDI_CTLOPS_AFFINITY: 415 case DDI_CTLOPS_POKE: 416 case DDI_CTLOPS_PEEK: 417 /* 418 * These ops correspond to functions that "shouldn't" be called 419 * by a pseudo driver. So we whine when we're called. 420 */ 421 cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d\n", 422 ddi_get_name(dip), ddi_get_instance(dip), 423 ctlop, ddi_get_name(rdip), ddi_get_instance(rdip)); 424 return (DDI_FAILURE); 425 426 case DDI_CTLOPS_ATTACH: 427 case DDI_CTLOPS_BTOP: 428 case DDI_CTLOPS_BTOPR: 429 case DDI_CTLOPS_DETACH: 430 case DDI_CTLOPS_DVMAPAGESIZE: 431 case DDI_CTLOPS_IOMIN: 432 case DDI_CTLOPS_POWER: 433 case DDI_CTLOPS_PTOB: 434 default: 435 /* 436 * The ops that we pass up (default). We pass up memory 437 * allocation oriented ops that we receive - these may be 438 * associated with pseudo HBA drivers below us with target 439 * drivers below them that use ddi memory allocation 440 * interfaces like scsi_alloc_consistent_buf. 441 */ 442 return (ddi_ctlops(dip, rdip, ctlop, arg, result)); 443 } 444 } 445 446 static int 447 tphci_initchild(dev_info_t *dip, dev_info_t *child) 448 { 449 _NOTE(ARGUNUSED(dip)) 450 ddi_set_name_addr(child, "0"); 451 return (DDI_SUCCESS); 452 } 453 454 /*ARGSUSED*/ 455 static int 456 tphci_uninitchild(dev_info_t *dip, dev_info_t *child) 457 { 458 ddi_set_name_addr(child, NULL); 459 return (DDI_SUCCESS); 460 } 461 462 static int 463 tp_decode_name(char *devnm, char **cname, char **paddr, char **guid) 464 { 465 char *tmp; 466 467 i_ddi_parse_name(devnm, cname, paddr, NULL); 468 if ((strcmp(*cname, "tclient") != 0) && 469 (strcmp(*cname, "tphci") != 0) || *paddr == NULL) 470 return (-1); 471 472 tmp = strchr(*paddr, ','); 473 if (tmp == NULL || tmp[1] == '\0') 474 return (-1); 475 476 *guid = tmp + 1; 477 return (0); 478 } 479 480 static int 481 tphci_bus_config(dev_info_t *parent, uint_t flags, 482 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 483 { 484 _NOTE(ARGUNUSED(flags)) 485 char *cname, *paddr, *guid, *devnm; 486 mdi_pathinfo_t *pip; 487 int len, circ, rval; 488 489 switch (op) { 490 case BUS_CONFIG_ONE: 491 break; 492 case BUS_CONFIG_DRIVER: /* no direct children to configure */ 493 case BUS_CONFIG_ALL: 494 return (NDI_SUCCESS); 495 default: 496 return (NDI_FAILURE); 497 } 498 499 /* only implement BUS_CONFIG_ONE */ 500 devnm = i_ddi_strdup((char *)arg, KM_SLEEP); 501 len = strlen(devnm) + 1; 502 503 /* caddr is hardcoded in the form *,<guid> */ 504 if (tp_decode_name(devnm, &cname, &paddr, &guid) != 0) { 505 cmn_err(CE_NOTE, "tphci_bus_config -- invalid device %s", 506 (char *)arg); 507 kmem_free(devnm, len); 508 return (NDI_FAILURE); 509 } 510 511 mdi_devi_enter(parent, &circ); 512 rval = mdi_pi_alloc(parent, cname, guid, paddr, 0, &pip); 513 kmem_free(devnm, len); 514 if (rval != MDI_SUCCESS) { 515 cmn_err(CE_NOTE, "tphci_bus_config -- mdi_pi_alloc failed"); 516 mdi_devi_exit(parent, circ); 517 return (NDI_FAILURE); 518 } 519 520 /* 521 * Hold the path and exit the pHCI while calling mdi_pi_online 522 * to avoid deadlock with power management of pHCI. 523 */ 524 mdi_hold_path(pip); 525 mdi_devi_exit_phci(parent, circ); 526 rval = mdi_pi_online(pip, 0); 527 mdi_devi_enter_phci(parent, &circ); 528 mdi_rele_path(pip); 529 530 if (rval != MDI_SUCCESS) { 531 cmn_err(CE_NOTE, "tphci_bus_config -- mdi_pi_online failed"); 532 (void) mdi_pi_free(pip, 0); 533 mdi_devi_exit(parent, circ); 534 return (NDI_FAILURE); 535 } 536 537 if (childp) { 538 *childp = mdi_pi_get_client(pip); 539 ndi_hold_devi(*childp); 540 } 541 mdi_devi_exit(parent, circ); 542 543 return (NDI_SUCCESS); 544 } 545 546 static int 547 tphci_bus_unconfig(dev_info_t *parent, uint_t flags, 548 ddi_bus_config_op_t op, void *arg) 549 { 550 int rval = MDI_SUCCESS; 551 int circ; 552 mdi_pathinfo_t *pip, *next; 553 char *devnm, *cname, *caddr; 554 555 switch (op) { 556 case BUS_UNCONFIG_ONE: 557 devnm = (char *)arg; 558 i_ddi_parse_name(devnm, &cname, &caddr, NULL); 559 if (strcmp(cname, "tclient") != 0) 560 return (NDI_SUCCESS); /* no such device */ 561 562 mdi_devi_enter(parent, &circ); 563 pip = mdi_pi_find(parent, NULL, caddr); 564 if (pip) { 565 mdi_hold_path(pip); 566 mdi_devi_exit_phci(parent, circ); 567 rval = mdi_pi_offline(pip, NDI_DEVI_REMOVE); 568 mdi_devi_enter_phci(parent, &circ); 569 mdi_rele_path(pip); 570 571 if (rval == MDI_SUCCESS) 572 (void) mdi_pi_free(pip, 0); 573 } 574 mdi_devi_exit(parent, circ); 575 return (rval == MDI_SUCCESS ? NDI_SUCCESS : NDI_FAILURE); 576 577 case BUS_UNCONFIG_ALL: 578 if (flags & NDI_AUTODETACH) 579 return (NDI_FAILURE); 580 581 mdi_devi_enter(parent, &circ); 582 next = mdi_get_next_client_path(parent, NULL); 583 while ((pip = next) != NULL) { 584 next = mdi_get_next_client_path(parent, pip); 585 586 mdi_hold_path(pip); 587 mdi_devi_exit_phci(parent, circ); 588 rval = mdi_pi_offline(pip, NDI_DEVI_REMOVE); 589 mdi_devi_enter_phci(parent, &circ); 590 mdi_rele_path(pip); 591 592 if (rval != MDI_SUCCESS) 593 break; 594 (void) mdi_pi_free(pip, 0); 595 } 596 mdi_devi_exit(parent, circ); 597 return (rval == MDI_SUCCESS ? NDI_SUCCESS : NDI_FAILURE); 598 599 case BUS_UNCONFIG_DRIVER: /* nothing to do */ 600 return (NDI_SUCCESS); 601 602 default: 603 return (NDI_FAILURE); 604 } 605 /*NOTREACHED*/ 606 } 607