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 /* 29 * generic character driver 30 */ 31 #include <sys/types.h> 32 #include <sys/param.h> 33 #include <sys/errno.h> 34 #include <sys/uio.h> 35 #include <sys/buf.h> 36 #include <sys/modctl.h> 37 #include <sys/open.h> 38 #include <sys/kmem.h> 39 #include <sys/conf.h> 40 #include <sys/cmn_err.h> 41 #include <sys/stat.h> 42 #include <sys/ddi.h> 43 #include <sys/sunddi.h> 44 #include <sys/sunndi.h> 45 46 47 #define NUMEVENTS 6 48 #define COMPONENTS 2 49 #define COMP_0_MAXPWR 3 50 #define COMP_1_MAXPWR 2 51 #define MINPWR 0 52 static int maxpwr[] = { COMP_0_MAXPWR, COMP_1_MAXPWR }; 53 54 /* 55 * The state for each generic device. 56 * NOTE: We save the node_type in the state structure. The node_type string 57 * (and not a copy) is stashed in a minor node by ddi_create_minor_node(), 58 * so ddi_remove_minor_node() must occur prior to state free. 59 */ 60 typedef struct dstate { 61 uint_t flag; 62 dev_info_t *dip; /* my devinfo handle */ 63 char *node_type; /* stable node_type copy */ 64 ddi_callback_id_t gen_cb_ids[NUMEVENTS]; 65 kmutex_t lock; 66 char *nodename; 67 int level[COMPONENTS]; /* pm level */ 68 int busy[COMPONENTS]; /* busy state */ 69 } dstate_t; 70 71 72 static void *dstates; 73 74 static int gen_debug = 0; 75 76 #ifdef DEBUG 77 #define gen_debug gen_debug_on 78 static int gen_debug_on = 0; 79 #define GEN_DEBUG(args) if (gen_debug) cmn_err args 80 #else 81 #define GEN_DEBUG(args) 82 #endif 83 84 extern void prom_printf(const char *fmt, ...); 85 86 static int gen_open(dev_t *devp, int flag, int otyp, cred_t *cred); 87 static int gen_close(dev_t devp, int flag, int otyp, cred_t *cred); 88 static int gen_read(dev_t dev, struct uio *uiop, cred_t *credp); 89 static int gen_write(dev_t dev, struct uio *uiop, cred_t *credp); 90 static int gen_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, 91 cred_t *credp, int *rvalp); 92 static int gen_attach(dev_info_t *dip, ddi_attach_cmd_t cmd); 93 static int gen_detach(dev_info_t *dip, ddi_detach_cmd_t cmd); 94 static void gen_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie, 95 void *arg, void *impl_data); 96 97 static int gen_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 98 void **result); 99 static int gen_create_minor_nodes(dev_info_t *, struct dstate *); 100 static int gen_power(dev_info_t *, int, int); 101 102 static struct cb_ops gen_cb_ops = { 103 gen_open, /* open */ 104 gen_close, /* close */ 105 nodev, /* strategy */ 106 nodev, /* print */ 107 nodev, /* dump */ 108 gen_read, /* read */ 109 gen_write, /* write */ 110 gen_ioctl, /* ioctl */ 111 nodev, /* devmap */ 112 nodev, /* mmap */ 113 nodev, /* segmap */ 114 nochpoll, /* poll */ 115 ddi_prop_op, /* prop_op */ 116 NULL, /* streamtab */ 117 D_NEW | D_MP | D_HOTPLUG, /* flag */ 118 CB_REV, /* cb_rev */ 119 nodev, /* aread */ 120 nodev /* awrite */ 121 }; 122 123 124 static struct dev_ops gen_ops = { 125 DEVO_REV, /* devo_rev */ 126 0, /* refcnt */ 127 gen_info, /* getinfo */ 128 nulldev, /* identify */ 129 nulldev, /* probe */ 130 gen_attach, /* attach */ 131 gen_detach, /* detach */ 132 nodev, /* reset */ 133 &gen_cb_ops, /* driver ops */ 134 (struct bus_ops *)0, /* bus ops */ 135 gen_power, /* power */ 136 ddi_quiesce_not_supported, /* devo_quiesce */ 137 }; 138 139 /* 140 * INST_TO_MINOR() gives the starting minor number for a given gen_drv driver 141 * instance. A shift left by 6 bits allows for each instance to have upto 142 * 64 (2^6) minor numbers. The maximum minor number allowed by the system 143 * is L_MAXMIN32 (0x3ffff). This effectively limits the gen_drv instance 144 * numbers from 0 to 0xfff for a total of 4096 instances. 145 */ 146 #define INST_TO_MINOR(i) (i << 6) 147 #define MINOR_TO_INST(mn) (mn >> 6) 148 149 static char *mnodetypes[] = { 150 "ddi_nt", 151 "ddi_nt:device_type", 152 "ddi_nt:device_class:bus_class", 153 "ddi_nt2", 154 "ddi_nt2:device_type", 155 "ddi_nt2:device_type:bus_class", 156 }; 157 #define N_NTYPES (sizeof (mnodetypes) / sizeof (char *)) 158 159 static struct modldrv modldrv = { 160 &mod_driverops, 161 "generic test driver", 162 &gen_ops 163 }; 164 165 static struct modlinkage modlinkage = { 166 MODREV_1, &modldrv, NULL 167 }; 168 169 170 /* 171 * flags 172 */ 173 #define OPEN_FLAG 0x001 174 #define PWR_HAS_CHANGED_ON_RESUME_FLAG 0x002 175 #define FAIL_SUSPEND_FLAG 0x004 176 #define PUP_WITH_PWR_HAS_CHANGED_FLAG 0x008 177 #define POWER_FLAG 0x010 178 #define LOWER_POWER_FLAG 0x020 179 #define NO_INVOL_FLAG 0x040 180 #define PM_SUPPORTED_FLAG 0x080 181 182 /* 183 * ioctl commands (non-devctl ioctl commands) 184 */ 185 #define GENDRV_IOCTL ('P' << 8) 186 #define GENDRV_IOFAULT_SIMULATE (GENDRV_IOCTL | 0) 187 #define GENDRV_NDI_EVENT_TEST (GENDRV_IOCTL | 1) 188 189 int 190 _init(void) 191 { 192 int e; 193 194 if ((e = ddi_soft_state_init(&dstates, 195 sizeof (struct dstate), 0)) != 0) { 196 return (e); 197 } 198 199 if ((e = mod_install(&modlinkage)) != 0) { 200 ddi_soft_state_fini(&dstates); 201 } 202 203 return (e); 204 } 205 206 int 207 _fini(void) 208 { 209 int e; 210 211 if ((e = mod_remove(&modlinkage)) != 0) { 212 return (e); 213 } 214 ddi_soft_state_fini(&dstates); 215 return (e); 216 } 217 218 int 219 _info(struct modinfo *modinfop) 220 { 221 return (mod_info(&modlinkage, modinfop)); 222 } 223 224 static int 225 gen_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 226 { 227 int instance = ddi_get_instance(devi); 228 struct dstate *dstatep; 229 int rval; 230 int n_devs; 231 int n_minorcomps; 232 int isclone; 233 ddi_eventcookie_t dev_offline_cookie, dev_reset_cookie; 234 ddi_eventcookie_t bus_reset_cookie, bus_quiesce_cookie; 235 ddi_eventcookie_t bus_unquiesce_cookie, bus_test_post_cookie; 236 int i_init = 0; 237 int level_tmp; 238 239 int i; 240 char *pm_comp[] = { 241 "NAME=leaf0", 242 "0=D0", 243 "1=D1", 244 "2=D2", 245 "3=D3", 246 "NAME=leaf1", 247 "0=off", 248 "1=blank", 249 "2=on"}; 250 char *pm_hw_state = {"needs-suspend-resume"}; 251 252 253 switch (cmd) { 254 case DDI_ATTACH: 255 256 if (ddi_soft_state_zalloc(dstates, instance) != 257 DDI_SUCCESS) { 258 cmn_err(CE_CONT, "%s%d: can't allocate state\n", 259 ddi_get_name(devi), instance); 260 261 return (DDI_FAILURE); 262 } 263 264 dstatep = ddi_get_soft_state(dstates, instance); 265 dstatep->dip = devi; 266 mutex_init(&dstatep->lock, NULL, MUTEX_DRIVER, NULL); 267 268 n_devs = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, 269 "ndevs", 1); 270 271 isclone = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, 272 "isclone", 0); 273 274 n_minorcomps = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, 275 "ncomps", 1); 276 277 GEN_DEBUG((CE_CONT, 278 "%s%d attaching: n_devs=%d n_minorcomps=%d isclone=%d", 279 ddi_get_name(devi), ddi_get_instance(devi), 280 n_devs, n_minorcomps, isclone)); 281 282 if (isclone) { 283 if (ddi_create_minor_node(devi, "gen", S_IFCHR, 284 INST_TO_MINOR(instance), mnodetypes[0], 285 isclone) != DDI_SUCCESS) { 286 ddi_remove_minor_node(devi, NULL); 287 ddi_soft_state_free(dstates, instance); 288 cmn_err(CE_WARN, "%s%d: can't create minor " 289 "node", ddi_get_name(devi), instance); 290 291 return (DDI_FAILURE); 292 } 293 rval = DDI_SUCCESS; 294 } else { 295 rval = gen_create_minor_nodes(devi, dstatep); 296 if (rval != DDI_SUCCESS) { 297 ddi_prop_remove_all(devi); 298 ddi_remove_minor_node(devi, NULL); 299 ddi_soft_state_free(dstates, instance); 300 cmn_err(CE_WARN, "%s%d: can't create minor " 301 "nodes", ddi_get_name(devi), instance); 302 303 return (DDI_FAILURE); 304 } 305 } 306 307 if (ddi_get_eventcookie(devi, "pshot_dev_offline", 308 &dev_offline_cookie) == DDI_SUCCESS) { 309 (void) ddi_add_event_handler(devi, dev_offline_cookie, 310 gen_event_cb, NULL, &(dstatep->gen_cb_ids[0])); 311 } 312 313 if (ddi_get_eventcookie(devi, "pshot_dev_reset", 314 &dev_reset_cookie) == DDI_SUCCESS) { 315 (void) ddi_add_event_handler(devi, dev_reset_cookie, 316 gen_event_cb, NULL, &(dstatep->gen_cb_ids[1])); 317 } 318 319 if (ddi_get_eventcookie(devi, "pshot_bus_reset", 320 &bus_reset_cookie) == DDI_SUCCESS) { 321 (void) ddi_add_event_handler(devi, bus_reset_cookie, 322 gen_event_cb, NULL, &(dstatep->gen_cb_ids[2])); 323 } 324 325 if (ddi_get_eventcookie(devi, "pshot_bus_quiesce", 326 &bus_quiesce_cookie) == DDI_SUCCESS) { 327 (void) ddi_add_event_handler(devi, bus_quiesce_cookie, 328 gen_event_cb, NULL, &(dstatep->gen_cb_ids[3])); 329 } 330 331 if (ddi_get_eventcookie(devi, "pshot_bus_unquiesce", 332 &bus_unquiesce_cookie) == DDI_SUCCESS) { 333 (void) ddi_add_event_handler(devi, 334 bus_unquiesce_cookie, gen_event_cb, 335 NULL, &(dstatep->gen_cb_ids[4])); 336 } 337 338 if (ddi_get_eventcookie(devi, "pshot_bus_test_post", 339 &bus_test_post_cookie) == DDI_SUCCESS) { 340 (void) ddi_add_event_handler(devi, 341 bus_test_post_cookie, gen_event_cb, 342 NULL, &(dstatep->gen_cb_ids[5])); 343 } 344 345 /* 346 * initialize the devices' pm state 347 */ 348 mutex_enter(&dstatep->lock); 349 dstatep->flag &= ~OPEN_FLAG; 350 dstatep->flag &= ~PWR_HAS_CHANGED_ON_RESUME_FLAG; 351 dstatep->flag &= ~FAIL_SUSPEND_FLAG; 352 dstatep->flag &= ~PUP_WITH_PWR_HAS_CHANGED_FLAG; 353 dstatep->flag |= LOWER_POWER_FLAG; 354 dstatep->flag &= ~NO_INVOL_FLAG; 355 dstatep->flag |= PM_SUPPORTED_FLAG; 356 dstatep->busy[0] = 0; 357 dstatep->busy[1] = 0; 358 dstatep->level[0] = -1; 359 dstatep->level[1] = -1; 360 mutex_exit(&dstatep->lock); 361 362 /* 363 * stash the nodename 364 */ 365 dstatep->nodename = ddi_node_name(devi); 366 367 /* 368 * Check if the no-involuntary-power-cycles property 369 * was created. Set NO_INVOL_FLAG if so. 370 */ 371 if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip, 372 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM), 373 "no-involuntary-power-cycles") == 1) { 374 GEN_DEBUG((CE_CONT, 375 "%s%d: DDI_ATTACH:\n\tno-involuntary-power-cycles" 376 " property was created", 377 ddi_node_name(devi), ddi_get_instance(devi))); 378 mutex_enter(&dstatep->lock); 379 dstatep->flag |= NO_INVOL_FLAG; 380 mutex_exit(&dstatep->lock); 381 } 382 383 /* 384 * Check if the dependency-property property 385 * was created. 386 */ 387 if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip, 388 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM), 389 "dependency-property") == 1) { 390 GEN_DEBUG((CE_CONT, 391 "%s%d: DDI_ATTACH:\n\tdependency-property" 392 " property was created", 393 ddi_node_name(devi), ddi_get_instance(devi))); 394 } 395 396 /* 397 * create the pm-components property. two comps: 398 * 4 levels on comp0, 3 on comp 1. 399 * - skip for a "tape" device, clear PM_SUPPORTED_FLAG 400 */ 401 if (strcmp(ddi_node_name(devi), "tape") != 0) { 402 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi, 403 "pm-components", pm_comp, 9) != DDI_PROP_SUCCESS) { 404 cmn_err(CE_WARN, "%s%d: %s\n", 405 ddi_node_name(devi), 406 ddi_get_instance(devi), 407 "unable to create \"pm-components\" " 408 " property."); 409 410 return (DDI_FAILURE); 411 } 412 } else { 413 mutex_enter(&dstatep->lock); 414 dstatep->flag &= ~PM_SUPPORTED_FLAG; 415 mutex_exit(&dstatep->lock); 416 } 417 418 /* 419 * Check if the pm-components property was created 420 */ 421 if (dstatep->flag & PM_SUPPORTED_FLAG) { 422 if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip, 423 (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM), 424 "pm-components") != 1) { 425 cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t%s", 426 ddi_node_name(devi), 427 ddi_get_instance(devi), 428 "\"pm-components\" property does" 429 " not exist"); 430 431 return (DDI_FAILURE); 432 433 } else { 434 GEN_DEBUG((CE_CONT, "%s%d: DDI_ATTACH:" 435 " created pm-components property", 436 ddi_node_name(devi), 437 ddi_get_instance(devi))); 438 } 439 } 440 441 /* 442 * create the pm-hardware-state property. 443 * needed to get DDI_SUSPEND and DDI_RESUME calls 444 */ 445 if (ddi_prop_update_string(DDI_DEV_T_NONE, devi, 446 "pm-hardware-state", pm_hw_state) != DDI_PROP_SUCCESS) { 447 cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t%s\n", 448 ddi_node_name(devi), ddi_get_instance(devi), 449 "unable to create \"pm-hardware-state\" " 450 " property."); 451 452 return (DDI_FAILURE); 453 } 454 455 /* 456 * set power levels to max via pm_raise_power(), 457 */ 458 mutex_enter(&dstatep->lock); 459 i_init = (dstatep->flag & PM_SUPPORTED_FLAG) ? 0 : COMPONENTS; 460 mutex_exit(&dstatep->lock); 461 for (i = i_init; i < COMPONENTS; i++) { 462 GEN_DEBUG((CE_CONT, 463 "%s%d: DDI_ATTACH: pm_raise_power comp %d " 464 "to level %d", ddi_node_name(devi), 465 ddi_get_instance(devi), i, maxpwr[i])); 466 if (pm_raise_power(dstatep->dip, i, maxpwr[i]) != 467 DDI_SUCCESS) { 468 cmn_err(CE_WARN, 469 "%s%d: DDI_ATTACH: pm_raise_power failed\n", 470 ddi_node_name(devi), 471 ddi_get_instance(devi)); 472 dstatep->level[i] = -1; 473 474 return (DDI_FAILURE); 475 } 476 } 477 478 if (rval == DDI_SUCCESS) { 479 ddi_report_dev(devi); 480 } 481 return (rval); 482 483 484 case DDI_RESUME: 485 GEN_DEBUG((CE_CONT, "%s%d: DDI_RESUME", ddi_node_name(devi), 486 ddi_get_instance(devi))); 487 488 dstatep = ddi_get_soft_state(dstates, ddi_get_instance(devi)); 489 if (dstatep == NULL) { 490 491 return (DDI_FAILURE); 492 } 493 494 /* 495 * Call pm_power_has_changed() if flag 496 * PWR_HAS_CHANGED_ON_RESUME_FLAG is set, 497 * then clear the flag 498 */ 499 mutex_enter(&dstatep->lock); 500 i_init = (dstatep->flag & PM_SUPPORTED_FLAG) ? 0 : COMPONENTS; 501 mutex_exit(&dstatep->lock); 502 if (dstatep->flag & PWR_HAS_CHANGED_ON_RESUME_FLAG) { 503 for (i = i_init; i < COMPONENTS; i++) { 504 GEN_DEBUG((CE_CONT, 505 "%s%d: DDI_RESUME: pm_power_has_changed " 506 "comp %d to level %d", ddi_node_name(devi), 507 ddi_get_instance(devi), i, maxpwr[i])); 508 mutex_enter(&dstatep->lock); 509 level_tmp = dstatep->level[i]; 510 dstatep->level[i] = maxpwr[i]; 511 if (pm_power_has_changed(dstatep->dip, i, 512 maxpwr[i]) != DDI_SUCCESS) { 513 cmn_err(CE_WARN, 514 "%s%d: DDI_RESUME:\n\t" 515 " pm_power_has_changed" 516 " failed: comp %d to level %d\n", 517 ddi_node_name(devi), 518 ddi_get_instance(devi), 519 i, maxpwr[i]); 520 dstatep->level[i] = level_tmp; 521 } 522 mutex_exit(&dstatep->lock); 523 } 524 } else { 525 /* 526 * Call pm_raise_power() instead 527 */ 528 for (i = i_init; i < COMPONENTS; i++) { 529 GEN_DEBUG((CE_CONT, 530 "%s%d: DDI_RESUME: pm_raise_power" 531 " comp %d to level %d", 532 ddi_node_name(devi), ddi_get_instance(devi), 533 i, maxpwr[i])); 534 if (pm_raise_power(dstatep->dip, i, maxpwr[i]) 535 != DDI_SUCCESS) { 536 cmn_err(CE_WARN, 537 "%s%d: DDI_RESUME:" 538 "\n\tpm_raise_power" 539 "failed: comp %d to level %d\n", 540 ddi_node_name(devi), 541 ddi_get_instance(devi), 542 i, maxpwr[i]); 543 } 544 } 545 } 546 547 return (DDI_SUCCESS); 548 549 default: 550 GEN_DEBUG((CE_WARN, "attach: default")); 551 return (DDI_FAILURE); 552 } 553 } 554 555 static int 556 gen_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 557 { 558 struct dstate *dstatep; 559 int instance; 560 int i; 561 int rv; 562 int rm_power; 563 int level_tmp; 564 565 #ifdef DEBUG 566 int n_devs; 567 int n_minorcomps; 568 int isclone; 569 #endif 570 571 switch (cmd) { 572 case DDI_DETACH: 573 GEN_DEBUG((CE_CONT, "%s%d: DDI_DETACH", ddi_node_name(devi), 574 ddi_get_instance(devi))); 575 576 instance = ddi_get_instance(devi); 577 dstatep = ddi_get_soft_state(dstates, instance); 578 if (dstatep == NULL) { 579 580 return (DDI_FAILURE); 581 } 582 583 #ifdef DEBUG 584 n_devs = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, 585 "ndevs", 1); 586 587 isclone = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, 588 "isclone", 0); 589 590 n_minorcomps = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, 591 "ncomps", 1); 592 #endif /* DEBUG */ 593 594 /* 595 * power off component 1. 596 */ 597 if (dstatep->flag & PM_SUPPORTED_FLAG) { 598 GEN_DEBUG((CE_CONT, 599 "%s%d: DDI_DETACH: pm_lower_power comp 1 level %d", 600 ddi_node_name(devi), ddi_get_instance(devi), 601 MINPWR)); 602 if (pm_lower_power(dstatep->dip, 1, MINPWR) 603 != DDI_SUCCESS) { 604 cmn_err(CE_WARN, "%s%d: DDI_DETACH:\n\t" 605 "pm_lower_power failed for comp 1 to" 606 " level %d\n", ddi_node_name(devi), 607 ddi_get_instance(devi), MINPWR); 608 609 return (DDI_FAILURE); 610 } 611 612 /* 613 * check power level. Issue pm_power_has_changed 614 * if not at MINPWR. 615 */ 616 mutex_enter(&dstatep->lock); 617 level_tmp = dstatep->level[1]; 618 dstatep->level[1] = MINPWR; 619 if (dstatep->level[1] != MINPWR) { 620 GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:" 621 " power off via pm_power_has_changed" 622 " instead", ddi_node_name(devi), 623 ddi_get_instance(devi))); 624 if (pm_power_has_changed(dstatep->dip, 625 1, MINPWR) != DDI_SUCCESS) { 626 GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:" 627 " pm_power_has_changed failed for" 628 " comp 1 to level %d", 629 ddi_node_name(devi), 630 ddi_get_instance(devi), 631 MINPWR)); 632 dstatep->level[1] = level_tmp; 633 mutex_exit(&dstatep->lock); 634 635 return (DDI_FAILURE); 636 } 637 } 638 mutex_exit(&dstatep->lock); 639 } 640 641 /* 642 * If the LOWER_POWER_FLAG flag is not set, 643 * don't call pm_lowr_power() for comp 0. 644 * This should be used only for the XXXXX@XX,no_invol 645 * devices that export the 646 * no-involuntary-power-cycles property 647 */ 648 if (!(dstatep->flag & LOWER_POWER_FLAG) && 649 dstatep->flag & PM_SUPPORTED_FLAG) { 650 cmn_err(CE_NOTE, "%s%d: DDI_DETACH:\n\t" 651 " NOT CALLING PM_LOWER_POWER():" 652 " LOWER_POWER_FLAG NOT SET\n", 653 ddi_node_name(devi), ddi_get_instance(devi)); 654 } else if (dstatep->flag & PM_SUPPORTED_FLAG) { 655 GEN_DEBUG((CE_CONT, 656 "%s%d: DDI_DETACH: pm_lower_power comp 0 level %d", 657 ddi_node_name(devi), ddi_get_instance(devi), 658 MINPWR)); 659 if (pm_lower_power(dstatep->dip, 0, MINPWR) 660 != DDI_SUCCESS) { 661 cmn_err(CE_WARN, "%s%d: DDI_DETACH:\n\t" 662 "pm_lower_power failed for comp 0 to" 663 " level %d\n", ddi_node_name(devi), 664 ddi_get_instance(devi), MINPWR); 665 666 return (DDI_FAILURE); 667 } 668 669 /* 670 * check power level. Issue pm_power_has_changed 671 * if not at MINPWR. 672 */ 673 mutex_enter(&dstatep->lock); 674 level_tmp = dstatep->level[0]; 675 dstatep->level[0] = MINPWR; 676 if (dstatep->level[0] != MINPWR) { 677 GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:" 678 " power off via pm_power_has_changed" 679 " instead", ddi_node_name(devi), 680 ddi_get_instance(devi))); 681 if (pm_power_has_changed(dstatep->dip, 682 0, MINPWR) != DDI_SUCCESS) { 683 GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:" 684 " pm_power_has_changed failed for" 685 " comp 0 to level %d", 686 ddi_node_name(devi), 687 ddi_get_instance(devi), 688 MINPWR)); 689 dstatep->level[0] = level_tmp; 690 mutex_exit(&dstatep->lock); 691 692 return (DDI_FAILURE); 693 } 694 } 695 mutex_exit(&dstatep->lock); 696 } 697 698 GEN_DEBUG((CE_CONT, 699 "%s%d detaching: n_devs=%d n_minorcomps=%d isclone=%d", 700 ddi_node_name(devi), ddi_get_instance(devi), 701 n_devs, n_minorcomps, isclone)); 702 703 for (i = 0; i < NUMEVENTS; i++) { 704 if (dstatep->gen_cb_ids[i]) { 705 (void) ddi_remove_event_handler(dstatep->gen_cb_ids[i]); 706 dstatep->gen_cb_ids[i] = NULL; 707 } 708 } 709 710 ddi_prop_remove_all(devi); 711 ddi_remove_minor_node(devi, NULL); 712 if (dstatep->node_type) 713 kmem_free(dstatep->node_type, 714 strlen(dstatep->node_type) + 1); 715 ddi_soft_state_free(dstates, instance); 716 return (DDI_SUCCESS); 717 718 case DDI_SUSPEND: 719 GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND", 720 ddi_node_name(devi), ddi_get_instance(devi))); 721 722 instance = ddi_get_instance(devi); 723 dstatep = ddi_get_soft_state(dstates, instance); 724 if (dstatep == NULL) { 725 726 return (DDI_FAILURE); 727 } 728 729 /* 730 * fail the suspend if FAIL_SUSPEND_FLAG is set. 731 * clear the FAIL_SUSPEND_FLAG flag 732 */ 733 mutex_enter(&dstatep->lock); 734 if (dstatep->flag & FAIL_SUSPEND_FLAG) { 735 GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:" 736 " FAIL_SUSPEND_FLAG is set," 737 " fail suspend", 738 ddi_node_name(devi), ddi_get_instance(devi))); 739 dstatep->flag &= ~FAIL_SUSPEND_FLAG; 740 rv = DDI_FAILURE; 741 } else { 742 rv = DDI_SUCCESS; 743 } 744 mutex_exit(&dstatep->lock); 745 746 /* 747 * Issue ddi_removing_power() to determine if the suspend 748 * was initiated by either CPR or DR. If CPR, the system 749 * will be powered OFF; if this driver has set the 750 * NO_INVOL_FLAG, then refuse to suspend. If DR, power 751 * will not be removed, thus allow the suspend. 752 */ 753 if (dstatep->flag & NO_INVOL_FLAG && 754 dstatep->flag & PM_SUPPORTED_FLAG) { 755 GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:" 756 " check via ddi_removing_power()", 757 ddi_node_name(devi), ddi_get_instance(devi))); 758 759 rm_power = ddi_removing_power(dstatep->dip); 760 761 if (rm_power < 0) { 762 cmn_err(CE_WARN, "%s%d: DDI_SUSPEND:" 763 " ddi_removing_power() failed\n", 764 ddi_node_name(devi), 765 ddi_get_instance(devi)); 766 } else if (rm_power == 1) { 767 /* 768 * CPR: power will be removed 769 */ 770 GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:\n\t" 771 " CPR: POWER WILL BE REMOVED, THEREFORE" 772 " REFUSE TO SUSPEND", ddi_node_name(devi), 773 ddi_get_instance(devi))); 774 rv = DDI_FAILURE; 775 } else if (rm_power == 0) { 776 /* 777 * DR: power will not be removed 778 */ 779 GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:\n\t" 780 " DR: POWER WILL NOT BE REMOVED, THEREFORE" 781 " ALLOW THE SUSPEND", ddi_node_name(devi), 782 ddi_get_instance(devi))); 783 rv = DDI_SUCCESS; 784 } 785 } 786 787 /* 788 * power OFF via pm_power_has_changed() 789 */ 790 mutex_enter(&dstatep->lock); 791 if (dstatep->flag & PM_SUPPORTED_FLAG && 792 !(dstatep->flag & NO_INVOL_FLAG)) { 793 level_tmp = dstatep->level[0]; 794 dstatep->level[0] = MINPWR; 795 GEN_DEBUG((CE_CONT, 796 "%s%d: DDI_SUSPEND: pm_power_has_changed comp 0" 797 " level %d", ddi_node_name(devi), 798 ddi_get_instance(devi), MINPWR)); 799 if (pm_power_has_changed(dstatep->dip, 0, MINPWR) 800 != DDI_SUCCESS) { 801 cmn_err(CE_WARN, "%s%d: DDI_SUSPEND:\n\t" 802 "pm_power_has_changed failed for comp 0 to" 803 " level %d\n", ddi_node_name(devi), 804 ddi_get_instance(devi), MINPWR); 805 dstatep->level[0] = level_tmp; 806 mutex_exit(&dstatep->lock); 807 808 return (DDI_FAILURE); 809 } 810 } 811 mutex_exit(&dstatep->lock); 812 813 return (rv); 814 815 default: 816 817 return (DDI_FAILURE); 818 } 819 } 820 821 /* ARGSUSED */ 822 static int 823 gen_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 824 { 825 dev_t dev; 826 int instance; 827 828 if (infocmd != DDI_INFO_DEVT2INSTANCE) 829 return (DDI_FAILURE); 830 831 dev = (dev_t)arg; 832 instance = MINOR_TO_INST(getminor(dev)); 833 *result = (void *)(uintptr_t)instance; 834 return (DDI_SUCCESS); 835 } 836 837 838 /*ARGSUSED*/ 839 static int 840 gen_open(dev_t *devp, int flag, int otyp, cred_t *cred) 841 { 842 minor_t minor; 843 struct dstate *dstatep; 844 845 if (otyp != OTYP_BLK && otyp != OTYP_CHR) 846 return (EINVAL); 847 848 minor = getminor(*devp); 849 if ((dstatep = ddi_get_soft_state(dstates, 850 MINOR_TO_INST(minor))) == NULL) 851 return (ENXIO); 852 853 mutex_enter(&dstatep->lock); 854 dstatep->flag |= OPEN_FLAG; 855 mutex_exit(&dstatep->lock); 856 857 GEN_DEBUG((CE_CONT, 858 "%s%d open", 859 dstatep->nodename, MINOR_TO_INST(minor))); 860 861 return (0); 862 } 863 864 /*ARGSUSED*/ 865 static int 866 gen_close(dev_t dev, int flag, int otyp, cred_t *cred) 867 { 868 struct dstate *dstatep; 869 minor_t minor = getminor(dev); 870 871 if (otyp != OTYP_BLK && otyp != OTYP_CHR) 872 return (EINVAL); 873 874 dstatep = ddi_get_soft_state(dstates, MINOR_TO_INST(minor)); 875 876 if (dstatep == NULL) 877 return (ENXIO); 878 879 mutex_enter(&dstatep->lock); 880 dstatep->flag &= ~OPEN_FLAG; 881 mutex_exit(&dstatep->lock); 882 883 GEN_DEBUG((CE_CONT, 884 "%s%d close", 885 dstatep->nodename, MINOR_TO_INST(minor))); 886 887 return (0); 888 } 889 890 /*ARGSUSED*/ 891 static int 892 gen_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp) 893 { 894 struct dstate *dstatep; 895 ddi_eventcookie_t cookie; 896 int instance; 897 int rval = 0; 898 char *nodename; 899 int i; 900 struct devctl_iocdata *dcp; 901 uint_t state; 902 int ret; 903 int level_tmp; 904 905 instance = MINOR_TO_INST(getminor(dev)); 906 dstatep = ddi_get_soft_state(dstates, instance); 907 nodename = dstatep->nodename; 908 909 if (dstatep == NULL) 910 return (ENXIO); 911 912 /* 913 * read devctl ioctl data 914 */ 915 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 916 return (EFAULT); 917 918 switch (cmd) { 919 case GENDRV_IOFAULT_SIMULATE: 920 if (ddi_get_eventcookie(dstatep->dip, DDI_DEVI_FAULT_EVENT, 921 &(cookie)) != NDI_SUCCESS) 922 return (DDI_FAILURE); 923 924 return (ndi_post_event(dstatep->dip, dstatep->dip, cookie, 925 NULL)); 926 927 case GENDRV_NDI_EVENT_TEST: 928 if (ddi_get_eventcookie(dstatep->dip, "pshot_dev_offline", 929 &cookie) == NDI_SUCCESS) { 930 (void) ndi_post_event(dstatep->dip, dstatep->dip, 931 cookie, NULL); 932 } 933 934 if (ddi_get_eventcookie(dstatep->dip, "pshot_dev_reset", 935 &cookie) == NDI_SUCCESS) { 936 (void) ndi_post_event(dstatep->dip, dstatep->dip, 937 cookie, NULL); 938 } 939 940 if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_reset", 941 &cookie) == NDI_SUCCESS) { 942 (void) ndi_post_event(dstatep->dip, dstatep->dip, 943 cookie, NULL); 944 } 945 946 if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_quiesce", 947 &cookie) == NDI_SUCCESS) { 948 (void) ndi_post_event(dstatep->dip, dstatep->dip, 949 cookie, NULL); 950 } 951 952 if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_unquiesce", 953 &cookie) == NDI_SUCCESS) { 954 (void) ndi_post_event(dstatep->dip, dstatep->dip, 955 cookie, NULL); 956 } 957 958 if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_test_post", 959 &cookie) == NDI_SUCCESS) { 960 (void) ndi_post_event(dstatep->dip, dstatep->dip, 961 cookie, NULL); 962 } 963 964 break; 965 966 case DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME: 967 /* 968 * Issue pm_power_has_changed() call on DDI_RESUME 969 */ 970 mutex_enter(&dstatep->lock); 971 dstatep->flag |= PWR_HAS_CHANGED_ON_RESUME_FLAG; 972 mutex_exit(&dstatep->lock); 973 GEN_DEBUG((CE_CONT, "%s%d:" 974 " DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME", nodename, 975 instance)); 976 977 break; 978 979 case DEVCTL_PM_FAIL_SUSPEND: 980 /* 981 * Fail the suspend attempt in DDI_SUSPEND 982 */ 983 mutex_enter(&dstatep->lock); 984 dstatep->flag |= FAIL_SUSPEND_FLAG; 985 mutex_exit(&dstatep->lock); 986 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_FAIL_SUSPEND", 987 nodename, instance)); 988 989 break; 990 991 case DEVCTL_PM_PUP_WITH_PWR_HAS_CHANGED: 992 /* 993 * Use pm_power_has_changed() to power up comp 0 when 994 * enforcing the comp 0 vs comp-not 0 dependency: 995 * Power up comp 0 first, if request for comp-not-0 996 * comes in. 997 * Else, default to pm_raise_power(). 998 */ 999 mutex_enter(&dstatep->lock); 1000 dstatep->flag |= PUP_WITH_PWR_HAS_CHANGED_FLAG; 1001 mutex_exit(&dstatep->lock); 1002 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_PUP_WITH_PWR_HAS_CHANGED", 1003 nodename, instance)); 1004 1005 break; 1006 1007 case DEVCTL_PM_BUSY_COMP: 1008 /* 1009 * mark component 0 busy via a pm_busy_component() call. 1010 * update the busy[] array. 1011 */ 1012 mutex_enter(&dstatep->lock); 1013 ++dstatep->busy[0]; 1014 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_BUSY_COMP: comp 0:" 1015 " busy=%d", nodename, instance, dstatep->busy[0])); 1016 mutex_exit(&dstatep->lock); 1017 ret = pm_busy_component(dstatep->dip, 0); 1018 ASSERT(ret == DDI_SUCCESS); 1019 1020 break; 1021 1022 case DEVCTL_PM_BUSY_COMP_TEST: 1023 /* 1024 * test busy state on component 0 1025 */ 1026 mutex_enter(&dstatep->lock); 1027 state = dstatep->busy[0]; 1028 if (copyout(&state, dcp->cpyout_buf, 1029 sizeof (uint_t)) != 0) { 1030 cmn_err(CE_WARN, "%s%d:" 1031 " DEVCTL_PM_BUSY_COMP_TEST: copyout failed\n", 1032 nodename, instance); 1033 rval = EINVAL; 1034 } 1035 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_BUSY_COMP_TEST:" 1036 " comp 0 busy %d", 1037 nodename, instance, state)); 1038 mutex_exit(&dstatep->lock); 1039 1040 break; 1041 1042 case DEVCTL_PM_IDLE_COMP: 1043 /* 1044 * mark component 0 idle via a pm_idle_component() call. 1045 * NOP if dstatep->busy[0] == 0. 1046 */ 1047 mutex_enter(&dstatep->lock); 1048 if (dstatep->busy[0] > 0) { 1049 --dstatep->busy[0]; 1050 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_IDLE_COMP:" 1051 " comp 0: busy=%d", nodename, instance, 1052 dstatep->busy[0])); 1053 mutex_exit(&dstatep->lock); 1054 ret = pm_idle_component(dstatep->dip, 0); 1055 ASSERT(ret == DDI_SUCCESS); 1056 } else { 1057 mutex_exit(&dstatep->lock); 1058 } 1059 1060 break; 1061 1062 case DEVCTL_PM_PROM_PRINTF: 1063 (void) prom_printf("%s%d: PROM_PRINTF FROM GEN_DRV\n", 1064 nodename, instance); 1065 1066 break; 1067 1068 case DEVCTL_PM_RAISE_PWR: 1069 /* 1070 * power up both components to MAXPWR via 1071 * pm_raise_power() calls. this ioctl() cmd 1072 * assumes that the current level is 0 1073 */ 1074 for (i = 0; i < COMPONENTS; i++) { 1075 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_RAISE_PWR:" 1076 " comp %d old 0 new %d", 1077 nodename, instance, i, maxpwr[i])); 1078 if (pm_raise_power(dstatep->dip, 0, maxpwr[i]) 1079 != DDI_SUCCESS) { 1080 rval = EINVAL; 1081 } 1082 } 1083 1084 break; 1085 1086 case DEVCTL_PM_CHANGE_PWR_LOW: 1087 /* 1088 * power off both components via pm_power_has_changed() calls 1089 */ 1090 for (i = (COMPONENTS - 1); i >= 0; --i) { 1091 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_CHANGE_PWR_LOW:" 1092 " comp %d new 0", 1093 nodename, instance, i)); 1094 mutex_enter(&dstatep->lock); 1095 level_tmp = dstatep->level[i]; 1096 dstatep->level[i] = 0; 1097 if (pm_power_has_changed(dstatep->dip, i, 0) 1098 != DDI_SUCCESS) { 1099 dstatep->level[i] = level_tmp; 1100 rval = EINVAL; 1101 } 1102 mutex_exit(&dstatep->lock); 1103 } 1104 1105 break; 1106 1107 case DEVCTL_PM_CHANGE_PWR_HIGH: 1108 /* 1109 * power up both components to MAXPWR via 1110 * pm_power_has_changed() calls 1111 */ 1112 for (i = 0; i < COMPONENTS; i++) { 1113 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_CHANGE_PWR_HIGH:" 1114 " comp %d new %d", 1115 nodename, instance, i, maxpwr[i])); 1116 mutex_enter(&dstatep->lock); 1117 level_tmp = dstatep->level[i]; 1118 dstatep->level[i] = maxpwr[i]; 1119 if (pm_power_has_changed(dstatep->dip, i, maxpwr[i]) 1120 != DDI_SUCCESS) { 1121 dstatep->level[i] = level_tmp; 1122 rval = EINVAL; 1123 } 1124 mutex_exit(&dstatep->lock); 1125 } 1126 1127 break; 1128 1129 case DEVCTL_PM_POWER: 1130 /* 1131 * test if the gen_drv_power() routine has been called, 1132 * then clear 1133 */ 1134 mutex_enter(&dstatep->lock); 1135 state = (dstatep->flag & POWER_FLAG) ? 1 : 0; 1136 if (copyout(&state, dcp->cpyout_buf, 1137 sizeof (uint_t)) != 0) { 1138 cmn_err(CE_WARN, "%s%d: DEVCTL_PM_POWER:" 1139 " copyout failed\n", nodename, instance); 1140 rval = EINVAL; 1141 } 1142 GEN_DEBUG((CE_CONT, "%s%d: %s POWER_FLAG: %d", 1143 nodename, instance, "DEVCTL_PM_POWER", state)); 1144 dstatep->flag &= ~POWER_FLAG; 1145 mutex_exit(&dstatep->lock); 1146 break; 1147 1148 case DEVCTL_PM_NO_LOWER_POWER: 1149 /* 1150 * issue to not invoke pm_lower_power() on detach 1151 */ 1152 mutex_enter(&dstatep->lock); 1153 dstatep->flag &= ~LOWER_POWER_FLAG; 1154 mutex_exit(&dstatep->lock); 1155 GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_NO_LOWER_POWER", 1156 nodename, instance)); 1157 break; 1158 1159 default: 1160 return (ENOTTY); 1161 } 1162 1163 return (rval); 1164 } 1165 1166 /*ARGSUSED*/ 1167 static int 1168 gen_read(dev_t dev, struct uio *uiop, cred_t *credp) 1169 { 1170 return (0); 1171 } 1172 1173 /*ARGSUSED*/ 1174 static int 1175 gen_write(dev_t dev, struct uio *uiop, cred_t *credp) 1176 { 1177 return (0); 1178 } 1179 1180 /*ARGSUSED0*/ 1181 static int 1182 gen_power(dev_info_t *dip, int cmpt, int level) 1183 { 1184 struct dstate *dstatep; 1185 int instance = ddi_get_instance(dip); 1186 char *nodename = ddi_node_name(dip); 1187 int level_tmp; 1188 1189 GEN_DEBUG((CE_CONT, "%s%d: power: cmpt %d to level %d", 1190 nodename, instance, cmpt, level)); 1191 1192 dstatep = ddi_get_soft_state(dstates, instance); 1193 if (dstatep == NULL) { 1194 1195 return (DDI_FAILURE); 1196 } 1197 1198 /* 1199 * Keep track of the power levels for both components 1200 * in the dstatep->comp[] array. 1201 * Set comp 0 to full level if non-zero comps 1202 * are being set to a higher, non-zero level. 1203 */ 1204 if (cmpt == 0) { 1205 mutex_enter(&dstatep->lock); 1206 dstatep->level[cmpt] = level; 1207 mutex_exit(&dstatep->lock); 1208 } else if (level > dstatep->level[cmpt] && level != 0 && 1209 dstatep->level[0] != COMP_0_MAXPWR) { 1210 /* 1211 * If component 0 is not at COMP_0_MAXPWR, and component 1 1212 * is being powered ON, invoke pm_raise_power() or 1213 * pm_power_has_changed() based on the 1214 * PUP_WITH_PWR_HAS_CHANGED_FLAG flag. 1215 * PUP_WITH_PWR_HAS_CHANGED_FLAG = FALSE by default, invoking 1216 * pm_raise_power(). 1217 */ 1218 if (!(dstatep->flag & PUP_WITH_PWR_HAS_CHANGED_FLAG)) { 1219 /* 1220 * first set comp 0 to level COMP_0_MAXPWR 1221 */ 1222 GEN_DEBUG((CE_CONT, "%s%d: power: " 1223 "pm_raise_power: comp 0 to level %d", 1224 nodename, instance, COMP_0_MAXPWR)); 1225 if (pm_raise_power(dip, 0, COMP_0_MAXPWR) != 1226 DDI_SUCCESS) { 1227 cmn_err(CE_WARN, 1228 "%s%d: power: pm_raise_power() " 1229 "failed: comp 0 to level %d\n", 1230 nodename, instance, COMP_0_MAXPWR); 1231 1232 return (DDI_FAILURE); 1233 1234 } else { 1235 mutex_enter(&dstatep->lock); 1236 dstatep->level[0] = COMP_0_MAXPWR; 1237 /* 1238 * now set the level on the non-zero comp 1239 */ 1240 dstatep->level[cmpt] = level; 1241 mutex_exit(&dstatep->lock); 1242 GEN_DEBUG((CE_CONT, "%s%d: power: " 1243 "comp %d to level %d", 1244 nodename, instance, cmpt, level)); 1245 } 1246 } else { 1247 GEN_DEBUG((CE_CONT, "%s%d: power: " 1248 "pm_power_has_changed: comp 0 to level %d", 1249 nodename, instance, COMP_0_MAXPWR)); 1250 mutex_enter(&dstatep->lock); 1251 level_tmp = dstatep->level[0]; 1252 dstatep->level[0] = COMP_0_MAXPWR; 1253 if (pm_power_has_changed(dip, 0, COMP_0_MAXPWR) != 1254 DDI_SUCCESS) { 1255 cmn_err(CE_WARN, 1256 "%s%d: power: pm_power_has_changed() " 1257 "failed: comp 0 to level %d\n", 1258 nodename, instance, COMP_0_MAXPWR); 1259 dstatep->level[0] = level_tmp; 1260 } else { 1261 /* 1262 * now set the level on the non-zero comp 1263 */ 1264 GEN_DEBUG((CE_CONT, "%s%d: power:" 1265 " pm_power_has_changed: comp %d" 1266 " to level %d", nodename, instance, 1267 cmpt, level)); 1268 dstatep->level[cmpt] = level; 1269 } 1270 mutex_exit(&dstatep->lock); 1271 } 1272 } else { 1273 mutex_enter(&dstatep->lock); 1274 dstatep->level[cmpt] = level; 1275 mutex_exit(&dstatep->lock); 1276 } 1277 1278 return (DDI_SUCCESS); 1279 } 1280 1281 1282 /* 1283 * Create properties of various data types for testing devfs events. 1284 */ 1285 static int 1286 gen_create_properties(dev_info_t *devi) 1287 { 1288 int int_val = 3023; 1289 int int_array[] = { 3, 10, 304, 230, 4}; 1290 int64_t int64_val = 20; 1291 int64_t int64_array[] = { 12, 24, 36, 48}; 1292 char *string_val = "Dev_node_prop"; 1293 char *string_array[] = {"Dev_node_prop:0", 1294 "Dev_node_prop:1", "Dev_node_prop:2", "Dev_node_prop:3"}; 1295 uchar_t byte_array[] = { (uchar_t)0xaa, (uchar_t)0x55, 1296 (uchar_t)0x12, (uchar_t)0xcd }; 1297 char bytes[] = { (char)0x00, (char)0xef, (char)0xff }; 1298 1299 if (ddi_prop_update_int(DDI_DEV_T_NONE, devi, "int", int_val) 1300 != DDI_PROP_SUCCESS) 1301 return (DDI_FAILURE); 1302 1303 if (ddi_prop_update_int_array(DDI_DEV_T_NONE, devi, "int-array", 1304 int_array, sizeof (int_array) / sizeof (int)) != DDI_PROP_SUCCESS) 1305 return (DDI_FAILURE); 1306 1307 if (ddi_prop_update_int64(DDI_DEV_T_NONE, devi, "int64", int64_val) 1308 != DDI_PROP_SUCCESS) 1309 return (DDI_FAILURE); 1310 1311 if (ddi_prop_update_int64_array(DDI_DEV_T_NONE, devi, "int64-array", 1312 int64_array, sizeof (int64_array) / sizeof (int64_t)) 1313 != DDI_PROP_SUCCESS) 1314 return (DDI_FAILURE); 1315 1316 if (ddi_prop_update_string(DDI_DEV_T_NONE, devi, "string", string_val) 1317 != DDI_PROP_SUCCESS) 1318 return (DDI_FAILURE); 1319 1320 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi, "string-array", 1321 string_array, sizeof (string_array) / sizeof (char *)) 1322 != DDI_PROP_SUCCESS) 1323 return (DDI_FAILURE); 1324 1325 if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 1326 "boolean", NULL, 0) != DDI_PROP_SUCCESS) 1327 return (DDI_FAILURE); 1328 1329 if (ddi_prop_update_byte_array(DDI_DEV_T_NONE, devi, "byte-array", 1330 byte_array, sizeof (byte_array)) != DDI_PROP_SUCCESS) 1331 return (DDI_FAILURE); 1332 1333 /* untyped property */ 1334 if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, "untyped", 1335 (caddr_t)bytes, sizeof (bytes)) != DDI_PROP_SUCCESS) 1336 return (DDI_FAILURE); 1337 1338 return (DDI_SUCCESS); 1339 } 1340 1341 static struct driver_minor_data { 1342 char *name; 1343 minor_t minor; 1344 int type; 1345 } disk_minor_data[] = { 1346 {"a", 0, S_IFBLK}, 1347 {"b", 1, S_IFBLK}, 1348 {"c", 2, S_IFBLK}, 1349 {"d", 3, S_IFBLK}, 1350 {"e", 4, S_IFBLK}, 1351 {"f", 5, S_IFBLK}, 1352 {"g", 6, S_IFBLK}, 1353 {"h", 7, S_IFBLK}, 1354 {"a,raw", 0, S_IFCHR}, 1355 {"b,raw", 1, S_IFCHR}, 1356 {"c,raw", 2, S_IFCHR}, 1357 {"d,raw", 3, S_IFCHR}, 1358 {"e,raw", 4, S_IFCHR}, 1359 {"f,raw", 5, S_IFCHR}, 1360 {"g,raw", 6, S_IFCHR}, 1361 {"h,raw", 7, S_IFCHR}, 1362 {0} 1363 }; 1364 1365 1366 static struct driver_serial_minor_data { 1367 char *name; 1368 minor_t minor; 1369 int type; 1370 char *node_type; 1371 } serial_minor_data[] = { 1372 {"0", 0, S_IFCHR, "ddi_serial"}, 1373 {"1", 1, S_IFCHR, "ddi_serial"}, 1374 {"0,cu", 2, S_IFCHR, "ddi_serial:dialout"}, 1375 {"1,cu", 3, S_IFCHR, "ddi_serial:dialout"}, 1376 {0} 1377 }; 1378 1379 1380 static int 1381 gen_create_display(dev_info_t *devi) 1382 { 1383 1384 int instance = ddi_get_instance(devi); 1385 char minor_name[15]; 1386 1387 (void) sprintf(minor_name, "cgtwenty%d", instance); 1388 1389 return (ddi_create_minor_node(devi, minor_name, S_IFCHR, 1390 INST_TO_MINOR(instance), DDI_NT_DISPLAY, NULL)); 1391 } 1392 1393 static int 1394 gen_create_mn_disk_chan(dev_info_t *devi) 1395 { 1396 struct driver_minor_data *dmdp; 1397 int instance = ddi_get_instance(devi); 1398 1399 if (gen_create_properties(devi) != DDI_SUCCESS) 1400 return (DDI_FAILURE); 1401 1402 for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) { 1403 if (ddi_create_minor_node(devi, dmdp->name, dmdp->type, 1404 (INST_TO_MINOR(instance)) | dmdp->minor, 1405 DDI_NT_BLOCK_CHAN, NULL) != DDI_SUCCESS) { 1406 1407 return (DDI_FAILURE); 1408 } 1409 } 1410 return (DDI_SUCCESS); 1411 } 1412 1413 static uint_t 1414 atod(char *s) 1415 { 1416 uint_t val = 0; 1417 uint_t digit; 1418 1419 while (*s) { 1420 if (*s >= '0' && *s <= '9') 1421 digit = *s++ - '0'; 1422 else 1423 break; 1424 val = (val * 10) + digit; 1425 } 1426 return (val); 1427 } 1428 1429 1430 static int 1431 gen_create_mn_disk_wwn(dev_info_t *devi) 1432 { 1433 struct driver_minor_data *dmdp; 1434 int instance = ddi_get_instance(devi); 1435 char *address = ddi_get_name_addr(devi); 1436 int target, lun; 1437 1438 if (address[0] >= '0' && address[0] <= '9' && 1439 strchr(address, ',')) { 1440 target = atod(address); 1441 address = strchr(address, ','); 1442 lun = atod(++address); 1443 } else { /* this hack is for rm_stale_link() testing */ 1444 target = 10; 1445 lun = 5; 1446 } 1447 1448 if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 1449 "target", (caddr_t)&target, sizeof (int)) 1450 != DDI_PROP_SUCCESS) { 1451 return (DDI_FAILURE); 1452 } 1453 if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 1454 "lun", (caddr_t)&lun, sizeof (int)) 1455 != DDI_PROP_SUCCESS) { 1456 return (DDI_FAILURE); 1457 } 1458 1459 for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) { 1460 if (ddi_create_minor_node(devi, dmdp->name, dmdp->type, 1461 (INST_TO_MINOR(instance)) | dmdp->minor, 1462 DDI_NT_BLOCK_WWN, NULL) != DDI_SUCCESS) { 1463 1464 return (DDI_FAILURE); 1465 } 1466 } 1467 return (DDI_SUCCESS); 1468 } 1469 1470 static int 1471 gen_create_mn_disk_cdrom(dev_info_t *devi) 1472 { 1473 struct driver_minor_data *dmdp; 1474 int instance = ddi_get_instance(devi); 1475 1476 for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) { 1477 if (ddi_create_minor_node(devi, dmdp->name, dmdp->type, 1478 (INST_TO_MINOR(instance)) | dmdp->minor, 1479 DDI_NT_CD_CHAN, NULL) != DDI_SUCCESS) { 1480 1481 return (DDI_FAILURE); 1482 } 1483 } 1484 return (DDI_SUCCESS); 1485 } 1486 1487 static int 1488 gen_create_mn_disk_fd(dev_info_t *devi) 1489 { 1490 struct driver_minor_data *dmdp; 1491 int instance = ddi_get_instance(devi); 1492 1493 for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) { 1494 if (ddi_create_minor_node(devi, dmdp->name, dmdp->type, 1495 (INST_TO_MINOR(instance)) | dmdp->minor, 1496 DDI_NT_BLOCK_CHAN, NULL) != DDI_SUCCESS) { 1497 1498 return (DDI_FAILURE); 1499 } 1500 } 1501 return (DDI_SUCCESS); 1502 } 1503 1504 static int 1505 gen_create_serial(dev_info_t *devi) 1506 { 1507 struct driver_serial_minor_data *dmdp; 1508 int instance = ddi_get_instance(devi); 1509 1510 for (dmdp = serial_minor_data; dmdp->name != NULL; dmdp++) { 1511 if (ddi_create_minor_node(devi, dmdp->name, dmdp->type, 1512 (INST_TO_MINOR(instance)) | dmdp->minor, 1513 dmdp->node_type, NULL) != DDI_SUCCESS) { 1514 1515 return (DDI_FAILURE); 1516 } 1517 } 1518 return (DDI_SUCCESS); 1519 } 1520 1521 static int 1522 gen_create_net(dev_info_t *devi) 1523 { 1524 int instance = ddi_get_instance(devi); 1525 char minorname[32]; 1526 1527 if (gen_create_properties(devi) != DDI_SUCCESS) 1528 return (DDI_FAILURE); 1529 1530 (void) snprintf(minorname, sizeof (minorname), "gen_drv%d", instance); 1531 return (ddi_create_minor_node(devi, minorname, S_IFCHR, 1532 INST_TO_MINOR(instance), DDI_NT_NET, 0)); 1533 } 1534 1535 static int 1536 gen_create_minor_nodes(dev_info_t *devi, struct dstate *dstatep) 1537 { 1538 int rval = DDI_SUCCESS; 1539 char *node_name; 1540 1541 node_name = ddi_node_name(devi); 1542 1543 if (strcmp(node_name, "disk_chan") == 0) { 1544 rval = gen_create_mn_disk_chan(devi); 1545 } else if (strcmp(node_name, "disk_wwn") == 0) { 1546 rval = gen_create_mn_disk_wwn(devi); 1547 } else if (strcmp(node_name, "disk_cdrom") == 0) { 1548 rval = gen_create_mn_disk_cdrom(devi); 1549 } else if (strcmp(node_name, "disk_fd") == 0) { 1550 rval = gen_create_mn_disk_fd(devi); 1551 } else if (strcmp(node_name, "cgtwenty") == 0) { 1552 rval = gen_create_display(devi); 1553 } else if (strcmp(node_name, "genzs") == 0) { 1554 rval = gen_create_serial(devi); 1555 } else if (strcmp(node_name, "net") == 0) { 1556 rval = gen_create_net(devi); 1557 } else { 1558 int instance = ddi_get_instance(devi); 1559 char *node_type; 1560 1561 /* 1562 * Solaris may directly hang the node_type off the minor node 1563 * (without making a copy). Since we free the node_type 1564 * property below we need to make a private copy to pass 1565 * to ddi_create_minor_node to avoid devinfo snapshot panics. 1566 * We store a pointer to our copy in dstate and free it in 1567 * gen_detach after the minor nodes have been deleted by 1568 * ddi_remove_minor_node. 1569 */ 1570 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 1571 DDI_PROP_DONTPASS, "node-type", &node_type) != 0) { 1572 cmn_err(CE_WARN, "couldn't get node-type\n"); 1573 return (DDI_FAILURE); 1574 } 1575 if (node_type) { 1576 dstatep->node_type = kmem_alloc( 1577 strlen(node_type) + 1, KM_SLEEP); 1578 (void) strcpy(dstatep->node_type, node_type); 1579 } 1580 ddi_prop_free(node_type); 1581 1582 /* the minor name is the same as the node name */ 1583 if (ddi_create_minor_node(devi, node_name, S_IFCHR, 1584 (INST_TO_MINOR(instance)), dstatep->node_type, NULL) != 1585 DDI_SUCCESS) { 1586 if (dstatep->node_type) { 1587 kmem_free(dstatep->node_type, 1588 strlen(dstatep->node_type) + 1); 1589 dstatep->node_type = NULL; 1590 } 1591 return (DDI_FAILURE); 1592 } 1593 return (DDI_SUCCESS); 1594 } 1595 1596 if (rval != DDI_SUCCESS) { 1597 ddi_prop_remove_all(devi); 1598 ddi_remove_minor_node(devi, NULL); 1599 } 1600 1601 return (rval); 1602 } 1603 1604 /*ARGSUSED*/ 1605 static void 1606 gen_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie, void *arg, 1607 void *impl_data) 1608 { 1609 if (gen_debug) 1610 cmn_err(CE_NOTE, "gen_event_cb invoked"); 1611 1612 } 1613