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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright 2010 Nexenta Systems, Inc. All rights reserved. 27 */ 28 29 /* 30 * sunpm.c builds sunpm.o "power management framework" 31 * kernel-resident power management code. Implements power management 32 * policy 33 * Assumes: all backwards compat. device components wake up on & 34 * the pm_info pointer in dev_info is initially NULL 35 * 36 * PM - (device) Power Management 37 * 38 * Each device may have 0 or more components. If a device has no components, 39 * then it can't be power managed. Each component has 2 or more 40 * power states. 41 * 42 * "Backwards Compatible" (bc) devices: 43 * There are two different types of devices from the point of view of this 44 * code. The original type, left over from the original PM implementation on 45 * the voyager platform are known in this code as "backwards compatible" 46 * devices (PM_ISBC(dip) returns true). 47 * They are recognized by the pm code by the lack of a pm-components property 48 * and a call made by the driver to pm_create_components(9F). 49 * For these devices, component 0 is special, and represents the power state 50 * of the device. If component 0 is to be set to power level 0 (off), then 51 * the framework must first call into the driver's detach(9E) routine with 52 * DDI_PM_SUSPEND, to get the driver to save the hardware state of the device. 53 * After setting component 0 from 0 to a non-zero power level, a call must be 54 * made into the driver's attach(9E) routine with DDI_PM_RESUME. 55 * 56 * Currently, the only way to get a bc device power managed is via a set of 57 * ioctls (PM_DIRECT_PM, PM_SET_CURRENT_POWER) issued to /dev/pm. 58 * 59 * For non-bc devices, the driver describes the components by exporting a 60 * pm-components(9P) property that tells how many components there are, 61 * tells what each component's power state values are, and provides human 62 * readable strings (currently unused) for each component name and power state. 63 * Devices which export pm-components(9P) are automatically power managed 64 * whenever autopm is enabled (via PM_START_PM ioctl issued by pmconfig(1M) 65 * after parsing power.conf(4)). The exception to this rule is that power 66 * manageable CPU devices may be automatically managed independently of autopm 67 * by either enabling or disabling (via PM_START_CPUPM and PM_STOP_CPUPM 68 * ioctls) cpupm. If the CPU devices are not managed independently, then they 69 * are managed by autopm. In either case, for automatically power managed 70 * devices, all components are considered independent of each other, and it is 71 * up to the driver to decide when a transition requires saving or restoring 72 * hardware state. 73 * 74 * Each device component also has a threshold time associated with each power 75 * transition (see power.conf(4)), and a busy/idle state maintained by the 76 * driver calling pm_idle_component(9F) and pm_busy_component(9F). 77 * Components are created idle. 78 * 79 * The PM framework provides several functions: 80 * -implement PM policy as described in power.conf(4) 81 * Policy is set by pmconfig(1M) issuing pm ioctls based on power.conf(4). 82 * Policies consist of: 83 * -set threshold values (defaults if none provided by pmconfig) 84 * -set dependencies among devices 85 * -enable/disable autopm 86 * -enable/disable cpupm 87 * -turn down idle components based on thresholds (if autopm or cpupm is 88 * enabled) (aka scanning) 89 * -maintain power states based on dependencies among devices 90 * -upon request, or when the frame buffer powers off, attempt to turn off 91 * all components that are idle or become idle over the next (10 sec) 92 * period in an attempt to get down to an EnergyStar compliant state 93 * -prevent powering off of a device which exported the 94 * pm-no-involuntary-power-cycles property without active involvement of 95 * the device's driver (so no removing power when the device driver is 96 * not attached) 97 * -provide a mechanism for a device driver to request that a device's component 98 * be brought back to the power level necessary for the use of the device 99 * -allow a process to directly control the power levels of device components 100 * (via ioctls issued to /dev/pm--see usr/src/uts/common/io/pm.c) 101 * -ensure that the console frame buffer is powered up before being referenced 102 * via prom_printf() or other prom calls that might generate console output 103 * -maintain implicit dependencies (e.g. parent must be powered up if child is) 104 * -provide "backwards compatible" behavior for devices without pm-components 105 * property 106 * 107 * Scanning: 108 * Whenever autopm or cpupm is enabled, the framework attempts to bring each 109 * component of each managed device to its lowest power based on the threshold 110 * of idleness associated with each transition and the busy/idle state of the 111 * component. 112 * 113 * The actual work of this is done by pm_scan_dev(), which cycles through each 114 * component of a device, checking its idleness against its current threshold, 115 * and calling pm_set_power() as appropriate to change the power level. 116 * This function also indicates when it would next be profitable to scan the 117 * device again, and a new scan is scheduled after that time. 118 * 119 * Dependencies: 120 * It is possible to establish a dependency between the power states of two 121 * otherwise unrelated devices. This is currently done to ensure that the 122 * cdrom is always up whenever the console framebuffer is up, so that the user 123 * can insert a cdrom and see a popup as a result. 124 * 125 * The dependency terminology used in power.conf(4) is not easy to understand, 126 * so we've adopted a different terminology in the implementation. We write 127 * of a "keeps up" and a "kept up" device. A relationship can be established 128 * where one device keeps up another. That means that if the keepsup device 129 * has any component that is at a non-zero power level, all components of the 130 * "kept up" device must be brought to full power. This relationship is 131 * asynchronous. When the keeping device is powered up, a request is queued 132 * to a worker thread to bring up the kept device. The caller does not wait. 133 * Scan will not turn down a kept up device. 134 * 135 * Direct PM: 136 * A device may be directly power managed by a process. If a device is 137 * directly pm'd, then it will not be scanned, and dependencies will not be 138 * enforced. * If a directly pm'd device's driver requests a power change (via 139 * pm_raise_power(9F)), then the request is blocked and notification is sent 140 * to the controlling process, which must issue the requested power change for 141 * the driver to proceed. 142 * 143 */ 144 145 #include <sys/types.h> 146 #include <sys/errno.h> 147 #include <sys/callb.h> /* callback registration during CPR */ 148 #include <sys/conf.h> /* driver flags and functions */ 149 #include <sys/open.h> /* OTYP_CHR definition */ 150 #include <sys/stat.h> /* S_IFCHR definition */ 151 #include <sys/pathname.h> /* name -> dev_info xlation */ 152 #include <sys/ddi_impldefs.h> /* dev_info node fields */ 153 #include <sys/kmem.h> /* memory alloc stuff */ 154 #include <sys/debug.h> 155 #include <sys/archsystm.h> 156 #include <sys/pm.h> 157 #include <sys/ddi.h> 158 #include <sys/sunddi.h> 159 #include <sys/sunndi.h> 160 #include <sys/sunpm.h> 161 #include <sys/epm.h> 162 #include <sys/vfs.h> 163 #include <sys/mode.h> 164 #include <sys/mkdev.h> 165 #include <sys/promif.h> 166 #include <sys/consdev.h> 167 #include <sys/esunddi.h> 168 #include <sys/modctl.h> 169 #include <sys/fs/ufs_fs.h> 170 #include <sys/note.h> 171 #include <sys/taskq.h> 172 #include <sys/bootconf.h> 173 #include <sys/reboot.h> 174 #include <sys/spl.h> 175 #include <sys/disp.h> 176 #include <sys/sobject.h> 177 #include <sys/sunmdi.h> 178 #include <sys/systm.h> 179 #include <sys/cpuvar.h> 180 #include <sys/cyclic.h> 181 #include <sys/uadmin.h> 182 #include <sys/srn.h> 183 184 185 /* 186 * PM LOCKING 187 * The list of locks: 188 * Global pm mutex locks. 189 * 190 * pm_scan_lock: 191 * It protects the timeout id of the scan thread, and the value 192 * of autopm_enabled and cpupm. This lock is not held 193 * concurrently with any other PM locks. 194 * 195 * pm_clone_lock: Protects the clone list and count of poll events 196 * pending for the pm driver. 197 * Lock ordering: 198 * pm_clone_lock -> pm_pscc_interest_rwlock, 199 * pm_clone_lock -> pm_pscc_direct_rwlock. 200 * 201 * pm_rsvp_lock: 202 * Used to synchronize the data structures used for processes 203 * to rendezvous with state change information when doing 204 * direct PM. 205 * Lock ordering: 206 * pm_rsvp_lock -> pm_pscc_interest_rwlock, 207 * pm_rsvp_lock -> pm_pscc_direct_rwlock, 208 * pm_rsvp_lock -> pm_clone_lock. 209 * 210 * ppm_lock: protects the list of registered ppm drivers 211 * Lock ordering: 212 * ppm_lock -> ppm driver unit_lock 213 * 214 * pm_compcnt_lock: 215 * Protects count of components that are not at their lowest 216 * power level. 217 * Lock ordering: 218 * pm_compcnt_lock -> ppm_lock. 219 * 220 * pm_dep_thread_lock: 221 * Protects work list for pm_dep_thread. Not taken concurrently 222 * with any other pm lock. 223 * 224 * pm_remdrv_lock: 225 * Serializes the operation of removing noinvol data structure 226 * entries for a branch of the tree when a driver has been 227 * removed from the system (modctl_rem_major). 228 * Lock ordering: 229 * pm_remdrv_lock -> pm_noinvol_rwlock. 230 * 231 * pm_cfb_lock: (High level spin lock) 232 * Protects the count of how many components of the console 233 * frame buffer are off (so we know if we have to bring up the 234 * console as a result of a prom_printf, etc. 235 * No other locks are taken while holding this lock. 236 * 237 * pm_loan_lock: 238 * Protects the lock_loan list. List is used to record that one 239 * thread has acquired a power lock but has launched another thread 240 * to complete its processing. An entry in the list indicates that 241 * the worker thread can borrow the lock held by the other thread, 242 * which must block on the completion of the worker. Use is 243 * specific to module loading. 244 * No other locks are taken while holding this lock. 245 * 246 * Global PM rwlocks 247 * 248 * pm_thresh_rwlock: 249 * Protects the list of thresholds recorded for future use (when 250 * devices attach). 251 * Lock ordering: 252 * pm_thresh_rwlock -> devi_pm_lock 253 * 254 * pm_noinvol_rwlock: 255 * Protects list of detached nodes that had noinvol registered. 256 * No other PM locks are taken while holding pm_noinvol_rwlock. 257 * 258 * pm_pscc_direct_rwlock: 259 * Protects the list that maps devices being directly power 260 * managed to the processes that manage them. 261 * Lock ordering: 262 * pm_pscc_direct_rwlock -> psce_lock 263 * 264 * pm_pscc_interest_rwlock; 265 * Protects the list that maps state change events to processes 266 * that want to know about them. 267 * Lock ordering: 268 * pm_pscc_interest_rwlock -> psce_lock 269 * 270 * per-dip locks: 271 * 272 * Each node has these per-dip locks, which are only used if the device is 273 * a candidate for power management (e.g. has pm components) 274 * 275 * devi_pm_lock: 276 * Protects all power management state of the node except for 277 * power level, which is protected by ndi_devi_enter(). 278 * Encapsulated in macros PM_LOCK_DIP()/PM_UNLOCK_DIP(). 279 * Lock ordering: 280 * devi_pm_lock -> pm_rsvp_lock, 281 * devi_pm_lock -> pm_dep_thread_lock, 282 * devi_pm_lock -> pm_noinvol_rwlock, 283 * devi_pm_lock -> power lock 284 * 285 * power lock (ndi_devi_enter()): 286 * Since changing power level is possibly a slow operation (30 287 * seconds to spin up a disk drive), this is locked separately. 288 * Since a call into the driver to change the power level of one 289 * component may result in a call back into the framework to change 290 * the power level of another, this lock allows re-entrancy by 291 * the same thread (ndi_devi_enter is used for this because 292 * the USB framework uses ndi_devi_enter in its power entry point, 293 * and use of any other lock would produce a deadlock. 294 * 295 * devi_pm_busy_lock: 296 * This lock protects the integrity of the busy count. It is 297 * only taken by pm_busy_component() and pm_idle_component and 298 * some code that adjust the busy time after the timer gets set 299 * up or after a CPR operation. It is per-dip to keep from 300 * single-threading all the disk drivers on a system. 301 * It could be per component instead, but most devices have 302 * only one component. 303 * No other PM locks are taken while holding this lock. 304 * 305 */ 306 307 static int stdout_is_framebuffer; 308 static kmutex_t e_pm_power_lock; 309 static kmutex_t pm_loan_lock; 310 kmutex_t pm_scan_lock; 311 callb_id_t pm_cpr_cb_id; 312 callb_id_t pm_panic_cb_id; 313 callb_id_t pm_halt_cb_id; 314 int pm_comps_notlowest; /* no. of comps not at lowest power */ 315 int pm_powering_down; /* cpr is source of DDI_SUSPEND calls */ 316 317 clock_t pm_id_ticks = 5; /* ticks to wait before scan during idle-down */ 318 clock_t pm_default_min_scan = PM_DEFAULT_MIN_SCAN; 319 clock_t pm_cpu_min_scan = PM_CPU_MIN_SCAN; 320 321 #define PM_MIN_SCAN(dip) (PM_ISCPU(dip) ? pm_cpu_min_scan : \ 322 pm_default_min_scan) 323 324 static int pm_busop_set_power(dev_info_t *, 325 void *, pm_bus_power_op_t, void *, void *); 326 static int pm_busop_match_request(dev_info_t *, void *); 327 static int pm_all_to_normal_nexus(dev_info_t *, pm_canblock_t); 328 static void e_pm_set_max_power(dev_info_t *, int, int); 329 static int e_pm_get_max_power(dev_info_t *, int); 330 331 /* 332 * Dependency Processing is done thru a seperate thread. 333 */ 334 kmutex_t pm_dep_thread_lock; 335 kcondvar_t pm_dep_thread_cv; 336 pm_dep_wk_t *pm_dep_thread_workq = NULL; 337 pm_dep_wk_t *pm_dep_thread_tail = NULL; 338 339 /* 340 * Autopm must be turned on by a PM_START_PM ioctl, so we don't end up 341 * power managing things in single user mode that have been suppressed via 342 * power.conf entries. Protected by pm_scan_lock. 343 */ 344 int autopm_enabled; 345 346 /* 347 * cpupm is turned on and off, by the PM_START_CPUPM and PM_STOP_CPUPM ioctls, 348 * to define the power management behavior of CPU devices separate from 349 * autopm. Protected by pm_scan_lock. 350 */ 351 pm_cpupm_t cpupm = PM_CPUPM_NOTSET; 352 353 /* 354 * Defines the default mode of operation for CPU power management, 355 * either the polling implementation, or the event based dispatcher driven 356 * implementation. 357 */ 358 pm_cpupm_t cpupm_default_mode = PM_CPUPM_EVENT; 359 360 /* 361 * AutoS3 depends on autopm being enabled, and must be enabled by 362 * PM_START_AUTOS3 command. 363 */ 364 int autoS3_enabled; 365 366 #if !defined(__sparc) 367 /* 368 * on sparc these live in fillsysinfo.c 369 * 370 * If this variable is non-zero, cpr should return "not supported" when 371 * it is queried even though it would normally be supported on this platform. 372 */ 373 int cpr_supported_override; 374 375 /* 376 * Some platforms may need to support CPR even in the absence of 377 * having the correct platform id information. If this 378 * variable is non-zero, cpr should proceed even in the absence 379 * of otherwise being qualified. 380 */ 381 int cpr_platform_enable = 0; 382 383 #endif 384 385 /* 386 * pm_S3_enabled indicates that we believe the platform can support S3, 387 * which we get from pmconfig(1M) 388 */ 389 int pm_S3_enabled; 390 391 /* 392 * This flag is true while processes are stopped for a checkpoint/resume. 393 * Controlling processes of direct pm'd devices are not available to 394 * participate in power level changes, so we bypass them when this is set. 395 */ 396 static int pm_processes_stopped; 397 398 #ifdef DEBUG 399 400 /* 401 * see common/sys/epm.h for PMD_* values 402 */ 403 404 uint_t pm_debug = 0; 405 406 /* 407 * If pm_divertdebug is set, then no prom_printf calls will be made by 408 * PMD(), which will prevent debug output from bringing up the console 409 * frame buffer. Clearing this variable before setting pm_debug will result 410 * in PMD output going to the console. 411 * 412 * pm_divertdebug is incremented in pm_set_power() if dip == cfb_dip to avoid 413 * deadlocks and decremented at the end of pm_set_power() 414 */ 415 uint_t pm_divertdebug = 1; 416 volatile uint_t pm_debug_to_console = 0; 417 kmutex_t pm_debug_lock; /* protects pm_divertdebug */ 418 419 void prdeps(char *); 420 #endif 421 422 /* Globals */ 423 424 /* 425 * List of recorded thresholds and dependencies 426 */ 427 pm_thresh_rec_t *pm_thresh_head; 428 krwlock_t pm_thresh_rwlock; 429 430 pm_pdr_t *pm_dep_head; 431 static int pm_unresolved_deps = 0; 432 static int pm_prop_deps = 0; 433 434 /* 435 * List of devices that exported no-involuntary-power-cycles property 436 */ 437 pm_noinvol_t *pm_noinvol_head; 438 439 /* 440 * Locks used in noinvol processing 441 */ 442 krwlock_t pm_noinvol_rwlock; 443 kmutex_t pm_remdrv_lock; 444 445 int pm_default_idle_threshold = PM_DEFAULT_SYS_IDLENESS; 446 int pm_system_idle_threshold; 447 int pm_cpu_idle_threshold; 448 449 /* 450 * By default nexus has 0 threshold, and depends on its children to keep it up 451 */ 452 int pm_default_nexus_threshold = 0; 453 454 /* 455 * Data structures shared with common/io/pm.c 456 */ 457 kmutex_t pm_clone_lock; 458 kcondvar_t pm_clones_cv[PM_MAX_CLONE]; 459 uint_t pm_poll_cnt[PM_MAX_CLONE]; /* count of events for poll */ 460 unsigned char pm_interest[PM_MAX_CLONE]; 461 struct pollhead pm_pollhead; 462 463 /* 464 * Data structures shared with common/io/srn.c 465 */ 466 kmutex_t srn_clone_lock; /* protects srn_signal, srn_inuse */ 467 void (*srn_signal)(int type, int event); 468 int srn_inuse; /* stop srn detach */ 469 470 extern int hz; 471 extern char *platform_module_list[]; 472 473 /* 474 * Wrappers for use in ddi_walk_devs 475 */ 476 477 static int pm_set_dev_thr_walk(dev_info_t *, void *); 478 static int pm_restore_direct_lvl_walk(dev_info_t *, void *); 479 static int pm_save_direct_lvl_walk(dev_info_t *, void *); 480 static int pm_discard_dep_walk(dev_info_t *, void *); 481 #ifdef DEBUG 482 static int pm_desc_pwrchk_walk(dev_info_t *, void *); 483 #endif 484 485 /* 486 * Routines for managing noinvol devices 487 */ 488 int pm_noinvol_update(int, int, int, char *, dev_info_t *); 489 void pm_noinvol_update_node(dev_info_t *, 490 pm_bp_noinvol_t *req); 491 492 kmutex_t pm_rsvp_lock; 493 kmutex_t pm_compcnt_lock; 494 krwlock_t pm_pscc_direct_rwlock; 495 krwlock_t pm_pscc_interest_rwlock; 496 497 #define PSC_INTEREST 0 /* belongs to interest psc list */ 498 #define PSC_DIRECT 1 /* belongs to direct psc list */ 499 500 pscc_t *pm_pscc_interest; 501 pscc_t *pm_pscc_direct; 502 503 #define PM_MAJOR(dip) ddi_driver_major(dip) 504 #define PM_IS_NEXUS(dip) ((PM_MAJOR(dip) == DDI_MAJOR_T_NONE) ? 0 : \ 505 NEXUS_DRV(devopsp[PM_MAJOR(dip)])) 506 #define POWERING_ON(old, new) ((old) == 0 && (new) != 0) 507 #define POWERING_OFF(old, new) ((old) != 0 && (new) == 0) 508 509 #define PM_INCR_NOTLOWEST(dip) { \ 510 mutex_enter(&pm_compcnt_lock); \ 511 if (!PM_IS_NEXUS(dip) || \ 512 (DEVI(dip)->devi_pm_flags & (PMC_DEV_THRESH|PMC_COMP_THRESH))) {\ 513 if (pm_comps_notlowest == 0) \ 514 pm_ppm_notify_all_lowest(dip, PM_NOT_ALL_LOWEST);\ 515 pm_comps_notlowest++; \ 516 PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d) incr notlowest->%d\n",\ 517 pmf, PM_DEVICE(dip), pm_comps_notlowest)) \ 518 } \ 519 mutex_exit(&pm_compcnt_lock); \ 520 } 521 #define PM_DECR_NOTLOWEST(dip) { \ 522 mutex_enter(&pm_compcnt_lock); \ 523 if (!PM_IS_NEXUS(dip) || \ 524 (DEVI(dip)->devi_pm_flags & (PMC_DEV_THRESH|PMC_COMP_THRESH))) {\ 525 ASSERT(pm_comps_notlowest); \ 526 pm_comps_notlowest--; \ 527 PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d) decr notlowest to " \ 528 "%d\n", pmf, PM_DEVICE(dip), pm_comps_notlowest))\ 529 if (pm_comps_notlowest == 0) \ 530 pm_ppm_notify_all_lowest(dip, PM_ALL_LOWEST); \ 531 } \ 532 mutex_exit(&pm_compcnt_lock); \ 533 } 534 535 /* 536 * console frame-buffer power-management is not enabled when 537 * debugging services are present. to override, set pm_cfb_override 538 * to non-zero. 539 */ 540 uint_t pm_cfb_comps_off = 0; /* PM_LEVEL_UNKNOWN is considered on */ 541 kmutex_t pm_cfb_lock; 542 int pm_cfb_enabled = 1; /* non-zero allows pm of console frame buffer */ 543 #ifdef DEBUG 544 int pm_cfb_override = 1; /* non-zero allows pm of cfb with debuggers */ 545 #else 546 int pm_cfb_override = 0; /* non-zero allows pm of cfb with debuggers */ 547 #endif 548 549 static dev_info_t *cfb_dip = 0; 550 static dev_info_t *cfb_dip_detaching = 0; 551 uint_t cfb_inuse = 0; 552 static ddi_softintr_t pm_soft_id; 553 static boolean_t pm_soft_pending; 554 int pm_scans_disabled = 0; 555 556 /* 557 * A structure to record the fact that one thread has borrowed a lock held 558 * by another thread. The context requires that the lender block on the 559 * completion of the borrower. 560 */ 561 typedef struct lock_loan { 562 struct lock_loan *pmlk_next; 563 kthread_t *pmlk_borrower; 564 kthread_t *pmlk_lender; 565 dev_info_t *pmlk_dip; 566 } lock_loan_t; 567 static lock_loan_t lock_loan_head; /* list head is a dummy element */ 568 569 #ifdef DEBUG 570 #ifdef PMDDEBUG 571 #define PMD_FUNC(func, name) char *(func) = (name); 572 #else /* !PMDDEBUG */ 573 #define PMD_FUNC(func, name) 574 #endif /* PMDDEBUG */ 575 #else /* !DEBUG */ 576 #define PMD_FUNC(func, name) 577 #endif /* DEBUG */ 578 579 580 /* 581 * Must be called before first device (including pseudo) attach 582 */ 583 void 584 pm_init_locks(void) 585 { 586 mutex_init(&pm_scan_lock, NULL, MUTEX_DRIVER, NULL); 587 mutex_init(&pm_rsvp_lock, NULL, MUTEX_DRIVER, NULL); 588 mutex_init(&pm_compcnt_lock, NULL, MUTEX_DRIVER, NULL); 589 mutex_init(&pm_dep_thread_lock, NULL, MUTEX_DRIVER, NULL); 590 mutex_init(&pm_remdrv_lock, NULL, MUTEX_DRIVER, NULL); 591 mutex_init(&pm_loan_lock, NULL, MUTEX_DRIVER, NULL); 592 rw_init(&pm_thresh_rwlock, NULL, RW_DEFAULT, NULL); 593 rw_init(&pm_noinvol_rwlock, NULL, RW_DEFAULT, NULL); 594 cv_init(&pm_dep_thread_cv, NULL, CV_DEFAULT, NULL); 595 } 596 597 static int pm_reset_timestamps(dev_info_t *, void *); 598 599 static boolean_t 600 pm_cpr_callb(void *arg, int code) 601 { 602 _NOTE(ARGUNUSED(arg)) 603 static int auto_save; 604 static pm_cpupm_t cpupm_save; 605 606 switch (code) { 607 case CB_CODE_CPR_CHKPT: 608 /* 609 * Cancel scan or wait for scan in progress to finish 610 * Other threads may be trying to restart the scan, so we 611 * have to keep at it unil it sticks 612 */ 613 mutex_enter(&pm_scan_lock); 614 ASSERT(!pm_scans_disabled); 615 pm_scans_disabled = 1; 616 auto_save = autopm_enabled; 617 autopm_enabled = 0; 618 cpupm_save = cpupm; 619 cpupm = PM_CPUPM_NOTSET; 620 mutex_exit(&pm_scan_lock); 621 ddi_walk_devs(ddi_root_node(), pm_scan_stop_walk, NULL); 622 break; 623 624 case CB_CODE_CPR_RESUME: 625 ASSERT(!autopm_enabled); 626 ASSERT(cpupm == PM_CPUPM_NOTSET); 627 ASSERT(pm_scans_disabled); 628 pm_scans_disabled = 0; 629 /* 630 * Call pm_reset_timestamps to reset timestamps of each 631 * device to the time when the system is resumed so that their 632 * idleness can be re-calculated. That's to avoid devices from 633 * being powered down right after resume if the system was in 634 * suspended mode long enough. 635 */ 636 ddi_walk_devs(ddi_root_node(), pm_reset_timestamps, NULL); 637 638 autopm_enabled = auto_save; 639 cpupm = cpupm_save; 640 /* 641 * If there is any auto-pm device, get the scanning 642 * going. Otherwise don't bother. 643 */ 644 ddi_walk_devs(ddi_root_node(), pm_rescan_walk, NULL); 645 break; 646 } 647 return (B_TRUE); 648 } 649 650 /* 651 * This callback routine is called when there is a system panic. This function 652 * exists for prototype matching. 653 */ 654 static boolean_t 655 pm_panic_callb(void *arg, int code) 656 { 657 _NOTE(ARGUNUSED(arg, code)) 658 void pm_cfb_check_and_powerup(void); 659 PMD(PMD_CFB, ("pm_panic_callb\n")) 660 pm_cfb_check_and_powerup(); 661 return (B_TRUE); 662 } 663 664 static boolean_t 665 pm_halt_callb(void *arg, int code) 666 { 667 _NOTE(ARGUNUSED(arg, code)) 668 return (B_TRUE); 669 } 670 671 static void pm_dep_thread(void); 672 673 /* 674 * This needs to be called after the root and platform drivers are loaded 675 * and be single-threaded with respect to driver attach/detach 676 */ 677 void 678 pm_init(void) 679 { 680 PMD_FUNC(pmf, "pm_init") 681 char **mod; 682 extern pri_t minclsyspri; 683 684 pm_comps_notlowest = 0; 685 pm_system_idle_threshold = pm_default_idle_threshold; 686 pm_cpu_idle_threshold = 0; 687 688 pm_cpr_cb_id = callb_add(pm_cpr_callb, (void *)NULL, 689 CB_CL_CPR_PM, "pm_cpr"); 690 pm_panic_cb_id = callb_add(pm_panic_callb, (void *)NULL, 691 CB_CL_PANIC, "pm_panic"); 692 pm_halt_cb_id = callb_add(pm_halt_callb, (void *)NULL, 693 CB_CL_HALT, "pm_halt"); 694 695 /* 696 * Create a thread to do dependency processing. 697 */ 698 (void) thread_create(NULL, 0, (void (*)())pm_dep_thread, NULL, 0, &p0, 699 TS_RUN, minclsyspri); 700 701 /* 702 * loadrootmodules already loaded these ppm drivers, now get them 703 * attached so they can claim the root drivers as they attach 704 */ 705 for (mod = platform_module_list; *mod; mod++) { 706 if (i_ddi_attach_hw_nodes(*mod) != DDI_SUCCESS) { 707 cmn_err(CE_WARN, "!cannot load platform pm driver %s\n", 708 *mod); 709 } else { 710 PMD(PMD_DHR, ("%s: %s (%s)\n", pmf, *mod, 711 ddi_major_to_name(ddi_name_to_major(*mod)))) 712 } 713 } 714 } 715 716 /* 717 * pm_scan_init - create pm scan data structure. Called (if autopm or cpupm 718 * enabled) when device becomes power managed or after a failed detach and 719 * when autopm is started via PM_START_PM or PM_START_CPUPM ioctls, and after 720 * a CPR resume to get all the devices scanning again. 721 */ 722 void 723 pm_scan_init(dev_info_t *dip) 724 { 725 PMD_FUNC(pmf, "scan_init") 726 pm_scan_t *scanp; 727 728 ASSERT(!PM_ISBC(dip)); 729 730 PM_LOCK_DIP(dip); 731 scanp = PM_GET_PM_SCAN(dip); 732 if (!scanp) { 733 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): create scan data\n", 734 pmf, PM_DEVICE(dip))) 735 scanp = kmem_zalloc(sizeof (pm_scan_t), KM_SLEEP); 736 DEVI(dip)->devi_pm_scan = scanp; 737 } else if (scanp->ps_scan_flags & PM_SCAN_STOP) { 738 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): " 739 "clear PM_SCAN_STOP flag\n", pmf, PM_DEVICE(dip))) 740 scanp->ps_scan_flags &= ~PM_SCAN_STOP; 741 } 742 PM_UNLOCK_DIP(dip); 743 } 744 745 /* 746 * pm_scan_fini - remove pm scan data structure when stopping pm on the device 747 */ 748 void 749 pm_scan_fini(dev_info_t *dip) 750 { 751 PMD_FUNC(pmf, "scan_fini") 752 pm_scan_t *scanp; 753 754 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip))) 755 ASSERT(!PM_ISBC(dip)); 756 PM_LOCK_DIP(dip); 757 scanp = PM_GET_PM_SCAN(dip); 758 if (!scanp) { 759 PM_UNLOCK_DIP(dip); 760 return; 761 } 762 763 ASSERT(!scanp->ps_scan_id && !(scanp->ps_scan_flags & 764 (PM_SCANNING | PM_SCAN_DISPATCHED | PM_SCAN_AGAIN))); 765 766 kmem_free(scanp, sizeof (pm_scan_t)); 767 DEVI(dip)->devi_pm_scan = NULL; 768 PM_UNLOCK_DIP(dip); 769 } 770 771 /* 772 * Given a pointer to a component struct, return the current power level 773 * (struct contains index unless it is a continuous level). 774 * Located here in hopes of getting both this and dev_is_needed into the 775 * cache together 776 */ 777 static int 778 cur_power(pm_component_t *cp) 779 { 780 if (cp->pmc_cur_pwr == PM_LEVEL_UNKNOWN) 781 return (cp->pmc_cur_pwr); 782 783 return (cp->pmc_comp.pmc_lvals[cp->pmc_cur_pwr]); 784 } 785 786 static char * 787 pm_decode_direction(int direction) 788 { 789 switch (direction) { 790 case PM_LEVEL_UPONLY: 791 return ("up"); 792 793 case PM_LEVEL_EXACT: 794 return ("exact"); 795 796 case PM_LEVEL_DOWNONLY: 797 return ("down"); 798 799 default: 800 return ("INVALID DIRECTION"); 801 } 802 } 803 804 char * 805 pm_decode_op(pm_bus_power_op_t op) 806 { 807 switch (op) { 808 case BUS_POWER_CHILD_PWRCHG: 809 return ("CHILD_PWRCHG"); 810 case BUS_POWER_NEXUS_PWRUP: 811 return ("NEXUS_PWRUP"); 812 case BUS_POWER_PRE_NOTIFICATION: 813 return ("PRE_NOTIFICATION"); 814 case BUS_POWER_POST_NOTIFICATION: 815 return ("POST_NOTIFICATION"); 816 case BUS_POWER_HAS_CHANGED: 817 return ("HAS_CHANGED"); 818 case BUS_POWER_NOINVOL: 819 return ("NOINVOL"); 820 default: 821 return ("UNKNOWN OP"); 822 } 823 } 824 825 /* 826 * Returns true if level is a possible (valid) power level for component 827 */ 828 int 829 e_pm_valid_power(dev_info_t *dip, int cmpt, int level) 830 { 831 PMD_FUNC(pmf, "e_pm_valid_power") 832 pm_component_t *cp = PM_CP(dip, cmpt); 833 int i; 834 int *ip = cp->pmc_comp.pmc_lvals; 835 int limit = cp->pmc_comp.pmc_numlevels; 836 837 if (level < 0) 838 return (0); 839 for (i = 0; i < limit; i++) { 840 if (level == *ip++) 841 return (1); 842 } 843 #ifdef DEBUG 844 if (pm_debug & PMD_FAIL) { 845 ip = cp->pmc_comp.pmc_lvals; 846 847 for (i = 0; i < limit; i++) 848 PMD(PMD_FAIL, ("%s: index=%d, level=%d\n", 849 pmf, i, *ip++)) 850 } 851 #endif 852 return (0); 853 } 854 855 static int pm_start(dev_info_t *dip); 856 /* 857 * Returns true if device is pm'd (after calling pm_start if need be) 858 */ 859 int 860 e_pm_valid_info(dev_info_t *dip, pm_info_t **infop) 861 { 862 pm_info_t *info; 863 864 /* 865 * Check if the device is power managed if not. 866 * To make the common case (device is power managed already) 867 * fast, we check without the lock. If device is not already 868 * power managed, then we take the lock and the long route through 869 * go get it managed. Devices never go unmanaged until they 870 * detach. 871 */ 872 info = PM_GET_PM_INFO(dip); 873 if (!info) { 874 if (!DEVI_IS_ATTACHING(dip)) { 875 return (0); 876 } 877 if (pm_start(dip) != DDI_SUCCESS) { 878 return (0); 879 } 880 info = PM_GET_PM_INFO(dip); 881 } 882 ASSERT(info); 883 if (infop != NULL) 884 *infop = info; 885 return (1); 886 } 887 888 int 889 e_pm_valid_comp(dev_info_t *dip, int cmpt, pm_component_t **cpp) 890 { 891 if (cmpt >= 0 && cmpt < PM_NUMCMPTS(dip)) { 892 if (cpp != NULL) 893 *cpp = PM_CP(dip, cmpt); 894 return (1); 895 } else { 896 return (0); 897 } 898 } 899 900 /* 901 * Internal guts of ddi_dev_is_needed and pm_raise/lower_power 902 */ 903 static int 904 dev_is_needed(dev_info_t *dip, int cmpt, int level, int direction) 905 { 906 PMD_FUNC(pmf, "din") 907 pm_component_t *cp; 908 char *pathbuf; 909 int result; 910 911 ASSERT(direction == PM_LEVEL_UPONLY || direction == PM_LEVEL_DOWNONLY); 912 if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, cmpt, &cp) || 913 !e_pm_valid_power(dip, cmpt, level)) 914 return (DDI_FAILURE); 915 916 PMD(PMD_DIN, ("%s: %s@%s(%s#%d) cmpt=%d, dir=%s, new=%d, cur=%d\n", 917 pmf, PM_DEVICE(dip), cmpt, pm_decode_direction(direction), 918 level, cur_power(cp))) 919 920 if (pm_set_power(dip, cmpt, level, direction, 921 PM_CANBLOCK_BLOCK, 0, &result) != DDI_SUCCESS) { 922 if (direction == PM_LEVEL_UPONLY) { 923 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 924 (void) ddi_pathname(dip, pathbuf); 925 cmn_err(CE_WARN, "Device %s failed to power up.", 926 pathbuf); 927 kmem_free(pathbuf, MAXPATHLEN); 928 } 929 PMD(PMD_DIN | PMD_FAIL, ("%s: %s@%s(%s#%d) [%d] %s->%d failed, " 930 "errno %d\n", pmf, PM_DEVICE(dip), cmpt, 931 pm_decode_direction(direction), level, result)) 932 return (DDI_FAILURE); 933 } 934 935 PMD(PMD_RESCAN | PMD_DIN, ("%s: pm_rescan %s@%s(%s#%d)\n", pmf, 936 PM_DEVICE(dip))) 937 pm_rescan(dip); 938 return (DDI_SUCCESS); 939 } 940 941 /* 942 * We can get multiple pm_rescan() threads, if one of them discovers 943 * that no scan is running at the moment, it kicks it into action. 944 * Otherwise, it tells the current scanning thread to scan again when 945 * it is done by asserting the PM_SCAN_AGAIN flag. The PM_SCANNING and 946 * PM_SCAN_AGAIN flags are used to regulate scan, to make sure only one 947 * thread at a time runs the pm_scan_dev() code. 948 */ 949 void 950 pm_rescan(void *arg) 951 { 952 PMD_FUNC(pmf, "rescan") 953 dev_info_t *dip = (dev_info_t *)arg; 954 pm_info_t *info; 955 pm_scan_t *scanp; 956 timeout_id_t scanid; 957 958 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip))) 959 PM_LOCK_DIP(dip); 960 info = PM_GET_PM_INFO(dip); 961 scanp = PM_GET_PM_SCAN(dip); 962 if (pm_scans_disabled || !PM_SCANABLE(dip) || !info || !scanp || 963 (scanp->ps_scan_flags & PM_SCAN_STOP)) { 964 PM_UNLOCK_DIP(dip); 965 return; 966 } 967 if (scanp->ps_scan_flags & PM_SCANNING) { 968 scanp->ps_scan_flags |= PM_SCAN_AGAIN; 969 PM_UNLOCK_DIP(dip); 970 return; 971 } else if (scanp->ps_scan_id) { 972 scanid = scanp->ps_scan_id; 973 scanp->ps_scan_id = 0; 974 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): cancel timeout scanid %lx\n", 975 pmf, PM_DEVICE(dip), (ulong_t)scanid)) 976 PM_UNLOCK_DIP(dip); 977 (void) untimeout(scanid); 978 PM_LOCK_DIP(dip); 979 } 980 981 /* 982 * Dispatching pm_scan during attach time is risky due to the fact that 983 * attach might soon fail and dip dissolved, and panic may happen while 984 * attempting to stop scan. So schedule a pm_rescan instead. 985 * (Note that if either of the first two terms are true, taskq_dispatch 986 * will not be invoked). 987 * 988 * Multiple pm_scan dispatching is unecessary and costly to keep track 989 * of. The PM_SCAN_DISPATCHED flag is used between pm_rescan and pm_scan 990 * to regulate the dispatching. 991 * 992 * Scan is stopped before the device is detached (in pm_detaching()) 993 * but it may get re-started during the post_detach processing if the 994 * driver fails to detach. 995 */ 996 if (DEVI_IS_ATTACHING(dip) || 997 (scanp->ps_scan_flags & PM_SCAN_DISPATCHED) || 998 taskq_dispatch(system_taskq, pm_scan, (void *)dip, TQ_NOSLEEP) == 999 TASKQID_INVALID) { 1000 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): attaching, pm_scan already " 1001 "dispatched or dispatching failed\n", pmf, PM_DEVICE(dip))) 1002 if (scanp->ps_scan_id) { 1003 scanid = scanp->ps_scan_id; 1004 scanp->ps_scan_id = 0; 1005 PM_UNLOCK_DIP(dip); 1006 (void) untimeout(scanid); 1007 PM_LOCK_DIP(dip); 1008 if (scanp->ps_scan_id) { 1009 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): a competing " 1010 "thread scheduled pm_rescan, scanid %lx\n", 1011 pmf, PM_DEVICE(dip), 1012 (ulong_t)scanp->ps_scan_id)) 1013 PM_UNLOCK_DIP(dip); 1014 return; 1015 } 1016 } 1017 scanp->ps_scan_id = timeout(pm_rescan, (void *)dip, 1018 (scanp->ps_idle_down ? pm_id_ticks : 1019 (PM_MIN_SCAN(dip) * hz))); 1020 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): scheduled next pm_rescan, " 1021 "scanid %lx\n", pmf, PM_DEVICE(dip), 1022 (ulong_t)scanp->ps_scan_id)) 1023 } else { 1024 PMD(PMD_SCAN, ("%s: dispatched pm_scan for %s@%s(%s#%d)\n", 1025 pmf, PM_DEVICE(dip))) 1026 scanp->ps_scan_flags |= PM_SCAN_DISPATCHED; 1027 } 1028 PM_UNLOCK_DIP(dip); 1029 } 1030 1031 void 1032 pm_scan(void *arg) 1033 { 1034 PMD_FUNC(pmf, "scan") 1035 dev_info_t *dip = (dev_info_t *)arg; 1036 pm_scan_t *scanp; 1037 time_t nextscan; 1038 1039 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip))) 1040 1041 PM_LOCK_DIP(dip); 1042 scanp = PM_GET_PM_SCAN(dip); 1043 ASSERT(scanp && PM_GET_PM_INFO(dip)); 1044 1045 if (pm_scans_disabled || !PM_SCANABLE(dip) || 1046 (scanp->ps_scan_flags & PM_SCAN_STOP)) { 1047 scanp->ps_scan_flags &= ~(PM_SCAN_AGAIN | PM_SCAN_DISPATCHED); 1048 PM_UNLOCK_DIP(dip); 1049 return; 1050 } 1051 1052 if (scanp->ps_idle_down) { 1053 /* 1054 * make sure we remember idledown was in affect until 1055 * we've completed the scan 1056 */ 1057 PMID_SET_SCANS(scanp->ps_idle_down) 1058 PMD(PMD_IDLEDOWN, ("%s: %s@%s(%s#%d): idledown starts " 1059 "(pmid %x)\n", pmf, PM_DEVICE(dip), scanp->ps_idle_down)) 1060 } 1061 1062 /* possible having two threads running pm_scan() */ 1063 if (scanp->ps_scan_flags & PM_SCANNING) { 1064 scanp->ps_scan_flags |= PM_SCAN_AGAIN; 1065 PMD(PMD_SCAN, ("%s: scanning, will scan %s@%s(%s#%d) again\n", 1066 pmf, PM_DEVICE(dip))) 1067 scanp->ps_scan_flags &= ~PM_SCAN_DISPATCHED; 1068 PM_UNLOCK_DIP(dip); 1069 return; 1070 } 1071 1072 scanp->ps_scan_flags |= PM_SCANNING; 1073 scanp->ps_scan_flags &= ~PM_SCAN_DISPATCHED; 1074 do { 1075 scanp->ps_scan_flags &= ~PM_SCAN_AGAIN; 1076 PM_UNLOCK_DIP(dip); 1077 nextscan = pm_scan_dev(dip); 1078 PM_LOCK_DIP(dip); 1079 } while (scanp->ps_scan_flags & PM_SCAN_AGAIN); 1080 1081 ASSERT(scanp->ps_scan_flags & PM_SCANNING); 1082 scanp->ps_scan_flags &= ~PM_SCANNING; 1083 1084 if (scanp->ps_idle_down) { 1085 scanp->ps_idle_down &= ~PMID_SCANS; 1086 PMD(PMD_IDLEDOWN, ("%s: %s@%s(%s#%d): idledown ends " 1087 "(pmid %x)\n", pmf, PM_DEVICE(dip), scanp->ps_idle_down)) 1088 } 1089 1090 /* schedule for next idle check */ 1091 if (nextscan != LONG_MAX) { 1092 if (nextscan > (LONG_MAX / hz)) 1093 nextscan = (LONG_MAX - 1) / hz; 1094 if (scanp->ps_scan_id) { 1095 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): while scanning " 1096 "another rescan scheduled scanid(%lx)\n", pmf, 1097 PM_DEVICE(dip), (ulong_t)scanp->ps_scan_id)) 1098 PM_UNLOCK_DIP(dip); 1099 return; 1100 } else if (!(scanp->ps_scan_flags & PM_SCAN_STOP)) { 1101 scanp->ps_scan_id = timeout(pm_rescan, (void *)dip, 1102 (clock_t)(nextscan * hz)); 1103 PMD(PMD_SCAN, ("%s: nextscan for %s@%s(%s#%d) in " 1104 "%lx sec, scanid(%lx) \n", pmf, PM_DEVICE(dip), 1105 (ulong_t)nextscan, (ulong_t)scanp->ps_scan_id)) 1106 } 1107 } 1108 PM_UNLOCK_DIP(dip); 1109 } 1110 1111 void 1112 pm_get_timestamps(dev_info_t *dip, time_t *valuep) 1113 { 1114 int components = PM_NUMCMPTS(dip); 1115 int i; 1116 1117 ASSERT(components > 0); 1118 PM_LOCK_BUSY(dip); /* so we get a consistent view */ 1119 for (i = 0; i < components; i++) { 1120 valuep[i] = PM_CP(dip, i)->pmc_timestamp; 1121 } 1122 PM_UNLOCK_BUSY(dip); 1123 } 1124 1125 /* 1126 * Returns true if device needs to be kept up because it exported the 1127 * "no-involuntary-power-cycles" property or we're pretending it did (console 1128 * fb case) or it is an ancestor of such a device and has used up the "one 1129 * free cycle" allowed when all such leaf nodes have voluntarily powered down 1130 * upon detach 1131 */ 1132 int 1133 pm_noinvol(dev_info_t *dip) 1134 { 1135 PMD_FUNC(pmf, "noinvol") 1136 1137 /* 1138 * This doesn't change over the life of a driver, so no locking needed 1139 */ 1140 if (PM_IS_CFB(dip)) { 1141 PMD(PMD_NOINVOL | PMD_CFB, ("%s: inhibits CFB %s@%s(%s#%d)\n", 1142 pmf, PM_DEVICE(dip))) 1143 return (1); 1144 } 1145 /* 1146 * Not an issue if no such kids 1147 */ 1148 if (DEVI(dip)->devi_pm_noinvolpm == 0) { 1149 #ifdef DEBUG 1150 if (DEVI(dip)->devi_pm_volpmd != 0) { 1151 dev_info_t *pdip = dip; 1152 do { 1153 PMD(PMD_NOINVOL, ("%s: %s@%s(%s#%d) noinvol %d " 1154 "volpmd %d\n", pmf, PM_DEVICE(pdip), 1155 DEVI(pdip)->devi_pm_noinvolpm, 1156 DEVI(pdip)->devi_pm_volpmd)) 1157 pdip = ddi_get_parent(pdip); 1158 } while (pdip); 1159 } 1160 #endif 1161 ASSERT(DEVI(dip)->devi_pm_volpmd == 0); 1162 return (0); 1163 } 1164 1165 /* 1166 * Since we now maintain the counts correct at every node, we no longer 1167 * need to look up the tree. An ancestor cannot use up the free cycle 1168 * without the children getting their counts adjusted. 1169 */ 1170 1171 #ifdef DEBUG 1172 if (DEVI(dip)->devi_pm_noinvolpm != DEVI(dip)->devi_pm_volpmd) 1173 PMD(PMD_NOINVOL, ("%s: (%d != %d) inhibits %s@%s(%s#%d)\n", pmf, 1174 DEVI(dip)->devi_pm_noinvolpm, DEVI(dip)->devi_pm_volpmd, 1175 PM_DEVICE(dip))) 1176 #endif 1177 return (DEVI(dip)->devi_pm_noinvolpm != DEVI(dip)->devi_pm_volpmd); 1178 } 1179 1180 static int cur_threshold(dev_info_t *, int); 1181 static int pm_next_lower_power(pm_component_t *, int); 1182 1183 /* 1184 * This function performs the actual scanning of the device. 1185 * It attempts to power off the indicated device's components if they have 1186 * been idle and other restrictions are met. 1187 * pm_scan_dev calculates and returns when the next scan should happen for 1188 * this device. 1189 */ 1190 time_t 1191 pm_scan_dev(dev_info_t *dip) 1192 { 1193 PMD_FUNC(pmf, "scan_dev") 1194 pm_scan_t *scanp; 1195 time_t *timestamp, idletime, now, thresh; 1196 time_t timeleft = 0; 1197 #ifdef PMDDEBUG 1198 int curpwr; 1199 #endif 1200 int i, nxtpwr, pwrndx, unused; 1201 size_t size; 1202 pm_component_t *cp; 1203 dev_info_t *pdip = ddi_get_parent(dip); 1204 int circ; 1205 clock_t min_scan = pm_default_min_scan; 1206 1207 /* 1208 * skip attaching device 1209 */ 1210 if (DEVI_IS_ATTACHING(dip)) { 1211 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) is attaching, timeleft(%lx)\n", 1212 pmf, PM_DEVICE(dip), min_scan)) 1213 return (min_scan); 1214 } 1215 1216 PM_LOCK_DIP(dip); 1217 scanp = PM_GET_PM_SCAN(dip); 1218 min_scan = PM_MIN_SCAN(dip); 1219 ASSERT(scanp && PM_GET_PM_INFO(dip)); 1220 1221 PMD(PMD_SCAN, ("%s: [BEGIN %s@%s(%s#%d)]\n", pmf, PM_DEVICE(dip))) 1222 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): kuc is %d\n", pmf, PM_DEVICE(dip), 1223 PM_KUC(dip))) 1224 1225 /* no scan under the following conditions */ 1226 if (pm_scans_disabled || !PM_SCANABLE(dip) || 1227 (scanp->ps_scan_flags & PM_SCAN_STOP) || 1228 (PM_KUC(dip) != 0) || 1229 PM_ISDIRECT(dip) || pm_noinvol(dip)) { 1230 PM_UNLOCK_DIP(dip); 1231 PMD(PMD_SCAN, ("%s: [END, %s@%s(%s#%d)] no scan, " 1232 "scan_disabled(%d), apm_enabled(%d), cpupm(%d), " 1233 "kuc(%d), %s directpm, %s pm_noinvol\n", 1234 pmf, PM_DEVICE(dip), pm_scans_disabled, autopm_enabled, 1235 cpupm, PM_KUC(dip), 1236 PM_ISDIRECT(dip) ? "is" : "is not", 1237 pm_noinvol(dip) ? "is" : "is not")) 1238 return (LONG_MAX); 1239 } 1240 PM_UNLOCK_DIP(dip); 1241 1242 if (!ndi_devi_tryenter(pdip, &circ)) { 1243 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) can't hold pdip", 1244 pmf, PM_DEVICE(pdip))) 1245 return ((time_t)1); 1246 } 1247 now = gethrestime_sec(); 1248 size = PM_NUMCMPTS(dip) * sizeof (time_t); 1249 timestamp = kmem_alloc(size, KM_SLEEP); 1250 pm_get_timestamps(dip, timestamp); 1251 1252 /* 1253 * Since we removed support for backwards compatible devices, 1254 * (see big comment at top of file) 1255 * it is no longer required to deal with component 0 last. 1256 */ 1257 for (i = 0; i < PM_NUMCMPTS(dip); i++) { 1258 /* 1259 * If already off (an optimization, perhaps) 1260 */ 1261 cp = PM_CP(dip, i); 1262 pwrndx = cp->pmc_cur_pwr; 1263 #ifdef PMDDEBUG 1264 curpwr = (pwrndx == PM_LEVEL_UNKNOWN) ? 1265 PM_LEVEL_UNKNOWN : 1266 cp->pmc_comp.pmc_lvals[pwrndx]; 1267 #endif 1268 1269 if (pwrndx == 0) { 1270 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d off or " 1271 "lowest\n", pmf, PM_DEVICE(dip), i)) 1272 /* skip device if off or at its lowest */ 1273 continue; 1274 } 1275 1276 thresh = cur_threshold(dip, i); /* comp i threshold */ 1277 if ((timestamp[i] == 0) || (cp->pmc_busycount > 0)) { 1278 /* were busy or newly became busy by another thread */ 1279 if (timeleft == 0) 1280 timeleft = max(thresh, min_scan); 1281 else 1282 timeleft = min( 1283 timeleft, max(thresh, min_scan)); 1284 continue; 1285 } 1286 1287 idletime = now - timestamp[i]; /* idle time */ 1288 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d idle time %lx\n", 1289 pmf, PM_DEVICE(dip), i, idletime)) 1290 if (idletime >= thresh || PM_IS_PID(dip)) { 1291 nxtpwr = pm_next_lower_power(cp, pwrndx); 1292 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, %d->%d\n", 1293 pmf, PM_DEVICE(dip), i, curpwr, nxtpwr)) 1294 if (pm_set_power(dip, i, nxtpwr, PM_LEVEL_DOWNONLY, 1295 PM_CANBLOCK_FAIL, 1, &unused) != DDI_SUCCESS && 1296 PM_CURPOWER(dip, i) != nxtpwr) { 1297 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, " 1298 "%d->%d Failed\n", pmf, PM_DEVICE(dip), 1299 i, curpwr, nxtpwr)) 1300 timeleft = min_scan; 1301 continue; 1302 } else { 1303 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, " 1304 "%d->%d, GOOD curpwr %d\n", pmf, 1305 PM_DEVICE(dip), i, curpwr, nxtpwr, 1306 cur_power(cp))) 1307 1308 if (nxtpwr == 0) /* component went off */ 1309 continue; 1310 1311 /* 1312 * scan to next lower level 1313 */ 1314 if (timeleft == 0) 1315 timeleft = max( 1316 1, cur_threshold(dip, i)); 1317 else 1318 timeleft = min(timeleft, 1319 max(1, cur_threshold(dip, i))); 1320 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, " 1321 "timeleft(%lx)\n", pmf, PM_DEVICE(dip), 1322 i, timeleft)) 1323 } 1324 } else { /* comp not idle long enough */ 1325 if (timeleft == 0) 1326 timeleft = thresh - idletime; 1327 else 1328 timeleft = min(timeleft, (thresh - idletime)); 1329 PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, timeleft=" 1330 "%lx\n", pmf, PM_DEVICE(dip), i, timeleft)) 1331 } 1332 } 1333 ndi_devi_exit(pdip, circ); 1334 kmem_free(timestamp, size); 1335 PMD(PMD_SCAN, ("%s: [END %s@%s(%s#%d)] timeleft(%lx)\n", pmf, 1336 PM_DEVICE(dip), timeleft)) 1337 1338 /* 1339 * if components are already at lowest level, timeleft is left 0 1340 */ 1341 return ((timeleft == 0) ? LONG_MAX : timeleft); 1342 } 1343 1344 /* 1345 * pm_scan_stop - cancel scheduled pm_rescan, 1346 * wait for termination of dispatched pm_scan thread 1347 * and active pm_scan_dev thread. 1348 */ 1349 void 1350 pm_scan_stop(dev_info_t *dip) 1351 { 1352 PMD_FUNC(pmf, "scan_stop") 1353 pm_scan_t *scanp; 1354 timeout_id_t scanid; 1355 1356 PMD(PMD_SCAN, ("%s: [BEGIN %s@%s(%s#%d)]\n", pmf, PM_DEVICE(dip))) 1357 PM_LOCK_DIP(dip); 1358 scanp = PM_GET_PM_SCAN(dip); 1359 if (!scanp) { 1360 PMD(PMD_SCAN, ("%s: [END %s@%s(%s#%d)] scan not initialized\n", 1361 pmf, PM_DEVICE(dip))) 1362 PM_UNLOCK_DIP(dip); 1363 return; 1364 } 1365 scanp->ps_scan_flags |= PM_SCAN_STOP; 1366 1367 /* cancel scheduled scan taskq */ 1368 while (scanp->ps_scan_id) { 1369 scanid = scanp->ps_scan_id; 1370 scanp->ps_scan_id = 0; 1371 PM_UNLOCK_DIP(dip); 1372 (void) untimeout(scanid); 1373 PM_LOCK_DIP(dip); 1374 } 1375 1376 while (scanp->ps_scan_flags & (PM_SCANNING | PM_SCAN_DISPATCHED)) { 1377 PM_UNLOCK_DIP(dip); 1378 delay(1); 1379 PM_LOCK_DIP(dip); 1380 } 1381 PM_UNLOCK_DIP(dip); 1382 PMD(PMD_SCAN, ("%s: [END %s@%s(%s#%d)]\n", pmf, PM_DEVICE(dip))) 1383 } 1384 1385 int 1386 pm_scan_stop_walk(dev_info_t *dip, void *arg) 1387 { 1388 _NOTE(ARGUNUSED(arg)) 1389 1390 if (!PM_GET_PM_SCAN(dip)) 1391 return (DDI_WALK_CONTINUE); 1392 ASSERT(!PM_ISBC(dip)); 1393 pm_scan_stop(dip); 1394 return (DDI_WALK_CONTINUE); 1395 } 1396 1397 /* 1398 * Converts a power level value to its index 1399 */ 1400 static int 1401 power_val_to_index(pm_component_t *cp, int val) 1402 { 1403 int limit, i, *ip; 1404 1405 ASSERT(val != PM_LEVEL_UPONLY && val != PM_LEVEL_DOWNONLY && 1406 val != PM_LEVEL_EXACT); 1407 /* convert power value into index (i) */ 1408 limit = cp->pmc_comp.pmc_numlevels; 1409 ip = cp->pmc_comp.pmc_lvals; 1410 for (i = 0; i < limit; i++) 1411 if (val == *ip++) 1412 return (i); 1413 return (-1); 1414 } 1415 1416 /* 1417 * Converts a numeric power level to a printable string 1418 */ 1419 static char * 1420 power_val_to_string(pm_component_t *cp, int val) 1421 { 1422 int index; 1423 1424 if (val == PM_LEVEL_UPONLY) 1425 return ("<UPONLY>"); 1426 1427 if (val == PM_LEVEL_UNKNOWN || 1428 (index = power_val_to_index(cp, val)) == -1) 1429 return ("<LEVEL_UNKNOWN>"); 1430 1431 return (cp->pmc_comp.pmc_lnames[index]); 1432 } 1433 1434 /* 1435 * Return true if this node has been claimed by a ppm. 1436 */ 1437 static int 1438 pm_ppm_claimed(dev_info_t *dip) 1439 { 1440 return (PPM(dip) != NULL); 1441 } 1442 1443 /* 1444 * A node which was voluntarily power managed has just used up its "free cycle" 1445 * and need is volpmd field cleared, and the same done to all its descendents 1446 */ 1447 static void 1448 pm_clear_volpm_dip(dev_info_t *dip) 1449 { 1450 PMD_FUNC(pmf, "clear_volpm_dip") 1451 1452 if (dip == NULL) 1453 return; 1454 PMD(PMD_NOINVOL, ("%s: clear volpm from %s@%s(%s#%d)\n", pmf, 1455 PM_DEVICE(dip))) 1456 DEVI(dip)->devi_pm_volpmd = 0; 1457 for (dip = ddi_get_child(dip); dip; dip = ddi_get_next_sibling(dip)) { 1458 pm_clear_volpm_dip(dip); 1459 } 1460 } 1461 1462 /* 1463 * A node which was voluntarily power managed has used up the "free cycles" 1464 * for the subtree that it is the root of. Scan through the list of detached 1465 * nodes and adjust the counts of any that are descendents of the node. 1466 */ 1467 static void 1468 pm_clear_volpm_list(dev_info_t *dip) 1469 { 1470 PMD_FUNC(pmf, "clear_volpm_list") 1471 char *pathbuf; 1472 size_t len; 1473 pm_noinvol_t *ip; 1474 1475 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1476 (void) ddi_pathname(dip, pathbuf); 1477 len = strlen(pathbuf); 1478 PMD(PMD_NOINVOL, ("%s: clear volpm list %s\n", pmf, pathbuf)) 1479 rw_enter(&pm_noinvol_rwlock, RW_WRITER); 1480 for (ip = pm_noinvol_head; ip; ip = ip->ni_next) { 1481 PMD(PMD_NOINVOL, ("%s: clear volpm: ni_path %s\n", pmf, 1482 ip->ni_path)) 1483 if (strncmp(pathbuf, ip->ni_path, len) == 0 && 1484 ip->ni_path[len] == '/') { 1485 PMD(PMD_NOINVOL, ("%s: clear volpm: %s\n", pmf, 1486 ip->ni_path)) 1487 ip->ni_volpmd = 0; 1488 ip->ni_wasvolpmd = 0; 1489 } 1490 } 1491 kmem_free(pathbuf, MAXPATHLEN); 1492 rw_exit(&pm_noinvol_rwlock); 1493 } 1494 1495 /* 1496 * Powers a device, suspending or resuming the driver if it is a backward 1497 * compatible device, calling into ppm to change power level. 1498 * Called with the component's power lock held. 1499 */ 1500 static int 1501 power_dev(dev_info_t *dip, int comp, int level, int old_level, 1502 pm_canblock_t canblock, pm_ppm_devlist_t **devlist) 1503 { 1504 PMD_FUNC(pmf, "power_dev") 1505 power_req_t power_req; 1506 int power_op_ret; /* DDI_SUCCESS or DDI_FAILURE */ 1507 int resume_needed = 0; 1508 int suspended = 0; 1509 int result; 1510 #ifdef PMDDEBUG 1511 struct pm_component *cp = PM_CP(dip, comp); 1512 #endif 1513 int bc = PM_ISBC(dip); 1514 int pm_all_components_off(dev_info_t *); 1515 int clearvolpmd = 0; 1516 char pathbuf[MAXNAMELEN]; 1517 #ifdef PMDDEBUG 1518 char *ppmname, *ppmaddr; 1519 #endif 1520 /* 1521 * If this is comp 0 of a backwards compat device and we are 1522 * going to take the power away, we need to detach it with 1523 * DDI_PM_SUSPEND command. 1524 */ 1525 if (bc && comp == 0 && POWERING_OFF(old_level, level)) { 1526 if (devi_detach(dip, DDI_PM_SUSPEND) != DDI_SUCCESS) { 1527 /* We could not suspend before turning cmpt zero off */ 1528 PMD(PMD_ERROR, ("%s: could not suspend %s@%s(%s#%d)\n", 1529 pmf, PM_DEVICE(dip))) 1530 return (DDI_FAILURE); 1531 } else { 1532 DEVI(dip)->devi_pm_flags |= PMC_SUSPENDED; 1533 suspended++; 1534 } 1535 } 1536 power_req.request_type = PMR_PPM_SET_POWER; 1537 power_req.req.ppm_set_power_req.who = dip; 1538 power_req.req.ppm_set_power_req.cmpt = comp; 1539 power_req.req.ppm_set_power_req.old_level = old_level; 1540 power_req.req.ppm_set_power_req.new_level = level; 1541 power_req.req.ppm_set_power_req.canblock = canblock; 1542 power_req.req.ppm_set_power_req.cookie = NULL; 1543 #ifdef PMDDEBUG 1544 if (pm_ppm_claimed(dip)) { 1545 ppmname = PM_NAME(PPM(dip)); 1546 ppmaddr = PM_ADDR(PPM(dip)); 1547 1548 } else { 1549 ppmname = "noppm"; 1550 ppmaddr = "0"; 1551 } 1552 PMD(PMD_PPM, ("%s: %s@%s(%s#%d):%s[%d] %s (%d) -> %s (%d) via %s@%s\n", 1553 pmf, PM_DEVICE(dip), cp->pmc_comp.pmc_name, comp, 1554 power_val_to_string(cp, old_level), old_level, 1555 power_val_to_string(cp, level), level, ppmname, ppmaddr)) 1556 #endif 1557 /* 1558 * If non-bc noinvolpm device is turning first comp on, or noinvolpm 1559 * bc device comp 0 is powering on, then we count it as a power cycle 1560 * against its voluntary count. 1561 */ 1562 if (DEVI(dip)->devi_pm_volpmd && 1563 (!bc && pm_all_components_off(dip) && level != 0) || 1564 (bc && comp == 0 && POWERING_ON(old_level, level))) 1565 clearvolpmd = 1; 1566 if ((power_op_ret = pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, 1567 &power_req, &result)) == DDI_SUCCESS) { 1568 /* 1569 * Now do involuntary pm accounting; If we've just cycled power 1570 * on a voluntarily pm'd node, and by inference on its entire 1571 * subtree, we need to set the subtree (including those nodes 1572 * already detached) volpmd counts to 0, and subtract out the 1573 * value of the current node's volpmd count from the ancestors 1574 */ 1575 if (clearvolpmd) { 1576 int volpmd = DEVI(dip)->devi_pm_volpmd; 1577 pm_clear_volpm_dip(dip); 1578 pm_clear_volpm_list(dip); 1579 if (volpmd) { 1580 (void) ddi_pathname(dip, pathbuf); 1581 (void) pm_noinvol_update(PM_BP_NOINVOL_POWER, 1582 volpmd, 0, pathbuf, dip); 1583 } 1584 } 1585 } else { 1586 PMD(PMD_FAIL, ("%s: can't set comp %d (%s) of %s@%s(%s#%d) " 1587 "to level %d (%s)\n", pmf, comp, cp->pmc_comp.pmc_name, 1588 PM_DEVICE(dip), level, power_val_to_string(cp, level))) 1589 } 1590 /* 1591 * If some other devices were also powered up (e.g. other cpus in 1592 * the same domain) return a pointer to that list 1593 */ 1594 if (devlist) { 1595 *devlist = (pm_ppm_devlist_t *) 1596 power_req.req.ppm_set_power_req.cookie; 1597 } 1598 /* 1599 * We will have to resume the device if the device is backwards compat 1600 * device and either of the following is true: 1601 * -This is comp 0 and we have successfully powered it up 1602 * -This is comp 0 and we have failed to power it down. Resume is 1603 * needed because we have suspended it above 1604 */ 1605 1606 if (bc && comp == 0) { 1607 ASSERT(PM_ISDIRECT(dip) || DEVI_IS_DETACHING(dip)); 1608 if (power_op_ret == DDI_SUCCESS) { 1609 if (POWERING_ON(old_level, level)) { 1610 /* 1611 * It must be either suspended or resumed 1612 * via pm_power_has_changed path 1613 */ 1614 ASSERT((DEVI(dip)->devi_pm_flags & 1615 PMC_SUSPENDED) || 1616 (PM_CP(dip, comp)->pmc_flags & 1617 PM_PHC_WHILE_SET_POWER)); 1618 1619 resume_needed = suspended; 1620 } 1621 } else { 1622 if (POWERING_OFF(old_level, level)) { 1623 /* 1624 * It must be either suspended or resumed 1625 * via pm_power_has_changed path 1626 */ 1627 ASSERT((DEVI(dip)->devi_pm_flags & 1628 PMC_SUSPENDED) || 1629 (PM_CP(dip, comp)->pmc_flags & 1630 PM_PHC_WHILE_SET_POWER)); 1631 1632 resume_needed = suspended; 1633 } 1634 } 1635 } 1636 if (resume_needed) { 1637 ASSERT(DEVI(dip)->devi_pm_flags & PMC_SUSPENDED); 1638 /* ppm is not interested in DDI_PM_RESUME */ 1639 if ((power_op_ret = devi_attach(dip, DDI_PM_RESUME)) == 1640 DDI_SUCCESS) { 1641 DEVI(dip)->devi_pm_flags &= ~PMC_SUSPENDED; 1642 } else 1643 cmn_err(CE_WARN, "!pm: Can't resume %s@%s(%s#%d)", 1644 PM_DEVICE(dip)); 1645 } 1646 return (power_op_ret); 1647 } 1648 1649 /* 1650 * Return true if we are the owner or a borrower of the devi lock. See 1651 * pm_lock_power_single() about borrowing the lock. 1652 */ 1653 static int 1654 pm_devi_lock_held(dev_info_t *dip) 1655 { 1656 lock_loan_t *cur; 1657 1658 if (DEVI_BUSY_OWNED(dip)) 1659 return (1); 1660 1661 /* return false if no locks borrowed */ 1662 if (lock_loan_head.pmlk_next == NULL) 1663 return (0); 1664 1665 mutex_enter(&pm_loan_lock); 1666 /* see if our thread is registered as a lock borrower. */ 1667 for (cur = lock_loan_head.pmlk_next; cur; cur = cur->pmlk_next) 1668 if (cur->pmlk_borrower == curthread) 1669 break; 1670 mutex_exit(&pm_loan_lock); 1671 1672 return (cur != NULL && cur->pmlk_lender == DEVI(dip)->devi_busy_thread); 1673 } 1674 1675 /* 1676 * pm_set_power: adjusts power level of device. Assumes device is power 1677 * manageable & component exists. 1678 * 1679 * Cases which require us to bring up devices we keep up ("wekeepups") for 1680 * backwards compatible devices: 1681 * component 0 is off and we're bringing it up from 0 1682 * bring up wekeepup first 1683 * and recursively when component 0 is off and we bring some other 1684 * component up from 0 1685 * For devices which are not backward compatible, our dependency notion is much 1686 * simpler. Unless all components are off, then wekeeps must be on. 1687 * We don't treat component 0 differently. 1688 * Canblock tells how to deal with a direct pm'd device. 1689 * Scan arg tells us if we were called from scan, in which case we don't need 1690 * to go back to the root node and walk down to change power. 1691 */ 1692 int 1693 pm_set_power(dev_info_t *dip, int comp, int level, int direction, 1694 pm_canblock_t canblock, int scan, int *retp) 1695 { 1696 PMD_FUNC(pmf, "set_power") 1697 char *pathbuf; 1698 pm_bp_child_pwrchg_t bpc; 1699 pm_sp_misc_t pspm; 1700 int ret = DDI_SUCCESS; 1701 int unused = DDI_SUCCESS; 1702 dev_info_t *pdip = ddi_get_parent(dip); 1703 1704 #ifdef DEBUG 1705 int diverted = 0; 1706 1707 /* 1708 * This prevents operations on the console from calling prom_printf and 1709 * either deadlocking or bringing up the console because of debug 1710 * output 1711 */ 1712 if (dip == cfb_dip) { 1713 diverted++; 1714 mutex_enter(&pm_debug_lock); 1715 pm_divertdebug++; 1716 mutex_exit(&pm_debug_lock); 1717 } 1718 #endif 1719 ASSERT(direction == PM_LEVEL_UPONLY || direction == PM_LEVEL_DOWNONLY || 1720 direction == PM_LEVEL_EXACT); 1721 PMD(PMD_SET, ("%s: %s@%s(%s#%d), comp=%d, dir=%s, new=%d\n", 1722 pmf, PM_DEVICE(dip), comp, pm_decode_direction(direction), level)) 1723 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1724 (void) ddi_pathname(dip, pathbuf); 1725 bpc.bpc_dip = dip; 1726 bpc.bpc_path = pathbuf; 1727 bpc.bpc_comp = comp; 1728 bpc.bpc_olevel = PM_CURPOWER(dip, comp); 1729 bpc.bpc_nlevel = level; 1730 pspm.pspm_direction = direction; 1731 pspm.pspm_errnop = retp; 1732 pspm.pspm_canblock = canblock; 1733 pspm.pspm_scan = scan; 1734 bpc.bpc_private = &pspm; 1735 1736 /* 1737 * If a config operation is being done (we've locked the parent) or 1738 * we already hold the power lock (we've locked the node) 1739 * then we can operate directly on the node because we have already 1740 * brought up all the ancestors, otherwise, we have to go back to the 1741 * top of the tree. 1742 */ 1743 if (pm_devi_lock_held(pdip) || pm_devi_lock_held(dip)) 1744 ret = pm_busop_set_power(dip, NULL, BUS_POWER_CHILD_PWRCHG, 1745 (void *)&bpc, (void *)&unused); 1746 else 1747 ret = pm_busop_bus_power(ddi_root_node(), NULL, 1748 BUS_POWER_CHILD_PWRCHG, (void *)&bpc, (void *)&unused); 1749 #ifdef DEBUG 1750 if (ret != DDI_SUCCESS || *retp != DDI_SUCCESS) { 1751 PMD(PMD_ERROR, ("%s: %s@%s(%s#%d) can't change power, ret=%d, " 1752 "errno=%d\n", pmf, PM_DEVICE(dip), ret, *retp)) 1753 } 1754 if (diverted) { 1755 mutex_enter(&pm_debug_lock); 1756 pm_divertdebug--; 1757 mutex_exit(&pm_debug_lock); 1758 } 1759 #endif 1760 kmem_free(pathbuf, MAXPATHLEN); 1761 return (ret); 1762 } 1763 1764 /* 1765 * If holddip is set, then if a dip is found we return with the node held. 1766 * 1767 * This code uses the same locking scheme as e_ddi_hold_devi_by_path 1768 * (resolve_pathname), but it does not drive attach. 1769 */ 1770 dev_info_t * 1771 pm_name_to_dip(char *pathname, int holddip) 1772 { 1773 struct pathname pn; 1774 char *component; 1775 dev_info_t *parent, *child; 1776 int circ; 1777 1778 if ((pathname == NULL) || (*pathname != '/')) 1779 return (NULL); 1780 1781 /* setup pathname and allocate component */ 1782 if (pn_get(pathname, UIO_SYSSPACE, &pn)) 1783 return (NULL); 1784 component = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1785 1786 /* start at top, process '/' component */ 1787 parent = child = ddi_root_node(); 1788 ndi_hold_devi(parent); 1789 pn_skipslash(&pn); 1790 ASSERT(i_ddi_devi_attached(parent)); 1791 1792 /* process components of pathname */ 1793 while (pn_pathleft(&pn)) { 1794 (void) pn_getcomponent(&pn, component); 1795 1796 /* enter parent and search for component child */ 1797 ndi_devi_enter(parent, &circ); 1798 child = ndi_devi_findchild(parent, component); 1799 if ((child == NULL) || !i_ddi_devi_attached(child)) { 1800 child = NULL; 1801 ndi_devi_exit(parent, circ); 1802 ndi_rele_devi(parent); 1803 goto out; 1804 } 1805 1806 /* attached child found, hold child and release parent */ 1807 ndi_hold_devi(child); 1808 ndi_devi_exit(parent, circ); 1809 ndi_rele_devi(parent); 1810 1811 /* child becomes parent, and process next component */ 1812 parent = child; 1813 pn_skipslash(&pn); 1814 1815 /* loop with active ndi_devi_hold of child->parent */ 1816 } 1817 1818 out: 1819 pn_free(&pn); 1820 kmem_free(component, MAXNAMELEN); 1821 1822 /* if we are not asked to return with hold, drop current hold */ 1823 if (child && !holddip) 1824 ndi_rele_devi(child); 1825 return (child); 1826 } 1827 1828 /* 1829 * Search for a dependency and mark it unsatisfied 1830 */ 1831 static void 1832 pm_unsatisfy(char *keeper, char *kept) 1833 { 1834 PMD_FUNC(pmf, "unsatisfy") 1835 pm_pdr_t *dp; 1836 1837 PMD(PMD_KEEPS, ("%s: keeper=%s, kept=%s\n", pmf, keeper, kept)) 1838 for (dp = pm_dep_head; dp; dp = dp->pdr_next) { 1839 if (!dp->pdr_isprop) { 1840 if (strcmp(dp->pdr_keeper, keeper) == 0 && 1841 (dp->pdr_kept_count > 0) && 1842 strcmp(dp->pdr_kept_paths[0], kept) == 0) { 1843 if (dp->pdr_satisfied) { 1844 dp->pdr_satisfied = 0; 1845 pm_unresolved_deps++; 1846 PMD(PMD_KEEPS, ("%s: clear satisfied, " 1847 "pm_unresolved_deps now %d\n", pmf, 1848 pm_unresolved_deps)) 1849 } 1850 } 1851 } 1852 } 1853 } 1854 1855 /* 1856 * Device dip is being un power managed, it keeps up count other devices. 1857 * We need to release any hold we have on the kept devices, and also 1858 * mark the dependency no longer satisfied. 1859 */ 1860 static void 1861 pm_unkeeps(int count, char *keeper, char **keptpaths, int pwr) 1862 { 1863 PMD_FUNC(pmf, "unkeeps") 1864 int i, j; 1865 dev_info_t *kept; 1866 dev_info_t *dip; 1867 struct pm_component *cp; 1868 int keeper_on = 0, circ; 1869 1870 PMD(PMD_KEEPS, ("%s: count=%d, keeper=%s, keptpaths=%p\n", pmf, count, 1871 keeper, (void *)keptpaths)) 1872 /* 1873 * Try to grab keeper. Keeper may have gone away by now, 1874 * in this case, used the passed in value pwr 1875 */ 1876 dip = pm_name_to_dip(keeper, 1); 1877 for (i = 0; i < count; i++) { 1878 /* Release power hold */ 1879 kept = pm_name_to_dip(keptpaths[i], 1); 1880 if (kept) { 1881 PMD(PMD_KEEPS, ("%s: %s@%s(%s#%d)[%d]\n", pmf, 1882 PM_DEVICE(kept), i)) 1883 /* 1884 * We need to check if we skipped a bringup here 1885 * because we could have failed the bringup 1886 * (ie DIRECT PM device) and have 1887 * not increment the count. 1888 */ 1889 if ((dip != NULL) && (PM_GET_PM_INFO(dip) != NULL)) { 1890 keeper_on = 0; 1891 PM_LOCK_POWER(dip, &circ); 1892 for (j = 0; j < PM_NUMCMPTS(dip); j++) { 1893 cp = &DEVI(dip)->devi_pm_components[j]; 1894 if (cur_power(cp)) { 1895 keeper_on++; 1896 break; 1897 } 1898 } 1899 if (keeper_on && (PM_SKBU(kept) == 0)) { 1900 pm_rele_power(kept); 1901 DEVI(kept)->devi_pm_flags 1902 &= ~PMC_SKIP_BRINGUP; 1903 } 1904 PM_UNLOCK_POWER(dip, circ); 1905 } else if (pwr) { 1906 if (PM_SKBU(kept) == 0) { 1907 pm_rele_power(kept); 1908 DEVI(kept)->devi_pm_flags 1909 &= ~PMC_SKIP_BRINGUP; 1910 } 1911 } 1912 ddi_release_devi(kept); 1913 } 1914 /* 1915 * mark this dependency not satisfied 1916 */ 1917 pm_unsatisfy(keeper, keptpaths[i]); 1918 } 1919 if (dip) 1920 ddi_release_devi(dip); 1921 } 1922 1923 /* 1924 * Device kept is being un power managed, it is kept up by keeper. 1925 * We need to mark the dependency no longer satisfied. 1926 */ 1927 static void 1928 pm_unkepts(char *kept, char *keeper) 1929 { 1930 PMD_FUNC(pmf, "unkepts") 1931 PMD(PMD_KEEPS, ("%s: kept=%s, keeper=%s\n", pmf, kept, keeper)) 1932 ASSERT(keeper != NULL); 1933 /* 1934 * mark this dependency not satisfied 1935 */ 1936 pm_unsatisfy(keeper, kept); 1937 } 1938 1939 /* 1940 * Removes dependency information and hold on the kepts, if the path is a 1941 * path of a keeper. 1942 */ 1943 static void 1944 pm_free_keeper(char *path, int pwr) 1945 { 1946 pm_pdr_t *dp; 1947 int i; 1948 size_t length; 1949 1950 for (dp = pm_dep_head; dp; dp = dp->pdr_next) { 1951 if (strcmp(dp->pdr_keeper, path) != 0) 1952 continue; 1953 /* 1954 * Remove all our kept holds and the dependency records, 1955 * then free up the kept lists. 1956 */ 1957 pm_unkeeps(dp->pdr_kept_count, path, dp->pdr_kept_paths, pwr); 1958 if (dp->pdr_kept_count) { 1959 for (i = 0; i < dp->pdr_kept_count; i++) { 1960 length = strlen(dp->pdr_kept_paths[i]); 1961 kmem_free(dp->pdr_kept_paths[i], length + 1); 1962 } 1963 kmem_free(dp->pdr_kept_paths, 1964 dp->pdr_kept_count * sizeof (char **)); 1965 dp->pdr_kept_paths = NULL; 1966 dp->pdr_kept_count = 0; 1967 } 1968 } 1969 } 1970 1971 /* 1972 * Removes the device represented by path from the list of kepts, if the 1973 * path is a path of a kept 1974 */ 1975 static void 1976 pm_free_kept(char *path) 1977 { 1978 pm_pdr_t *dp; 1979 int i; 1980 int j, count; 1981 size_t length; 1982 char **paths; 1983 1984 paths = NULL; 1985 for (dp = pm_dep_head; dp; dp = dp->pdr_next) { 1986 if (dp->pdr_kept_count == 0) 1987 continue; 1988 count = dp->pdr_kept_count; 1989 /* Remove this device from the kept path lists */ 1990 for (i = 0; i < count; i++) { 1991 if (strcmp(dp->pdr_kept_paths[i], path) == 0) { 1992 pm_unkepts(path, dp->pdr_keeper); 1993 length = strlen(dp->pdr_kept_paths[i]) + 1; 1994 kmem_free(dp->pdr_kept_paths[i], length); 1995 dp->pdr_kept_paths[i] = NULL; 1996 dp->pdr_kept_count--; 1997 } 1998 } 1999 /* Compact the kept paths array */ 2000 if (dp->pdr_kept_count) { 2001 length = dp->pdr_kept_count * sizeof (char **); 2002 paths = kmem_zalloc(length, KM_SLEEP); 2003 j = 0; 2004 for (i = 0; i < count; i++) { 2005 if (dp->pdr_kept_paths[i] != NULL) { 2006 paths[j] = dp->pdr_kept_paths[i]; 2007 j++; 2008 } 2009 } 2010 ASSERT(j == dp->pdr_kept_count); 2011 } 2012 /* Now free the old array and point to the new one */ 2013 kmem_free(dp->pdr_kept_paths, count * sizeof (char **)); 2014 dp->pdr_kept_paths = paths; 2015 } 2016 } 2017 2018 /* 2019 * Free the dependency information for a device. 2020 */ 2021 void 2022 pm_free_keeps(char *path, int pwr) 2023 { 2024 PMD_FUNC(pmf, "free_keeps") 2025 2026 #ifdef DEBUG 2027 int doprdeps = 0; 2028 void prdeps(char *); 2029 2030 PMD(PMD_KEEPS, ("%s: %s\n", pmf, path)) 2031 if (pm_debug & PMD_KEEPS) { 2032 doprdeps = 1; 2033 prdeps("pm_free_keeps before"); 2034 } 2035 #endif 2036 /* 2037 * First assume we are a keeper and remove all our kepts. 2038 */ 2039 pm_free_keeper(path, pwr); 2040 /* 2041 * Now assume we a kept device, and remove all our records. 2042 */ 2043 pm_free_kept(path); 2044 #ifdef DEBUG 2045 if (doprdeps) { 2046 prdeps("pm_free_keeps after"); 2047 } 2048 #endif 2049 } 2050 2051 static int 2052 pm_is_kept(char *path) 2053 { 2054 pm_pdr_t *dp; 2055 int i; 2056 2057 for (dp = pm_dep_head; dp; dp = dp->pdr_next) { 2058 if (dp->pdr_kept_count == 0) 2059 continue; 2060 for (i = 0; i < dp->pdr_kept_count; i++) { 2061 if (strcmp(dp->pdr_kept_paths[i], path) == 0) 2062 return (1); 2063 } 2064 } 2065 return (0); 2066 } 2067 2068 static void 2069 e_pm_hold_rele_power(dev_info_t *dip, int cnt) 2070 { 2071 PMD_FUNC(pmf, "hold_rele_power") 2072 int circ; 2073 2074 if ((dip == NULL) || 2075 (PM_GET_PM_INFO(dip) == NULL) || PM_ISBC(dip)) 2076 return; 2077 2078 PM_LOCK_POWER(dip, &circ); 2079 ASSERT(cnt >= 0 && PM_KUC(dip) >= 0 || cnt < 0 && PM_KUC(dip) > 0); 2080 PMD(PMD_KIDSUP, ("%s: kidsupcnt for %s@%s(%s#%d) %d->%d\n", pmf, 2081 PM_DEVICE(dip), PM_KUC(dip), (PM_KUC(dip) + cnt))) 2082 2083 PM_KUC(dip) += cnt; 2084 2085 ASSERT(PM_KUC(dip) >= 0); 2086 PM_UNLOCK_POWER(dip, circ); 2087 2088 if (cnt < 0 && PM_KUC(dip) == 0) 2089 pm_rescan(dip); 2090 } 2091 2092 #define MAX_PPM_HANDLERS 4 2093 2094 kmutex_t ppm_lock; /* in case we ever do multi-threaded startup */ 2095 2096 struct ppm_callbacks { 2097 int (*ppmc_func)(dev_info_t *); 2098 dev_info_t *ppmc_dip; 2099 } ppm_callbacks[MAX_PPM_HANDLERS + 1]; 2100 2101 2102 /* 2103 * This routine calls into all the registered ppms to notify them 2104 * that either all components of power-managed devices are at their 2105 * lowest levels or no longer all are at their lowest levels. 2106 */ 2107 static void 2108 pm_ppm_notify_all_lowest(dev_info_t *dip, int mode) 2109 { 2110 struct ppm_callbacks *ppmcp; 2111 power_req_t power_req; 2112 int result = 0; 2113 2114 power_req.request_type = PMR_PPM_ALL_LOWEST; 2115 power_req.req.ppm_all_lowest_req.mode = mode; 2116 mutex_enter(&ppm_lock); 2117 for (ppmcp = ppm_callbacks; ppmcp->ppmc_func; ppmcp++) 2118 (void) pm_ctlops((dev_info_t *)ppmcp->ppmc_dip, dip, 2119 DDI_CTLOPS_POWER, &power_req, &result); 2120 mutex_exit(&ppm_lock); 2121 if (mode == PM_ALL_LOWEST) { 2122 if (autoS3_enabled) { 2123 PMD(PMD_SX, ("pm_ppm_notify_all_lowest triggering " 2124 "autos3\n")) 2125 mutex_enter(&srn_clone_lock); 2126 if (srn_signal) { 2127 srn_inuse++; 2128 PMD(PMD_SX, ("(*srn_signal)(AUTOSX, 3)\n")) 2129 (*srn_signal)(SRN_TYPE_AUTOSX, 3); 2130 srn_inuse--; 2131 } else { 2132 PMD(PMD_SX, ("srn_signal NULL\n")) 2133 } 2134 mutex_exit(&srn_clone_lock); 2135 } else { 2136 PMD(PMD_SX, ("pm_ppm_notify_all_lowest autos3 " 2137 "disabled\n")); 2138 } 2139 } 2140 } 2141 2142 static void 2143 pm_set_pm_info(dev_info_t *dip, void *value) 2144 { 2145 DEVI(dip)->devi_pm_info = value; 2146 } 2147 2148 pm_rsvp_t *pm_blocked_list; 2149 2150 /* 2151 * Look up an entry in the blocked list by dip and component 2152 */ 2153 static pm_rsvp_t * 2154 pm_rsvp_lookup(dev_info_t *dip, int comp) 2155 { 2156 pm_rsvp_t *p; 2157 ASSERT(MUTEX_HELD(&pm_rsvp_lock)); 2158 for (p = pm_blocked_list; p; p = p->pr_next) 2159 if (p->pr_dip == dip && p->pr_comp == comp) { 2160 return (p); 2161 } 2162 return (NULL); 2163 } 2164 2165 /* 2166 * Called when a device which is direct power managed (or the parent or 2167 * dependent of such a device) changes power, or when a pm clone is closed 2168 * that was direct power managing a device. This call results in pm_blocked() 2169 * (below) returning. 2170 */ 2171 void 2172 pm_proceed(dev_info_t *dip, int cmd, int comp, int newlevel) 2173 { 2174 PMD_FUNC(pmf, "proceed") 2175 pm_rsvp_t *found = NULL; 2176 pm_rsvp_t *p; 2177 2178 mutex_enter(&pm_rsvp_lock); 2179 switch (cmd) { 2180 /* 2181 * we're giving up control, let any pending op continue 2182 */ 2183 case PMP_RELEASE: 2184 for (p = pm_blocked_list; p; p = p->pr_next) { 2185 if (dip == p->pr_dip) { 2186 p->pr_retval = PMP_RELEASE; 2187 PMD(PMD_DPM, ("%s: RELEASE %s@%s(%s#%d)\n", 2188 pmf, PM_DEVICE(dip))) 2189 cv_signal(&p->pr_cv); 2190 } 2191 } 2192 break; 2193 2194 /* 2195 * process has done PM_SET_CURRENT_POWER; let a matching request 2196 * succeed and a non-matching request for the same device fail 2197 */ 2198 case PMP_SETPOWER: 2199 found = pm_rsvp_lookup(dip, comp); 2200 if (!found) /* if driver not waiting */ 2201 break; 2202 /* 2203 * This cannot be pm_lower_power, since that can only happen 2204 * during detach or probe 2205 */ 2206 if (found->pr_newlevel <= newlevel) { 2207 found->pr_retval = PMP_SUCCEED; 2208 PMD(PMD_DPM, ("%s: SUCCEED %s@%s(%s#%d)\n", pmf, 2209 PM_DEVICE(dip))) 2210 } else { 2211 found->pr_retval = PMP_FAIL; 2212 PMD(PMD_DPM, ("%s: FAIL %s@%s(%s#%d)\n", pmf, 2213 PM_DEVICE(dip))) 2214 } 2215 cv_signal(&found->pr_cv); 2216 break; 2217 2218 default: 2219 panic("pm_proceed unknown cmd %d", cmd); 2220 } 2221 mutex_exit(&pm_rsvp_lock); 2222 } 2223 2224 /* 2225 * This routine dispatches new work to the dependency thread. Caller must 2226 * be prepared to block for memory if necessary. 2227 */ 2228 void 2229 pm_dispatch_to_dep_thread(int cmd, char *keeper, char *kept, int wait, 2230 int *res, int cached_pwr) 2231 { 2232 pm_dep_wk_t *new_work; 2233 2234 new_work = kmem_zalloc(sizeof (pm_dep_wk_t), KM_SLEEP); 2235 new_work->pdw_type = cmd; 2236 new_work->pdw_wait = wait; 2237 new_work->pdw_done = 0; 2238 new_work->pdw_ret = 0; 2239 new_work->pdw_pwr = cached_pwr; 2240 cv_init(&new_work->pdw_cv, NULL, CV_DEFAULT, NULL); 2241 if (keeper != NULL) { 2242 new_work->pdw_keeper = kmem_zalloc(strlen(keeper) + 1, 2243 KM_SLEEP); 2244 (void) strcpy(new_work->pdw_keeper, keeper); 2245 } 2246 if (kept != NULL) { 2247 new_work->pdw_kept = kmem_zalloc(strlen(kept) + 1, KM_SLEEP); 2248 (void) strcpy(new_work->pdw_kept, kept); 2249 } 2250 mutex_enter(&pm_dep_thread_lock); 2251 if (pm_dep_thread_workq == NULL) { 2252 pm_dep_thread_workq = new_work; 2253 pm_dep_thread_tail = new_work; 2254 new_work->pdw_next = NULL; 2255 } else { 2256 pm_dep_thread_tail->pdw_next = new_work; 2257 pm_dep_thread_tail = new_work; 2258 new_work->pdw_next = NULL; 2259 } 2260 cv_signal(&pm_dep_thread_cv); 2261 /* If caller asked for it, wait till it is done. */ 2262 if (wait) { 2263 while (!new_work->pdw_done) 2264 cv_wait(&new_work->pdw_cv, &pm_dep_thread_lock); 2265 /* 2266 * Pass return status, if any, back. 2267 */ 2268 if (res != NULL) 2269 *res = new_work->pdw_ret; 2270 /* 2271 * If we asked to wait, it is our job to free the request 2272 * structure. 2273 */ 2274 if (new_work->pdw_keeper) 2275 kmem_free(new_work->pdw_keeper, 2276 strlen(new_work->pdw_keeper) + 1); 2277 if (new_work->pdw_kept) 2278 kmem_free(new_work->pdw_kept, 2279 strlen(new_work->pdw_kept) + 1); 2280 kmem_free(new_work, sizeof (pm_dep_wk_t)); 2281 } 2282 mutex_exit(&pm_dep_thread_lock); 2283 } 2284 2285 /* 2286 * Release the pm resource for this device. 2287 */ 2288 void 2289 pm_rem_info(dev_info_t *dip) 2290 { 2291 PMD_FUNC(pmf, "rem_info") 2292 int i, count = 0; 2293 pm_info_t *info = PM_GET_PM_INFO(dip); 2294 dev_info_t *pdip = ddi_get_parent(dip); 2295 char *pathbuf; 2296 int work_type = PM_DEP_WK_DETACH; 2297 2298 ASSERT(info); 2299 2300 ASSERT(!PM_IAM_LOCKING_DIP(dip)); 2301 if (PM_ISDIRECT(dip)) { 2302 info->pmi_dev_pm_state &= ~PM_DIRECT; 2303 ASSERT(info->pmi_clone); 2304 info->pmi_clone = 0; 2305 pm_proceed(dip, PMP_RELEASE, -1, -1); 2306 } 2307 ASSERT(!PM_GET_PM_SCAN(dip)); 2308 2309 /* 2310 * Now adjust parent's kidsupcnt. BC nodes we check only comp 0, 2311 * Others we check all components. BC node that has already 2312 * called pm_destroy_components() has zero component count. 2313 * Parents that get notification are not adjusted because their 2314 * kidsupcnt is always 0 (or 1 during configuration). 2315 */ 2316 PMD(PMD_KEEPS, ("%s: %s@%s(%s#%d) has %d components\n", pmf, 2317 PM_DEVICE(dip), PM_NUMCMPTS(dip))) 2318 2319 /* node is detached, so we can examine power without locking */ 2320 if (PM_ISBC(dip)) { 2321 count = (PM_CURPOWER(dip, 0) != 0); 2322 } else { 2323 for (i = 0; i < PM_NUMCMPTS(dip); i++) 2324 count += (PM_CURPOWER(dip, i) != 0); 2325 } 2326 2327 if (PM_NUMCMPTS(dip) && pdip && !PM_WANTS_NOTIFICATION(pdip)) 2328 e_pm_hold_rele_power(pdip, -count); 2329 2330 /* Schedule a request to clean up dependency records */ 2331 pathbuf = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 2332 (void) ddi_pathname(dip, pathbuf); 2333 pm_dispatch_to_dep_thread(work_type, pathbuf, pathbuf, 2334 PM_DEP_NOWAIT, NULL, (count > 0)); 2335 kmem_free(pathbuf, MAXPATHLEN); 2336 2337 /* 2338 * Adjust the pm_comps_notlowest count since this device is 2339 * not being power-managed anymore. 2340 */ 2341 for (i = 0; i < PM_NUMCMPTS(dip); i++) { 2342 pm_component_t *cp = PM_CP(dip, i); 2343 if (cp->pmc_cur_pwr != 0) 2344 PM_DECR_NOTLOWEST(dip) 2345 } 2346 /* 2347 * Once we clear the info pointer, it looks like it is not power 2348 * managed to everybody else. 2349 */ 2350 pm_set_pm_info(dip, NULL); 2351 kmem_free(info, sizeof (pm_info_t)); 2352 } 2353 2354 int 2355 pm_get_norm_pwrs(dev_info_t *dip, int **valuep, size_t *length) 2356 { 2357 int components = PM_NUMCMPTS(dip); 2358 int *bufp; 2359 size_t size; 2360 int i; 2361 2362 if (components <= 0) { 2363 cmn_err(CE_NOTE, "!pm: %s@%s(%s#%d) has no components, " 2364 "can't get normal power values\n", PM_DEVICE(dip)); 2365 return (DDI_FAILURE); 2366 } else { 2367 size = components * sizeof (int); 2368 bufp = kmem_alloc(size, KM_SLEEP); 2369 for (i = 0; i < components; i++) { 2370 bufp[i] = pm_get_normal_power(dip, i); 2371 } 2372 } 2373 *length = size; 2374 *valuep = bufp; 2375 return (DDI_SUCCESS); 2376 } 2377 2378 static int 2379 pm_reset_timestamps(dev_info_t *dip, void *arg) 2380 { 2381 _NOTE(ARGUNUSED(arg)) 2382 2383 int components; 2384 int i; 2385 2386 if (!PM_GET_PM_INFO(dip)) 2387 return (DDI_WALK_CONTINUE); 2388 components = PM_NUMCMPTS(dip); 2389 ASSERT(components > 0); 2390 PM_LOCK_BUSY(dip); 2391 for (i = 0; i < components; i++) { 2392 struct pm_component *cp; 2393 /* 2394 * If the component was not marked as busy, 2395 * reset its timestamp to now. 2396 */ 2397 cp = PM_CP(dip, i); 2398 if (cp->pmc_timestamp) 2399 cp->pmc_timestamp = gethrestime_sec(); 2400 } 2401 PM_UNLOCK_BUSY(dip); 2402 return (DDI_WALK_CONTINUE); 2403 } 2404 2405 /* 2406 * Convert a power level to an index into the levels array (or 2407 * just PM_LEVEL_UNKNOWN in that special case). 2408 */ 2409 static int 2410 pm_level_to_index(dev_info_t *dip, pm_component_t *cp, int level) 2411 { 2412 PMD_FUNC(pmf, "level_to_index") 2413 int i; 2414 int limit = cp->pmc_comp.pmc_numlevels; 2415 int *ip = cp->pmc_comp.pmc_lvals; 2416 2417 if (level == PM_LEVEL_UNKNOWN) 2418 return (level); 2419 2420 for (i = 0; i < limit; i++) { 2421 if (level == *ip++) { 2422 PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d)[%d] to %x\n", 2423 pmf, PM_DEVICE(dip), 2424 (int)(cp - DEVI(dip)->devi_pm_components), level)) 2425 return (i); 2426 } 2427 } 2428 panic("pm_level_to_index: level %d not found for device " 2429 "%s@%s(%s#%d)", level, PM_DEVICE(dip)); 2430 /*NOTREACHED*/ 2431 } 2432 2433 /* 2434 * Internal function to set current power level 2435 */ 2436 static void 2437 e_pm_set_cur_pwr(dev_info_t *dip, pm_component_t *cp, int level) 2438 { 2439 PMD_FUNC(pmf, "set_cur_pwr") 2440 int curpwr = (cp->pmc_flags & PM_PHC_WHILE_SET_POWER ? 2441 cp->pmc_phc_pwr : cp->pmc_cur_pwr); 2442 2443 /* 2444 * Nothing to adjust if current & new levels are the same. 2445 */ 2446 if (curpwr != PM_LEVEL_UNKNOWN && 2447 level == cp->pmc_comp.pmc_lvals[curpwr]) 2448 return; 2449 2450 /* 2451 * Keep the count for comps doing transition to/from lowest 2452 * level. 2453 */ 2454 if (curpwr == 0) { 2455 PM_INCR_NOTLOWEST(dip); 2456 } else if (level == cp->pmc_comp.pmc_lvals[0]) { 2457 PM_DECR_NOTLOWEST(dip); 2458 } 2459 cp->pmc_phc_pwr = PM_LEVEL_UNKNOWN; 2460 cp->pmc_cur_pwr = pm_level_to_index(dip, cp, level); 2461 } 2462 2463 static int pm_phc_impl(dev_info_t *, int, int, int); 2464 2465 /* 2466 * This is the default method of setting the power of a device if no ppm 2467 * driver has claimed it. 2468 */ 2469 int 2470 pm_power(dev_info_t *dip, int comp, int level) 2471 { 2472 PMD_FUNC(pmf, "power") 2473 struct dev_ops *ops; 2474 int (*fn)(dev_info_t *, int, int); 2475 struct pm_component *cp = PM_CP(dip, comp); 2476 int retval; 2477 pm_info_t *info = PM_GET_PM_INFO(dip); 2478 2479 PMD(PMD_KIDSUP, ("%s: %s@%s(%s#%d), comp=%d, level=%d\n", pmf, 2480 PM_DEVICE(dip), comp, level)) 2481 if (!(ops = ddi_get_driver(dip))) { 2482 PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) has no ops\n", pmf, 2483 PM_DEVICE(dip))) 2484 return (DDI_FAILURE); 2485 } 2486 if ((ops->devo_rev < 2) || !(fn = ops->devo_power)) { 2487 PMD(PMD_FAIL, ("%s: %s%s\n", pmf, 2488 (ops->devo_rev < 2 ? " wrong devo_rev" : ""), 2489 (!fn ? " devo_power NULL" : ""))) 2490 return (DDI_FAILURE); 2491 } 2492 cp->pmc_flags |= PM_POWER_OP; 2493 retval = (*fn)(dip, comp, level); 2494 cp->pmc_flags &= ~PM_POWER_OP; 2495 if (retval == DDI_SUCCESS) { 2496 e_pm_set_cur_pwr(dip, PM_CP(dip, comp), level); 2497 return (DDI_SUCCESS); 2498 } 2499 2500 /* 2501 * If pm_power_has_changed() detected a deadlock with pm_power() it 2502 * updated only the power level of the component. If our attempt to 2503 * set the device new to a power level above has failed we sync the 2504 * total power state via phc code now. 2505 */ 2506 if (cp->pmc_flags & PM_PHC_WHILE_SET_POWER) { 2507 int phc_lvl = 2508 cp->pmc_comp.pmc_lvals[cp->pmc_cur_pwr]; 2509 2510 ASSERT(info); 2511 (void) pm_phc_impl(dip, comp, phc_lvl, 0); 2512 PMD(PMD_PHC, ("%s: phc %s@%s(%s#%d) comp=%d level=%d\n", 2513 pmf, PM_DEVICE(dip), comp, phc_lvl)) 2514 } 2515 2516 PMD(PMD_FAIL, ("%s: can't set comp=%d (%s) of %s@%s(%s#%d) to " 2517 "level=%d (%s)\n", pmf, comp, cp->pmc_comp.pmc_name, PM_DEVICE(dip), 2518 level, power_val_to_string(cp, level))); 2519 return (DDI_FAILURE); 2520 } 2521 2522 int 2523 pm_unmanage(dev_info_t *dip) 2524 { 2525 PMD_FUNC(pmf, "unmanage") 2526 power_req_t power_req; 2527 int result, retval = 0; 2528 2529 ASSERT(!PM_IAM_LOCKING_DIP(dip)); 2530 PMD(PMD_REMDEV | PMD_KIDSUP, ("%s: %s@%s(%s#%d)\n", pmf, 2531 PM_DEVICE(dip))) 2532 power_req.request_type = PMR_PPM_UNMANAGE; 2533 power_req.req.ppm_config_req.who = dip; 2534 if (pm_ppm_claimed(dip)) 2535 retval = pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, 2536 &power_req, &result); 2537 #ifdef DEBUG 2538 else 2539 retval = pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, 2540 &power_req, &result); 2541 #endif 2542 ASSERT(retval == DDI_SUCCESS); 2543 pm_rem_info(dip); 2544 return (retval); 2545 } 2546 2547 int 2548 pm_raise_power(dev_info_t *dip, int comp, int level) 2549 { 2550 if (level < 0) 2551 return (DDI_FAILURE); 2552 if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, NULL) || 2553 !e_pm_valid_power(dip, comp, level)) 2554 return (DDI_FAILURE); 2555 2556 return (dev_is_needed(dip, comp, level, PM_LEVEL_UPONLY)); 2557 } 2558 2559 int 2560 pm_lower_power(dev_info_t *dip, int comp, int level) 2561 { 2562 PMD_FUNC(pmf, "pm_lower_power") 2563 2564 if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, NULL) || 2565 !e_pm_valid_power(dip, comp, level)) { 2566 PMD(PMD_FAIL, ("%s: validation checks failed for %s@%s(%s#%d) " 2567 "comp=%d level=%d\n", pmf, PM_DEVICE(dip), comp, level)) 2568 return (DDI_FAILURE); 2569 } 2570 2571 if (!DEVI_IS_DETACHING(dip)) { 2572 PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) not detaching\n", 2573 pmf, PM_DEVICE(dip))) 2574 return (DDI_FAILURE); 2575 } 2576 2577 /* 2578 * If we don't care about saving power, or we're treating this node 2579 * specially, then this is a no-op 2580 */ 2581 if (!PM_SCANABLE(dip) || pm_noinvol(dip)) { 2582 PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) %s%s%s%s\n", 2583 pmf, PM_DEVICE(dip), 2584 !autopm_enabled ? "!autopm_enabled " : "", 2585 !PM_POLLING_CPUPM ? "!cpupm_polling " : "", 2586 PM_CPUPM_DISABLED ? "cpupm_disabled " : "", 2587 pm_noinvol(dip) ? "pm_noinvol()" : "")) 2588 return (DDI_SUCCESS); 2589 } 2590 2591 if (dev_is_needed(dip, comp, level, PM_LEVEL_DOWNONLY) != DDI_SUCCESS) { 2592 PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) dev_is_needed failed\n", pmf, 2593 PM_DEVICE(dip))) 2594 return (DDI_FAILURE); 2595 } 2596 return (DDI_SUCCESS); 2597 } 2598 2599 /* 2600 * Find the entries struct for a given dip in the blocked list, return it locked 2601 */ 2602 static psce_t * 2603 pm_psc_dip_to_direct(dev_info_t *dip, pscc_t **psccp) 2604 { 2605 pscc_t *p; 2606 psce_t *psce; 2607 2608 rw_enter(&pm_pscc_direct_rwlock, RW_READER); 2609 for (p = pm_pscc_direct; p; p = p->pscc_next) { 2610 if (p->pscc_dip == dip) { 2611 *psccp = p; 2612 psce = p->pscc_entries; 2613 mutex_enter(&psce->psce_lock); 2614 ASSERT(psce); 2615 rw_exit(&pm_pscc_direct_rwlock); 2616 return (psce); 2617 } 2618 } 2619 rw_exit(&pm_pscc_direct_rwlock); 2620 panic("sunpm: no entry for dip %p in direct list", (void *)dip); 2621 /*NOTREACHED*/ 2622 } 2623 2624 /* 2625 * Write an entry indicating a power level change (to be passed to a process 2626 * later) in the given psce. 2627 * If we were called in the path that brings up the console fb in the 2628 * case of entering the prom, we don't want to sleep. If the alloc fails, then 2629 * we create a record that has a size of -1, a physaddr of NULL, and that 2630 * has the overflow flag set. 2631 */ 2632 static int 2633 psc_entry(ushort_t event, psce_t *psce, dev_info_t *dip, int comp, int new, 2634 int old, int which, pm_canblock_t canblock) 2635 { 2636 char buf[MAXNAMELEN]; 2637 pm_state_change_t *p; 2638 size_t size; 2639 caddr_t physpath = NULL; 2640 int overrun = 0; 2641 2642 ASSERT(MUTEX_HELD(&psce->psce_lock)); 2643 (void) ddi_pathname(dip, buf); 2644 size = strlen(buf) + 1; 2645 p = psce->psce_in; 2646 if (canblock == PM_CANBLOCK_BYPASS) { 2647 physpath = kmem_alloc(size, KM_NOSLEEP); 2648 if (physpath == NULL) { 2649 /* 2650 * mark current entry as overrun 2651 */ 2652 p->flags |= PSC_EVENT_LOST; 2653 size = (size_t)-1; 2654 } 2655 } else 2656 physpath = kmem_alloc(size, KM_SLEEP); 2657 if (p->size) { /* overflow; mark the next entry */ 2658 if (p->size != (size_t)-1) 2659 kmem_free(p->physpath, p->size); 2660 ASSERT(psce->psce_out == p); 2661 if (p == psce->psce_last) { 2662 psce->psce_first->flags |= PSC_EVENT_LOST; 2663 psce->psce_out = psce->psce_first; 2664 } else { 2665 (p + 1)->flags |= PSC_EVENT_LOST; 2666 psce->psce_out = (p + 1); 2667 } 2668 overrun++; 2669 } else if (physpath == NULL) { /* alloc failed, mark this entry */ 2670 p->flags |= PSC_EVENT_LOST; 2671 p->size = 0; 2672 p->physpath = NULL; 2673 } 2674 if (which == PSC_INTEREST) { 2675 mutex_enter(&pm_compcnt_lock); 2676 if (pm_comps_notlowest == 0) 2677 p->flags |= PSC_ALL_LOWEST; 2678 else 2679 p->flags &= ~PSC_ALL_LOWEST; 2680 mutex_exit(&pm_compcnt_lock); 2681 } 2682 p->event = event; 2683 p->timestamp = gethrestime_sec(); 2684 p->component = comp; 2685 p->old_level = old; 2686 p->new_level = new; 2687 p->physpath = physpath; 2688 p->size = size; 2689 if (physpath != NULL) 2690 (void) strcpy(p->physpath, buf); 2691 if (p == psce->psce_last) 2692 psce->psce_in = psce->psce_first; 2693 else 2694 psce->psce_in = ++p; 2695 mutex_exit(&psce->psce_lock); 2696 return (overrun); 2697 } 2698 2699 /* 2700 * Find the next entry on the interest list. We keep a pointer to the item we 2701 * last returned in the user's cooke. Returns a locked entries struct. 2702 */ 2703 static psce_t * 2704 psc_interest(void **cookie, pscc_t **psccp) 2705 { 2706 pscc_t *pscc; 2707 pscc_t **cookiep = (pscc_t **)cookie; 2708 2709 if (*cookiep == NULL) 2710 pscc = pm_pscc_interest; 2711 else 2712 pscc = (*cookiep)->pscc_next; 2713 if (pscc) { 2714 *cookiep = pscc; 2715 *psccp = pscc; 2716 mutex_enter(&pscc->pscc_entries->psce_lock); 2717 return (pscc->pscc_entries); 2718 } else { 2719 return (NULL); 2720 } 2721 } 2722 2723 /* 2724 * Create an entry for a process to pick up indicating a power level change. 2725 */ 2726 static void 2727 pm_enqueue_notify(ushort_t cmd, dev_info_t *dip, int comp, 2728 int newlevel, int oldlevel, pm_canblock_t canblock) 2729 { 2730 PMD_FUNC(pmf, "enqueue_notify") 2731 pscc_t *pscc; 2732 psce_t *psce; 2733 void *cookie = NULL; 2734 int overrun; 2735 2736 ASSERT(MUTEX_HELD(&pm_rsvp_lock)); 2737 switch (cmd) { 2738 case PSC_PENDING_CHANGE: /* only for controlling process */ 2739 PMD(PMD_DPM, ("%s: PENDING %s@%s(%s#%d), comp %d, %d -> %d\n", 2740 pmf, PM_DEVICE(dip), comp, oldlevel, newlevel)) 2741 psce = pm_psc_dip_to_direct(dip, &pscc); 2742 ASSERT(psce); 2743 PMD(PMD_IOCTL, ("%s: PENDING: %s@%s(%s#%d) pm_poll_cnt[%d] " 2744 "%d\n", pmf, PM_DEVICE(dip), pscc->pscc_clone, 2745 pm_poll_cnt[pscc->pscc_clone])) 2746 overrun = psc_entry(cmd, psce, dip, comp, newlevel, oldlevel, 2747 PSC_DIRECT, canblock); 2748 PMD(PMD_DPM, ("%s: sig %d\n", pmf, pscc->pscc_clone)) 2749 mutex_enter(&pm_clone_lock); 2750 if (!overrun) 2751 pm_poll_cnt[pscc->pscc_clone]++; 2752 cv_signal(&pm_clones_cv[pscc->pscc_clone]); 2753 pollwakeup(&pm_pollhead, (POLLRDNORM | POLLIN)); 2754 mutex_exit(&pm_clone_lock); 2755 break; 2756 case PSC_HAS_CHANGED: 2757 PMD(PMD_DPM, ("%s: HAS %s@%s(%s#%d), comp %d, %d -> %d\n", 2758 pmf, PM_DEVICE(dip), comp, oldlevel, newlevel)) 2759 if (PM_ISDIRECT(dip) && canblock != PM_CANBLOCK_BYPASS) { 2760 psce = pm_psc_dip_to_direct(dip, &pscc); 2761 PMD(PMD_IOCTL, ("%s: HAS: %s@%s(%s#%d) pm_poll_cnt[%d] " 2762 "%d\n", pmf, PM_DEVICE(dip), pscc->pscc_clone, 2763 pm_poll_cnt[pscc->pscc_clone])) 2764 overrun = psc_entry(cmd, psce, dip, comp, newlevel, 2765 oldlevel, PSC_DIRECT, canblock); 2766 PMD(PMD_DPM, ("%s: sig %d\n", pmf, pscc->pscc_clone)) 2767 mutex_enter(&pm_clone_lock); 2768 if (!overrun) 2769 pm_poll_cnt[pscc->pscc_clone]++; 2770 cv_signal(&pm_clones_cv[pscc->pscc_clone]); 2771 pollwakeup(&pm_pollhead, (POLLRDNORM | POLLIN)); 2772 mutex_exit(&pm_clone_lock); 2773 } 2774 mutex_enter(&pm_clone_lock); 2775 rw_enter(&pm_pscc_interest_rwlock, RW_READER); 2776 while ((psce = psc_interest(&cookie, &pscc)) != NULL) { 2777 (void) psc_entry(cmd, psce, dip, comp, newlevel, 2778 oldlevel, PSC_INTEREST, canblock); 2779 cv_signal(&pm_clones_cv[pscc->pscc_clone]); 2780 } 2781 rw_exit(&pm_pscc_interest_rwlock); 2782 mutex_exit(&pm_clone_lock); 2783 break; 2784 #ifdef DEBUG 2785 default: 2786 ASSERT(0); 2787 #endif 2788 } 2789 } 2790 2791 static void 2792 pm_enqueue_notify_others(pm_ppm_devlist_t **listp, pm_canblock_t canblock) 2793 { 2794 if (listp) { 2795 pm_ppm_devlist_t *p, *next = NULL; 2796 2797 for (p = *listp; p; p = next) { 2798 next = p->ppd_next; 2799 pm_enqueue_notify(PSC_HAS_CHANGED, p->ppd_who, 2800 p->ppd_cmpt, p->ppd_new_level, p->ppd_old_level, 2801 canblock); 2802 kmem_free(p, sizeof (pm_ppm_devlist_t)); 2803 } 2804 *listp = NULL; 2805 } 2806 } 2807 2808 /* 2809 * Try to get the power locks of the parent node and target (child) 2810 * node. Return true if successful (with both locks held) or false 2811 * (with no locks held). 2812 */ 2813 static int 2814 pm_try_parent_child_locks(dev_info_t *pdip, 2815 dev_info_t *dip, int *pcircp, int *circp) 2816 { 2817 if (ndi_devi_tryenter(pdip, pcircp)) 2818 if (PM_TRY_LOCK_POWER(dip, circp)) { 2819 return (1); 2820 } else { 2821 ndi_devi_exit(pdip, *pcircp); 2822 } 2823 return (0); 2824 } 2825 2826 /* 2827 * Determine if the power lock owner is blocked by current thread. 2828 * returns : 2829 * 1 - If the thread owning the effective power lock (the first lock on 2830 * which a thread blocks when it does PM_LOCK_POWER) is blocked by 2831 * a mutex held by the current thread. 2832 * 2833 * 0 - otherwise 2834 * 2835 * Note : This function is called by pm_power_has_changed to determine whether 2836 * it is executing in parallel with pm_set_power. 2837 */ 2838 static int 2839 pm_blocked_by_us(dev_info_t *dip) 2840 { 2841 power_req_t power_req; 2842 kthread_t *owner; 2843 int result; 2844 kmutex_t *mp; 2845 dev_info_t *ppm = (dev_info_t *)DEVI(dip)->devi_pm_ppm; 2846 2847 power_req.request_type = PMR_PPM_POWER_LOCK_OWNER; 2848 power_req.req.ppm_power_lock_owner_req.who = dip; 2849 if (pm_ctlops(ppm, dip, DDI_CTLOPS_POWER, &power_req, &result) != 2850 DDI_SUCCESS) { 2851 /* 2852 * It is assumed that if the device is claimed by ppm, ppm 2853 * will always implement this request type and it'll always 2854 * return success. We panic here, if it fails. 2855 */ 2856 panic("pm: Can't determine power lock owner of %s@%s(%s#%d)\n", 2857 PM_DEVICE(dip)); 2858 /*NOTREACHED*/ 2859 } 2860 2861 if ((owner = power_req.req.ppm_power_lock_owner_req.owner) != NULL && 2862 owner->t_state == TS_SLEEP && 2863 owner->t_sobj_ops && 2864 SOBJ_TYPE(owner->t_sobj_ops) == SOBJ_MUTEX && 2865 (mp = (kmutex_t *)owner->t_wchan) && 2866 mutex_owner(mp) == curthread) 2867 return (1); 2868 2869 return (0); 2870 } 2871 2872 /* 2873 * Notify parent which wants to hear about a child's power changes. 2874 */ 2875 static void 2876 pm_notify_parent(dev_info_t *dip, 2877 dev_info_t *pdip, int comp, int old_level, int level) 2878 { 2879 pm_bp_has_changed_t bphc; 2880 pm_sp_misc_t pspm; 2881 char *pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 2882 int result = DDI_SUCCESS; 2883 2884 bphc.bphc_dip = dip; 2885 bphc.bphc_path = ddi_pathname(dip, pathbuf); 2886 bphc.bphc_comp = comp; 2887 bphc.bphc_olevel = old_level; 2888 bphc.bphc_nlevel = level; 2889 pspm.pspm_canblock = PM_CANBLOCK_BLOCK; 2890 pspm.pspm_scan = 0; 2891 bphc.bphc_private = &pspm; 2892 (void) (*PM_BUS_POWER_FUNC(pdip))(pdip, NULL, 2893 BUS_POWER_HAS_CHANGED, (void *)&bphc, (void *)&result); 2894 kmem_free(pathbuf, MAXPATHLEN); 2895 } 2896 2897 /* 2898 * Check if we need to resume a BC device, and make the attach call as required. 2899 */ 2900 static int 2901 pm_check_and_resume(dev_info_t *dip, int comp, int old_level, int level) 2902 { 2903 int ret = DDI_SUCCESS; 2904 2905 if (PM_ISBC(dip) && comp == 0 && old_level == 0 && level != 0) { 2906 ASSERT(DEVI(dip)->devi_pm_flags & PMC_SUSPENDED); 2907 /* ppm is not interested in DDI_PM_RESUME */ 2908 if ((ret = devi_attach(dip, DDI_PM_RESUME)) != DDI_SUCCESS) 2909 /* XXX Should we mark it resumed, */ 2910 /* even though it failed? */ 2911 cmn_err(CE_WARN, "!pm: Can't resume %s@%s", 2912 PM_NAME(dip), PM_ADDR(dip)); 2913 DEVI(dip)->devi_pm_flags &= ~PMC_SUSPENDED; 2914 } 2915 2916 return (ret); 2917 } 2918 2919 /* 2920 * Tests outside the lock to see if we should bother to enqueue an entry 2921 * for any watching process. If yes, then caller will take the lock and 2922 * do the full protocol 2923 */ 2924 static int 2925 pm_watchers() 2926 { 2927 if (pm_processes_stopped) 2928 return (0); 2929 return (pm_pscc_direct || pm_pscc_interest); 2930 } 2931 2932 static int pm_phc_impl(dev_info_t *, int, int, int); 2933 2934 /* 2935 * A driver is reporting that the power of one of its device's components 2936 * has changed. Update the power state accordingly. 2937 */ 2938 int 2939 pm_power_has_changed(dev_info_t *dip, int comp, int level) 2940 { 2941 PMD_FUNC(pmf, "pm_power_has_changed") 2942 int ret; 2943 dev_info_t *pdip = ddi_get_parent(dip); 2944 struct pm_component *cp; 2945 int blocked, circ, pcirc, old_level; 2946 2947 if (level < 0) { 2948 PMD(PMD_FAIL, ("%s: %s@%s(%s#%d): bad level=%d\n", pmf, 2949 PM_DEVICE(dip), level)) 2950 return (DDI_FAILURE); 2951 } 2952 2953 PMD(PMD_KIDSUP | PMD_DEP, ("%s: %s@%s(%s#%d), comp=%d, level=%d\n", pmf, 2954 PM_DEVICE(dip), comp, level)) 2955 2956 if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, &cp) || 2957 !e_pm_valid_power(dip, comp, level)) 2958 return (DDI_FAILURE); 2959 2960 /* 2961 * A driver thread calling pm_power_has_changed and another thread 2962 * calling pm_set_power can deadlock. The problem is not resolvable 2963 * by changing lock order, so we use pm_blocked_by_us() to detect 2964 * this specific deadlock. If we can't get the lock immediately 2965 * and we are deadlocked, just update the component's level, do 2966 * notifications, and return. We intend to update the total power 2967 * state later (if the other thread fails to set power to the 2968 * desired level). If we were called because of a power change on a 2969 * component that isn't involved in a set_power op, update all state 2970 * immediately. 2971 */ 2972 cp = PM_CP(dip, comp); 2973 while (!pm_try_parent_child_locks(pdip, dip, &pcirc, &circ)) { 2974 if (((blocked = pm_blocked_by_us(dip)) != 0) && 2975 (cp->pmc_flags & PM_POWER_OP)) { 2976 if (pm_watchers()) { 2977 mutex_enter(&pm_rsvp_lock); 2978 pm_enqueue_notify(PSC_HAS_CHANGED, dip, comp, 2979 level, cur_power(cp), PM_CANBLOCK_BLOCK); 2980 mutex_exit(&pm_rsvp_lock); 2981 } 2982 if (pdip && PM_WANTS_NOTIFICATION(pdip)) 2983 pm_notify_parent(dip, 2984 pdip, comp, cur_power(cp), level); 2985 (void) pm_check_and_resume(dip, 2986 comp, cur_power(cp), level); 2987 2988 /* 2989 * Stash the old power index, update curpwr, and flag 2990 * that the total power state needs to be synched. 2991 */ 2992 cp->pmc_flags |= PM_PHC_WHILE_SET_POWER; 2993 /* 2994 * Several pm_power_has_changed calls could arrive 2995 * while the set power path remains blocked. Keep the 2996 * oldest old power and the newest new power of any 2997 * sequence of phc calls which arrive during deadlock. 2998 */ 2999 if (cp->pmc_phc_pwr == PM_LEVEL_UNKNOWN) 3000 cp->pmc_phc_pwr = cp->pmc_cur_pwr; 3001 cp->pmc_cur_pwr = 3002 pm_level_to_index(dip, cp, level); 3003 PMD(PMD_PHC, ("%s: deadlock for %s@%s(%s#%d), comp=%d, " 3004 "level=%d\n", pmf, PM_DEVICE(dip), comp, level)) 3005 return (DDI_SUCCESS); 3006 } else 3007 if (blocked) { /* blocked, but different cmpt? */ 3008 if (!ndi_devi_tryenter(pdip, &pcirc)) { 3009 cmn_err(CE_NOTE, 3010 "!pm: parent kuc not updated due " 3011 "to possible deadlock.\n"); 3012 return (pm_phc_impl(dip, 3013 comp, level, 1)); 3014 } 3015 old_level = cur_power(cp); 3016 if (pdip && !PM_WANTS_NOTIFICATION(pdip) && 3017 (!PM_ISBC(dip) || comp == 0) && 3018 POWERING_ON(old_level, level)) 3019 pm_hold_power(pdip); 3020 ret = pm_phc_impl(dip, comp, level, 1); 3021 if (pdip && !PM_WANTS_NOTIFICATION(pdip)) { 3022 if ((!PM_ISBC(dip) || 3023 comp == 0) && level == 0 && 3024 old_level != PM_LEVEL_UNKNOWN) 3025 pm_rele_power(pdip); 3026 } 3027 ndi_devi_exit(pdip, pcirc); 3028 /* child lock not held: deadlock */ 3029 return (ret); 3030 } 3031 delay(1); 3032 PMD(PMD_PHC, ("%s: try lock again\n", pmf)) 3033 } 3034 3035 /* non-deadlock case */ 3036 old_level = cur_power(cp); 3037 if (pdip && !PM_WANTS_NOTIFICATION(pdip) && 3038 (!PM_ISBC(dip) || comp == 0) && POWERING_ON(old_level, level)) 3039 pm_hold_power(pdip); 3040 ret = pm_phc_impl(dip, comp, level, 1); 3041 if (pdip && !PM_WANTS_NOTIFICATION(pdip)) { 3042 if ((!PM_ISBC(dip) || comp == 0) && level == 0 && 3043 old_level != PM_LEVEL_UNKNOWN) 3044 pm_rele_power(pdip); 3045 } 3046 PM_UNLOCK_POWER(dip, circ); 3047 ndi_devi_exit(pdip, pcirc); 3048 return (ret); 3049 } 3050 3051 /* 3052 * Account for power changes to a component of the the console frame buffer. 3053 * If lowering power from full (or "unkown", which is treatd as full) 3054 * we will increment the "components off" count of the fb device. 3055 * Subsequent lowering of the same component doesn't affect the count. If 3056 * raising a component back to full power, we will decrement the count. 3057 * 3058 * Return: the increment value for pm_cfb_comps_off (-1, 0, or 1) 3059 */ 3060 static int 3061 calc_cfb_comps_incr(dev_info_t *dip, int cmpt, int old, int new) 3062 { 3063 struct pm_component *cp = PM_CP(dip, cmpt); 3064 int on = (old == PM_LEVEL_UNKNOWN || old == cp->pmc_norm_pwr); 3065 int want_normal = (new == cp->pmc_norm_pwr); 3066 int incr = 0; 3067 3068 if (on && !want_normal) 3069 incr = 1; 3070 else if (!on && want_normal) 3071 incr = -1; 3072 return (incr); 3073 } 3074 3075 /* 3076 * Adjust the count of console frame buffer components < full power. 3077 */ 3078 static void 3079 update_comps_off(int incr, dev_info_t *dip) 3080 { 3081 mutex_enter(&pm_cfb_lock); 3082 pm_cfb_comps_off += incr; 3083 ASSERT(pm_cfb_comps_off <= PM_NUMCMPTS(dip)); 3084 mutex_exit(&pm_cfb_lock); 3085 } 3086 3087 /* 3088 * Update the power state in the framework (via the ppm). The 'notify' 3089 * argument tells whether to notify watchers. Power lock is already held. 3090 */ 3091 static int 3092 pm_phc_impl(dev_info_t *dip, int comp, int level, int notify) 3093 { 3094 PMD_FUNC(pmf, "phc_impl") 3095 power_req_t power_req; 3096 int i, dodeps = 0; 3097 dev_info_t *pdip = ddi_get_parent(dip); 3098 int result; 3099 int old_level; 3100 struct pm_component *cp; 3101 int incr = 0; 3102 dev_info_t *ppm = (dev_info_t *)DEVI(dip)->devi_pm_ppm; 3103 int work_type = 0; 3104 char *pathbuf; 3105 3106 /* Must use "official" power level for this test. */ 3107 cp = PM_CP(dip, comp); 3108 old_level = (cp->pmc_flags & PM_PHC_WHILE_SET_POWER ? 3109 cp->pmc_phc_pwr : cp->pmc_cur_pwr); 3110 if (old_level != PM_LEVEL_UNKNOWN) 3111 old_level = cp->pmc_comp.pmc_lvals[old_level]; 3112 3113 if (level == old_level) { 3114 PMD(PMD_SET, ("%s: %s@%s(%s#%d), comp=%d is already at " 3115 "level=%d\n", pmf, PM_DEVICE(dip), comp, level)) 3116 return (DDI_SUCCESS); 3117 } 3118 3119 /* 3120 * Tell ppm about this. 3121 */ 3122 power_req.request_type = PMR_PPM_POWER_CHANGE_NOTIFY; 3123 power_req.req.ppm_notify_level_req.who = dip; 3124 power_req.req.ppm_notify_level_req.cmpt = comp; 3125 power_req.req.ppm_notify_level_req.new_level = level; 3126 power_req.req.ppm_notify_level_req.old_level = old_level; 3127 if (pm_ctlops(ppm, dip, DDI_CTLOPS_POWER, &power_req, 3128 &result) == DDI_FAILURE) { 3129 PMD(PMD_FAIL, ("%s: pm_ctlops %s@%s(%s#%d) to %d failed\n", 3130 pmf, PM_DEVICE(dip), level)) 3131 return (DDI_FAILURE); 3132 } 3133 3134 if (PM_IS_CFB(dip)) { 3135 incr = calc_cfb_comps_incr(dip, comp, old_level, level); 3136 3137 if (incr) { 3138 update_comps_off(incr, dip); 3139 PMD(PMD_CFB, ("%s: %s@%s(%s#%d) comp=%d %d->%d " 3140 "cfb_comps_off->%d\n", pmf, PM_DEVICE(dip), 3141 comp, old_level, level, pm_cfb_comps_off)) 3142 } 3143 } 3144 e_pm_set_cur_pwr(dip, PM_CP(dip, comp), level); 3145 result = DDI_SUCCESS; 3146 3147 if (notify) { 3148 if (pdip && PM_WANTS_NOTIFICATION(pdip)) 3149 pm_notify_parent(dip, pdip, comp, old_level, level); 3150 (void) pm_check_and_resume(dip, comp, old_level, level); 3151 } 3152 3153 /* 3154 * Decrement the dependency kidsup count if we turn a device 3155 * off. 3156 */ 3157 if (POWERING_OFF(old_level, level)) { 3158 dodeps = 1; 3159 for (i = 0; i < PM_NUMCMPTS(dip); i++) { 3160 cp = PM_CP(dip, i); 3161 if (cur_power(cp)) { 3162 dodeps = 0; 3163 break; 3164 } 3165 } 3166 if (dodeps) 3167 work_type = PM_DEP_WK_POWER_OFF; 3168 } 3169 3170 /* 3171 * Increment if we turn it on. Check to see 3172 * if other comps are already on, if so, 3173 * dont increment. 3174 */ 3175 if (POWERING_ON(old_level, level)) { 3176 dodeps = 1; 3177 for (i = 0; i < PM_NUMCMPTS(dip); i++) { 3178 cp = PM_CP(dip, i); 3179 if (comp == i) 3180 continue; 3181 /* -1 also treated as 0 in this case */ 3182 if (cur_power(cp) > 0) { 3183 dodeps = 0; 3184 break; 3185 } 3186 } 3187 if (dodeps) 3188 work_type = PM_DEP_WK_POWER_ON; 3189 } 3190 3191 if (dodeps) { 3192 pathbuf = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 3193 (void) ddi_pathname(dip, pathbuf); 3194 pm_dispatch_to_dep_thread(work_type, pathbuf, NULL, 3195 PM_DEP_NOWAIT, NULL, 0); 3196 kmem_free(pathbuf, MAXPATHLEN); 3197 } 3198 3199 if (notify && (level != old_level) && pm_watchers()) { 3200 mutex_enter(&pm_rsvp_lock); 3201 pm_enqueue_notify(PSC_HAS_CHANGED, dip, comp, level, old_level, 3202 PM_CANBLOCK_BLOCK); 3203 mutex_exit(&pm_rsvp_lock); 3204 } 3205 3206 PMD(PMD_RESCAN, ("%s: %s@%s(%s#%d): pm_rescan\n", pmf, PM_DEVICE(dip))) 3207 pm_rescan(dip); 3208 return (DDI_SUCCESS); 3209 } 3210 3211 /* 3212 * This function is called at startup time to notify pm of the existence 3213 * of any platform power managers for this platform. As a result of 3214 * this registration, each function provided will be called each time 3215 * a device node is attached, until one returns true, and it must claim the 3216 * device node (by returning non-zero) if it wants to be involved in the 3217 * node's power management. If it does claim the node, then it will 3218 * subsequently be notified of attach and detach events. 3219 * 3220 */ 3221 3222 int 3223 pm_register_ppm(int (*func)(dev_info_t *), dev_info_t *dip) 3224 { 3225 PMD_FUNC(pmf, "register_ppm") 3226 struct ppm_callbacks *ppmcp; 3227 pm_component_t *cp; 3228 int i, pwr, result, circ; 3229 power_req_t power_req; 3230 struct ppm_notify_level_req *p = &power_req.req.ppm_notify_level_req; 3231 void pm_ppm_claim(dev_info_t *); 3232 3233 mutex_enter(&ppm_lock); 3234 ppmcp = ppm_callbacks; 3235 for (i = 0; i < MAX_PPM_HANDLERS; i++, ppmcp++) { 3236 if (ppmcp->ppmc_func == NULL) { 3237 ppmcp->ppmc_func = func; 3238 ppmcp->ppmc_dip = dip; 3239 break; 3240 } 3241 } 3242 mutex_exit(&ppm_lock); 3243 3244 if (i >= MAX_PPM_HANDLERS) 3245 return (DDI_FAILURE); 3246 while ((dip = ddi_get_parent(dip)) != NULL) { 3247 if (dip != ddi_root_node() && PM_GET_PM_INFO(dip) == NULL) 3248 continue; 3249 pm_ppm_claim(dip); 3250 /* don't bother with the not power-manageable nodes */ 3251 if (pm_ppm_claimed(dip) && PM_GET_PM_INFO(dip)) { 3252 /* 3253 * Tell ppm about this. 3254 */ 3255 power_req.request_type = PMR_PPM_POWER_CHANGE_NOTIFY; 3256 p->old_level = PM_LEVEL_UNKNOWN; 3257 p->who = dip; 3258 PM_LOCK_POWER(dip, &circ); 3259 for (i = 0; i < PM_NUMCMPTS(dip); i++) { 3260 cp = PM_CP(dip, i); 3261 pwr = cp->pmc_cur_pwr; 3262 if (pwr != PM_LEVEL_UNKNOWN) { 3263 p->cmpt = i; 3264 p->new_level = cur_power(cp); 3265 p->old_level = PM_LEVEL_UNKNOWN; 3266 if (pm_ctlops(PPM(dip), dip, 3267 DDI_CTLOPS_POWER, &power_req, 3268 &result) == DDI_FAILURE) { 3269 PMD(PMD_FAIL, ("%s: pc " 3270 "%s@%s(%s#%d) to %d " 3271 "fails\n", pmf, 3272 PM_DEVICE(dip), pwr)) 3273 } 3274 } 3275 } 3276 PM_UNLOCK_POWER(dip, circ); 3277 } 3278 } 3279 return (DDI_SUCCESS); 3280 } 3281 3282 /* 3283 * Call the ppm's that have registered and adjust the devinfo struct as 3284 * appropriate. First one to claim it gets it. The sets of devices claimed 3285 * by each ppm are assumed to be disjoint. 3286 */ 3287 void 3288 pm_ppm_claim(dev_info_t *dip) 3289 { 3290 struct ppm_callbacks *ppmcp; 3291 3292 if (PPM(dip)) { 3293 return; 3294 } 3295 mutex_enter(&ppm_lock); 3296 for (ppmcp = ppm_callbacks; ppmcp->ppmc_func; ppmcp++) { 3297 if ((*ppmcp->ppmc_func)(dip)) { 3298 DEVI(dip)->devi_pm_ppm = 3299 (struct dev_info *)ppmcp->ppmc_dip; 3300 mutex_exit(&ppm_lock); 3301 return; 3302 } 3303 } 3304 mutex_exit(&ppm_lock); 3305 } 3306 3307 /* 3308 * Node is being detached so stop autopm until we see if it succeeds, in which 3309 * case pm_stop will be called. For backwards compatible devices we bring the 3310 * device up to full power on the assumption the detach will succeed. 3311 */ 3312 void 3313 pm_detaching(dev_info_t *dip) 3314 { 3315 PMD_FUNC(pmf, "detaching") 3316 pm_info_t *info = PM_GET_PM_INFO(dip); 3317 int iscons; 3318 3319 PMD(PMD_REMDEV, ("%s: %s@%s(%s#%d), %d comps\n", pmf, PM_DEVICE(dip), 3320 PM_NUMCMPTS(dip))) 3321 if (info == NULL) 3322 return; 3323 ASSERT(DEVI_IS_DETACHING(dip)); 3324 PM_LOCK_DIP(dip); 3325 info->pmi_dev_pm_state |= PM_DETACHING; 3326 PM_UNLOCK_DIP(dip); 3327 if (!PM_ISBC(dip)) 3328 pm_scan_stop(dip); 3329 3330 /* 3331 * console and old-style devices get brought up when detaching. 3332 */ 3333 iscons = PM_IS_CFB(dip); 3334 if (iscons || PM_ISBC(dip)) { 3335 (void) pm_all_to_normal(dip, PM_CANBLOCK_BYPASS); 3336 if (iscons) { 3337 mutex_enter(&pm_cfb_lock); 3338 while (cfb_inuse) { 3339 mutex_exit(&pm_cfb_lock); 3340 PMD(PMD_CFB, ("%s: delay; cfb_inuse\n", pmf)) 3341 delay(1); 3342 mutex_enter(&pm_cfb_lock); 3343 } 3344 ASSERT(cfb_dip_detaching == NULL); 3345 ASSERT(cfb_dip); 3346 cfb_dip_detaching = cfb_dip; /* case detach fails */ 3347 cfb_dip = NULL; 3348 mutex_exit(&pm_cfb_lock); 3349 } 3350 } 3351 } 3352 3353 /* 3354 * Node failed to detach. If it used to be autopm'd, make it so again. 3355 */ 3356 void 3357 pm_detach_failed(dev_info_t *dip) 3358 { 3359 PMD_FUNC(pmf, "detach_failed") 3360 pm_info_t *info = PM_GET_PM_INFO(dip); 3361 int pm_all_at_normal(dev_info_t *); 3362 3363 if (info == NULL) 3364 return; 3365 ASSERT(DEVI_IS_DETACHING(dip)); 3366 if (info->pmi_dev_pm_state & PM_DETACHING) { 3367 info->pmi_dev_pm_state &= ~PM_DETACHING; 3368 if (info->pmi_dev_pm_state & PM_ALLNORM_DEFERRED) { 3369 /* Make sure the operation is still needed */ 3370 if (!pm_all_at_normal(dip)) { 3371 if (pm_all_to_normal(dip, 3372 PM_CANBLOCK_FAIL) != DDI_SUCCESS) { 3373 PMD(PMD_ERROR, ("%s: could not bring " 3374 "%s@%s(%s#%d) to normal\n", pmf, 3375 PM_DEVICE(dip))) 3376 } 3377 } 3378 info->pmi_dev_pm_state &= ~PM_ALLNORM_DEFERRED; 3379 } 3380 } 3381 if (!PM_ISBC(dip)) { 3382 mutex_enter(&pm_scan_lock); 3383 if (PM_SCANABLE(dip)) 3384 pm_scan_init(dip); 3385 mutex_exit(&pm_scan_lock); 3386 pm_rescan(dip); 3387 } 3388 } 3389 3390 /* generic Backwards Compatible component */ 3391 static char *bc_names[] = {"off", "on"}; 3392 3393 static pm_comp_t bc_comp = {"unknown", 2, NULL, NULL, &bc_names[0]}; 3394 3395 static void 3396 e_pm_default_levels(dev_info_t *dip, pm_component_t *cp, int norm) 3397 { 3398 pm_comp_t *pmc; 3399 pmc = &cp->pmc_comp; 3400 pmc->pmc_numlevels = 2; 3401 pmc->pmc_lvals[0] = 0; 3402 pmc->pmc_lvals[1] = norm; 3403 e_pm_set_cur_pwr(dip, cp, norm); 3404 } 3405 3406 static void 3407 e_pm_default_components(dev_info_t *dip, int cmpts) 3408 { 3409 int i; 3410 pm_component_t *p = DEVI(dip)->devi_pm_components; 3411 3412 p = DEVI(dip)->devi_pm_components; 3413 for (i = 0; i < cmpts; i++, p++) { 3414 p->pmc_comp = bc_comp; /* struct assignment */ 3415 p->pmc_comp.pmc_lvals = kmem_zalloc(2 * sizeof (int), 3416 KM_SLEEP); 3417 p->pmc_comp.pmc_thresh = kmem_alloc(2 * sizeof (int), 3418 KM_SLEEP); 3419 p->pmc_comp.pmc_numlevels = 2; 3420 p->pmc_comp.pmc_thresh[0] = INT_MAX; 3421 p->pmc_comp.pmc_thresh[1] = INT_MAX; 3422 } 3423 } 3424 3425 /* 3426 * Called from functions that require components to exist already to allow 3427 * for their creation by parsing the pm-components property. 3428 * Device will not be power managed as a result of this call 3429 * No locking needed because we're single threaded by the ndi_devi_enter 3430 * done while attaching, and the device isn't visible until after it has 3431 * attached 3432 */ 3433 int 3434 pm_premanage(dev_info_t *dip, int style) 3435 { 3436 PMD_FUNC(pmf, "premanage") 3437 pm_comp_t *pcp, *compp; 3438 int cmpts, i, norm, error; 3439 pm_component_t *p = DEVI(dip)->devi_pm_components; 3440 pm_comp_t *pm_autoconfig(dev_info_t *, int *); 3441 3442 ASSERT(!PM_IAM_LOCKING_DIP(dip)); 3443 /* 3444 * If this dip has already been processed, don't mess with it 3445 */ 3446 if (DEVI(dip)->devi_pm_flags & PMC_COMPONENTS_DONE) 3447 return (DDI_SUCCESS); 3448 if (DEVI(dip)->devi_pm_flags & PMC_COMPONENTS_FAILED) { 3449 return (DDI_FAILURE); 3450 } 3451 /* 3452 * Look up pm-components