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 #ifndef _SYS_EPM_H 27 #define _SYS_EPM_H 28 29 #include <sys/pm.h> 30 #include <sys/dditypes.h> 31 #include <sys/devops.h> 32 #include <sys/ddi_impldefs.h> 33 #include <sys/taskq.h> 34 #include <sys/tzfile.h> 35 36 /* 37 * XXXX 38 * Do we really need this include? It may be leftover from early CPUPM code. 39 * #include <sys/processor.h> 40 */ 41 42 #ifdef __cplusplus 43 extern "C" { 44 #endif 45 46 #ifdef _KERNEL 47 48 /* 49 * epm.h: Function prototypes and data structs for kernel pm functions. 50 */ 51 52 void e_pm_props(dev_info_t *); 53 int e_new_pm_props(dev_info_t *); 54 55 #define PM_LEVEL_UPONLY (-2) /* only raise power level */ 56 #define PM_LEVEL_DOWNONLY (-3) /* only lower power level */ 57 #define PM_LEVEL_EXACT (-4) /* wants exact power level */ 58 59 /* 60 * Values used by e_pm_props and friends, found in devi_pm_flags 61 */ 62 #define PMC_NEEDS_SR 0x00001 /* do suspend/resume despite no "reg" */ 63 #define PMC_NO_SR 0x00002 /* don't suspend/resume despite "reg" */ 64 #define PMC_PARENTAL_SR 0x00004 /* call up tree to suspend/resume */ 65 #define PMC_WANTS_NOTIFY 0x00008 /* notify if child pwr level changes */ 66 #define PMC_BC 0x00010 /* no pm-components, backwards compat */ 67 #define PMC_COMPONENTS_DONE 0x00020 /* parsed pm-components */ 68 #define PMC_COMPONENTS_FAILED 0x00040 /* failed parsing pm-components */ 69 #define PMC_SUSPENDED 0x00080 /* device has been suspended */ 70 #define PMC_DEF_THRESH 0x00100 /* thresholds are default */ 71 #define PMC_DEV_THRESH 0x00200 /* SET_THRESHOLD ioctl seen */ 72 #define PMC_COMP_THRESH 0x00400 /* relative threshold set */ 73 #define PMC_NEXDEF_THRESH 0x00800 /* relative threshold set for nexus */ 74 #define PMC_NOPMKID 0x01000 /* non-pm'd child of pm'd parent */ 75 #define PMC_NO_INVOL 0x02000 /* no pm without driver's consent */ 76 #define PMC_VOLPMD 0x04000 /* went down voluntarily */ 77 #define PMC_SKIP_BRINGUP 0x08000 /* Skipped a dependency bringup */ 78 79 /* 80 * A node which is the console frame buffer, and should not be powered down 81 * automatically because the OBP driver doesn't know how to power it back up 82 * before using it (can remove this when prom calls back into kernel to do 83 * io to console). 84 */ 85 #define PMC_CONSOLE_FB 0x10000 /* console framebuffer */ 86 #define PMC_NOINVOL_DONE 0x20000 /* processed by pm_noinvol_specd() */ 87 #define PMC_DRIVER_REMOVED 0x40000 /* driver is removed */ 88 #define PMC_CPU_DEVICE 0x80000 /* device is a power manageable CPU */ 89 #define PMC_CPU_THRESH 0x100000 /* cpu threshold set */ 90 91 #define PMC_THRESH_ALL (PMC_DEF_THRESH | PMC_DEV_THRESH | \ 92 PMC_COMP_THRESH | PMC_NEXDEF_THRESH | PMC_CPU_THRESH) 93 #define PMC_THRESH_NONE ~(PMC_THRESH_ALL) 94 95 /* Flags for the component */ 96 #define PM_POWER_OP 0x00001 /* set power in process */ 97 #define PM_PHC_WHILE_SET_POWER 0x00002 /* phc and set power deadlock */ 98 99 /* 100 * One of these is attached to each devinfo that is autopm'd. 101 */ 102 typedef struct pm_scan { 103 int ps_idle_down; /* PMID_XXX flags */ 104 int ps_scan_flags; /* scan flags, defined below */ 105 timeout_id_t ps_scan_id; /* per dip scan timeout id */ 106 } pm_scan_t; 107 108 /* 109 * ps_scan_flags may take the following values, plus possibly 110 * more defined. 111 */ 112 #define PM_SCANNING 0x100 /* scanning: pm_scan_dev is active */ 113 #define PM_SCAN_AGAIN 0x200 114 #define PM_SCAN_STOP 0x400 115 #define PM_SCAN_DISPATCHED 0x800 116 117 #define PM_DEFAULT_MIN_SCAN ((clock_t)15) /* Minimum scan interval in sec */ 118 #define PM_CPU_MIN_SCAN ((clock_t)1) /* Minimum interval for CPUs */ 119 120 /* 121 * Power management component definitions, used for tracking idleness of 122 * devices. An array of these hangs off the devi_pm_components member of the 123 * dev_info struct (if initialized by driver and/or auto-pm) 124 * The array of these structs is followed in the same kmem_zalloc'd chunk by 125 * the names pointed to by the structs. 126 */ 127 128 /* 129 * This (sub-)struct contains all the info extracted from the pm-components 130 * property for each component (name of component, names and values of power 131 * levels supported). It is in a separate structure to allow it to be handled 132 * as a struct assignment. 133 */ 134 typedef struct pm_comp { 135 char *pmc_name; /* name of component */ 136 int pmc_numlevels; /* number of power levels supported */ 137 int *pmc_lvals; /* numerical values of levels */ 138 int *pmc_thresh; /* thresholds in secs, last INT_MAX */ 139 char **pmc_lnames; /* human readable names of levels */ 140 /* 141 * This part is just bookkeeping for the storage space involved above 142 * used for copying and freeing the struct members. This because C 143 * is really an assembler at heart. 144 */ 145 size_t pmc_name_sz; /* size of name string */ 146 char *pmc_lname_buf; /* buffer holding *pmc_lnames */ 147 size_t pmc_lnames_sz; /* total size of pmc_lname_buf */ 148 } pm_comp_t; 149 150 /* 151 * Here we have the rest of what we need to know about a component. 152 */ 153 typedef struct pm_component { 154 uint_t pmc_flags; /* flags this component */ 155 uint_t pmc_busycount; /* for nesting busy calls */ 156 time_t pmc_timestamp; /* timestamp */ 157 uint_t pmc_norm_pwr; /* normal power index (or value) */ 158 int pmc_cur_pwr; /* current power index (or value) */ 159 int pmc_phc_pwr; /* prev. value of curpwr (deadlock) */ 160 pm_comp_t pmc_comp; /* component description */ 161 } pm_component_t; 162 163 /* 164 * All members of this struct are protected by PM_LOCK_DIP(dip). 165 * 166 * kidsupcnt counts (the number of components of new-style children at non-zero 167 * level (unknown counts as non-zero)) + (the number of old-style children with 168 * component 0 at non-zero level) for parents that have not asked for 169 * notification. When kidsupcnt is 0 for a nexus node, then pm scans it, 170 * otherwise it leaves it alone. 171 * Parents that ask for notification always get get scanned, 172 * so we keep their kidsupcnt at zero. 173 */ 174 typedef struct pm_info { 175 uint_t pmi_dev_pm_state; /* PM state of a device */ 176 int pmi_clone; /* owner for direct pm'd devs */ 177 int pmi_levels[2]; /* storage space for 2 levels */ 178 int *pmi_lp; /* storage space for >2 levels */ 179 kcondvar_t pmi_cv; /* condvar for direct PM access */ 180 } pm_info_t; 181 182 /* 183 * Work request structure for the dependency processing thread. 184 */ 185 typedef struct pm_dep_wk { 186 int pdw_type; /* Type of request */ 187 int pdw_wait; /* caller waits for result */ 188 int pdw_done; /* set when req is done */ 189 int pdw_ret; /* return value to caller */ 190 int pdw_pwr; /* pwr level of keeper */ 191 kcondvar_t pdw_cv; /* cv to wake up caller */ 192 struct pm_dep_wk *pdw_next; /* next element */ 193 char *pdw_keeper; 194 char *pdw_kept; 195 } pm_dep_wk_t; 196 197 /* 198 * Types of work, depends on when it gets called: 199 */ 200 #define PM_DEP_WK_POWER_ON 1 /* power on */ 201 #define PM_DEP_WK_POWER_OFF 2 /* power off */ 202 #define PM_DEP_WK_DETACH 3 /* detach */ 203 #define PM_DEP_WK_REMOVE_DEP 4 /* dependency removed */ 204 #define PM_DEP_WK_BRINGUP_SELF 5 /* released from direct PM */ 205 #define PM_DEP_WK_RECORD_KEEPER 6 /* PM_ADD_DEPENDENT */ 206 #define PM_DEP_WK_RECORD_KEEPER_PROP 7 /* PM_ADD_DEPENDENT_PROP */ 207 #define PM_DEP_WK_KEPT 8 /* dep. work as a kept */ 208 #define PM_DEP_WK_KEEPER 9 /* dep. work as a keeper */ 209 #define PM_DEP_WK_ATTACH 10 /* when dip is attached */ 210 #define PM_DEP_WK_CHECK_KEPT 11 /* check if this is a kept */ 211 #define PM_DEP_WK_CPR_SUSPEND 12 /* Suspend dep. during CPR */ 212 #define PM_DEP_WK_CPR_RESUME 13 /* Resume dep. after CPR */ 213 214 /* 215 * Wait for dependency work to finish or not. 216 */ 217 #define PM_DEP_WAIT 1 218 #define PM_DEP_NOWAIT 0 219 220 typedef enum pm_canblock 221 { 222 PM_CANBLOCK_BLOCK, /* wait for controlling process action */ 223 PM_CANBLOCK_FAIL, /* don't wait, fail request */ 224 PM_CANBLOCK_BYPASS /* don't wait, ignore controlling process */ 225 } pm_canblock_t; 226 227 typedef enum pm_cpupm 228 { 229 PM_CPUPM_NOTSET, /* no specific treatment of CPU devices */ 230 PM_CPUPM_POLLING, /* CPUPM enabled: polling mode */ 231 PM_CPUPM_EVENT, /* CPUPM enabled: event driven mode */ 232 PM_CPUPM_DISABLE /* do not power manage CPU devices */ 233 } pm_cpupm_t; 234 235 #define PPM(dip) ((dev_info_t *)DEVI(dip)->devi_pm_ppm) 236 237 /* 238 * The power request struct uses for the DDI_CTLOPS_POWER busctl. 239 * 240 * Note: When changing this enum it is necessary to maintain binary 241 * compatibility with older versions. To insure that, add new values only 242 * at the end and refrain from deleting any existing values. 243 */ 244 typedef enum { 245 PMR_SET_POWER = 1, /* called ddi_power (obsolete) */ 246 PMR_SUSPEND, /* parental suspend */ 247 PMR_RESUME, /* parental resume */ 248 PMR_PRE_SET_POWER, /* parent's "pre" notification */ 249 PMR_POST_SET_POWER, /* parent's "post" notification */ 250 PMR_PPM_SET_POWER, /* platform pm set power */ 251 PMR_PPM_ATTACH, /* ppm attach notify - unused */ 252 PMR_PPM_DETACH, /* ppm detach notify - unused */ 253 PMR_PPM_POWER_CHANGE_NOTIFY, /* ppm level change notify */ 254 PMR_REPORT_PMCAP, /* report pm capability */ 255 PMR_CHANGED_POWER, /* parent's power_has_changed notif. */ 256 PMR_PPM_PRE_PROBE, /* ppm pre probe notify */ 257 PMR_PPM_POST_PROBE, /* ppm post probe notify */ 258 PMR_PPM_PRE_ATTACH, /* ppm pre attach notify */ 259 PMR_PPM_POST_ATTACH, /* ppm post pm attach notify */ 260 PMR_PPM_PRE_DETACH, /* ppm pre pm detach notify */ 261 PMR_PPM_POST_DETACH, /* ppm post pm detach notify */ 262 PMR_PPM_UNMANAGE, /* device being unmanaged */ 263 PMR_PPM_PRE_RESUME, /* ppm resume notify */ 264 PMR_PPM_ALL_LOWEST, /* ppm all lowest power notify */ 265 PMR_PPM_LOCK_POWER, /* ppm lock power */ 266 PMR_PPM_UNLOCK_POWER, /* ppm unlock power */ 267 PMR_PPM_TRY_LOCK_POWER, /* ppm try lock power */ 268 PMR_PPM_INIT_CHILD, /* ppm init child notify */ 269 PMR_PPM_UNINIT_CHILD, /* ppm uninit child notify */ 270 PMR_PPM_POWER_LOCK_OWNER, /* ppm power lock owner's address */ 271 PMR_PPM_ENTER_SX, /* ppm: enter ACPI S[2-4] state */ 272 PMR_PPM_EXIT_SX, /* ppm: enter ACPI S[2-4] state */ 273 PMR_PPM_SEARCH_LIST /* ppm: search tuple list */ 274 } pm_request_type; 275 276 /* 277 * When changing the elements of the union below it is necessary to 278 * maintain binary compatibility with older versions. Refrain from 279 * deleting existing elements of the union or modifying their contents. 280 * Avoid increasing the total size of this structure if new elements 281 * must be added. 282 */ 283 typedef struct power_req { 284 pm_request_type request_type; 285 union req { 286 /* 287 * PMR_SET_POWER (obsolete) 288 */ 289 struct set_power_req { 290 dev_info_t *who; 291 int cmpt; 292 int level; 293 } set_power_req; 294 /* 295 * PMR_SUSPEND 296 */ 297 struct suspend_req { 298 dev_info_t *who; 299 ddi_detach_cmd_t cmd; 300 } suspend_req; 301 /* 302 * PMR_PPM_PRE_RESUME or PMR_RESUME 303 */ 304 struct resume_req { 305 dev_info_t *who; 306 ddi_attach_cmd_t cmd; 307 } resume_req; 308 /* 309 * PMR_PRE_SET_POWER 310 */ 311 struct pre_set_power_req { 312 dev_info_t *who; 313 int cmpt; 314 int old_level; 315 int new_level; 316 } pre_set_power_req; 317 /* 318 * PMR_POST_SET_POWER 319 */ 320 struct post_set_power_req { 321 dev_info_t *who; 322 int cmpt; 323 int old_level; 324 int new_level; 325 int result; /* driver's return */ 326 } post_set_power_req; 327 /* 328 * PMR_PPM_SET_POWER 329 */ 330 struct ppm_set_power_req { 331 dev_info_t *who; 332 int cmpt; 333 int old_level; 334 int new_level; 335 pm_canblock_t canblock; 336 void *cookie; 337 } ppm_set_power_req; 338 /* 339 * PMR_PPM_POWER_CHANGE_NOTIFY 340 */ 341 struct ppm_notify_level_req { 342 dev_info_t *who; 343 int cmpt; 344 int old_level; 345 int new_level; 346 } ppm_notify_level_req; 347 /* 348 * PMR_REPORT_PMCAP 349 */ 350 struct report_pmcap_req { 351 dev_info_t *who; 352 int cap; 353 void *arg; 354 } report_pmcap_req; 355 /* 356 * PMR_CHANGED_POWER 357 */ 358 struct changed_power_req { 359 dev_info_t *who; 360 int cmpt; 361 int old_level; 362 int new_level; 363 int result; 364 } changed_power_req; 365 /* 366 * PMR_PPM_PRE_PROBE, PMR_PPM_POST_PROBE, PMR_PPM_PRE_ATTACH, 367 * PMR_PPM_POST_ATTACH, PMR_PPM_PRE_DETACH, PMR_PPM_POST_DETACH 368 * PMR_PPM_INIT_CHILD, PMR_PPM_UNINIT_CHILD, or PMR_PPM_UNMANAGE 369 */ 370 struct ppm_config_req { 371 dev_info_t *who; 372 int result; /* post only */ 373 } ppm_config_req; 374 /* 375 * PMR_PPM_ALL_LOWEST 376 */ 377 struct ppm_all_lowest_req { 378 int mode; 379 } ppm_all_lowest_req; 380 /* 381 * PMR_PPM_LOCK_POWER, PMR_PPM_TRY_LOCK_POWER 382 */ 383 struct ppm_lock_power_req { 384 dev_info_t *who; 385 int *circp; 386 } ppm_lock_power_req; 387 /* 388 * PMR_PPM_UNLOCK_POWER 389 */ 390 struct ppm_unlock_power_req { 391 dev_info_t *who; 392 int circ; 393 } ppm_unlock_power_req; 394 /* 395 * PMR_PPM_POWER_LOCK_OWNER 396 */ 397 struct ppm_power_lock_owner_req { 398 dev_info_t *who; 399 kthread_t *owner; 400 } ppm_power_lock_owner_req; 401 /* 402 * PMR_PPM_POWER_ENTER_SX 403 */ 404 struct ppm_power_enter_sx_req { 405 int sx_state; /* S3, S4 */ 406 int test_point; /* test point */ 407 uint64_t wakephys; /* restart vector phys addr */ 408 void *psr; /* PSM (apic) state buffer */ 409 } ppm_power_enter_sx_req; 410 /* 411 * PMR_PPM_SEARCH_LIST 412 */ 413 struct ppm_search_list { 414 pm_searchargs_t *searchlist; 415 int result; 416 } ppm_search_list_req; 417 } req; 418 } power_req_t; 419 420 #define S3 3 421 #define S4 4 422 423 extern int cpr_test_point; 424 extern major_t cpr_device; 425 426 #define LOOP_BACK_NONE 0 427 #define LOOP_BACK_PASS 1 428 #define LOOP_BACK_FAIL 2 429 #define FORCE_SUSPEND_TO_RAM 3 430 #define DEVICE_SUSPEND_TO_RAM 4 431 432 /* 433 * Struct passed as arg to appm_ioctl 434 */ 435 typedef struct s3_args { 436 int s3a_state; /* S3, S4 */ 437 int s3a_test_point; /* test point */ 438 uint64_t s3a_wakephys; /* restart vector physical addr */ 439 void *s3a_psr; /* apic state save buffer */ 440 } s3a_t; 441 442 /* 443 * Structure used by the following bus_power operations: 444 * 445 * BUS_POWER_PRE_NOTIFICATION 446 * BUS_POWER_POST_NOTIFICATION 447 * BUS_POWER_CHILD_PWRCHG 448 */ 449 typedef struct pm_bp_child_pwrchg { 450 dev_info_t *bpc_dip; /* dip of the target device */ 451 char *bpc_path; /* path to the target device */ 452 int bpc_comp; /* component changing power */ 453 int bpc_olevel; /* old power level */ 454 int bpc_nlevel; /* new power level */ 455 void *bpc_private; /* PM framework private */ 456 } pm_bp_child_pwrchg_t; 457 458 /* 459 * Structure used by the BUS_POWER_NEXUS_PWRUP operation 460 */ 461 typedef struct pm_bp_nexus_pwrup { 462 dev_info_t *bpn_dip; /* dip of the nexus device */ 463 int bpn_comp; /* component powering up */ 464 int bpn_level; /* new power level */ 465 void *bpn_private; /* PM framework private */ 466 } pm_bp_nexus_pwrup_t; 467 468 /* 469 * Structure used by the BUS_POWER_HAS_CHANGED operation 470 */ 471 typedef struct pm_bp_has_changed { 472 dev_info_t *bphc_dip; /* dip of the target device */ 473 char *bphc_path; /* path to the target device */ 474 int bphc_comp; /* component changing power */ 475 int bphc_olevel; /* old power level */ 476 int bphc_nlevel; /* new power level */ 477 void *bphc_private; /* PM framework private */ 478 } pm_bp_has_changed_t; 479 480 /* 481 * Commands indicating which activity is requiring an 482 * update to the noinvol counters. 483 */ 484 #define PM_BP_NOINVOL_ATTACH 1 485 #define PM_BP_NOINVOL_DETACH 2 486 #define PM_BP_NOINVOL_REMDRV 3 487 #define PM_BP_NOINVOL_CFB 4 488 #define PM_BP_NOINVOL_POWER 5 489 490 /* 491 * Structure used by the BUS_POWER_NOINVOL operation. 492 */ 493 typedef struct pm_bp_noinvol { 494 dev_info_t *bpni_dip; /* dip of the target device */ 495 char *bpni_path; /* path to the target device */ 496 int bpni_cmd; /* how to update the counters */ 497 int bpni_volpmd; /* volpmd of target device */ 498 int bpni_wasvolpmd; /* whether to update volpmd */ 499 void *bpni_private; /* PM framework private */ 500 } pm_bp_noinvol_t; 501 502 /* 503 * This struct is used by the code that makes a PMR_PPM_SET_POWER request 504 * to ppm. Devices that changed power other than the primary device (which 505 * was requested) are passed back to the pm framework through this 506 * structure. 507 */ 508 typedef struct pm_ppm_devlist { 509 dev_info_t *ppd_who; 510 int ppd_cmpt; 511 int ppd_old_level; 512 int ppd_new_level; 513 struct pm_ppm_devlist *ppd_next; 514 } pm_ppm_devlist_t; 515 516 /* 517 * This struct is used by the code that brings up parents and notifies 518 * ppm drivers across probe/attach/detach (pm_pre/post_probe/attach/detach()) 519 */ 520 typedef struct pm_ppm_cookie { 521 dev_info_t *ppc_dip; /* dip of target node */ 522 dev_info_t *ppc_pdip; /* parent's dip */ 523 dev_info_t *ppc_ppm; /* interested ppm driver */ 524 int ppc_cmd; /* attach/detach cmd */ 525 } pm_ppm_cookie_t; 526 527 /* 528 * This struct records one dependency (a device keeps another or others up) 529 * pdr_size includes size of strings. 530 */ 531 typedef struct pm_dep_rec { 532 char *pdr_keeper; /* physpath of device keeping up */ 533 char *pdr_kept; /* physpath or property name */ 534 char **pdr_kept_paths; /* array of kept devices' paths */ 535 struct pm_dep_rec *pdr_next; /* next dependency device */ 536 size_t pdr_size; /* size to kmem_free */ 537 major_t pdr_major; /* major of kept driver (not props) */ 538 int pdr_isprop; /* true if kept is property name */ 539 int pdr_kept_count; /* how many kept altogether */ 540 int pdr_satisfied; /* true if in force (not properties) */ 541 } pm_pdr_t; 542 543 544 /* 545 * This struct records threshold information about a single component 546 */ 547 typedef struct pm_thresh_entry { 548 int pte_numthresh; 549 int *pte_thresh; 550 } pm_pte_t; 551 552 /* 553 * Note that this header and its array of entry structs with their arrays 554 * of thresholds and string storage for physpath are all kmem_alloced in one 555 * chunk for easy freeing ptr_size is the size of that chunk 556 */ 557 typedef struct pm_thresh_rec { 558 char *ptr_physpath; /* identifies node */ 559 struct pm_thresh_rec *ptr_next; 560 int ptr_numcomps; /* number of components */ 561 size_t ptr_size; /* total size for kmem_free */ 562 pm_pte_t *ptr_entries; 563 } pm_thresh_rec_t; 564 565 /* 566 * pmi_dev_pm_state state bits: 567 */ 568 569 /* 570 * a direct-pm device, not scanned, but controlled by a process 571 */ 572 #define PM_DIRECT 0x1 573 /* 574 * autopm is suspended while waiting to see if detach succeeds 575 */ 576 #define PM_DETACHING 0x2 577 578 /* 579 * An all_to_normal operation for an autopm device that is detaching, is 580 * deferred in case the detach fails. 581 */ 582 #define PM_ALLNORM_DEFERRED 0x4 583 584 #define PM_GET_PM_INFO(dip) (DEVI(dip)->devi_pm_info) 585 #define PM_GET_PM_SCAN(dip) (DEVI(dip)->devi_pm_scan) 586 587 #define PM_NUMCMPTS(dip) (DEVI(dip)->devi_pm_num_components) 588 #define PM_CP(dip, comp) (&DEVI(dip)->devi_pm_components[comp]) 589 590 /* 591 * Returns true if the device specified by dip is directly power managed 592 */ 593 #define PM_ISDIRECT(dip) \ 594 (((pm_info_t *)PM_GET_PM_INFO(dip))->pmi_dev_pm_state & PM_DIRECT) 595 596 /* 597 * Returns true if the device specified by dip is an old node for which we 598 * provide backwards compatible behavior (e.g. no pm-components property). 599 */ 600 #define PM_ISBC(dip) (DEVI(dip)->devi_pm_flags & PMC_BC) 601 602 /* 603 * Returns true if we have skipped a dependency bringup on this dip. 604 */ 605 #define PM_SKBU(dip) (DEVI(dip)->devi_pm_flags & PMC_SKIP_BRINGUP) 606 607 /* 608 * Returns true if device specified by dip is a power manageable CPU. 609 */ 610 #define PM_ISCPU(dip) (DEVI(dip)->devi_pm_flags & PMC_CPU_DEVICE) 611 612 /* 613 * Returns true if cpupm is enabled in event driven mode. 614 */ 615 #define PM_EVENT_CPUPM (cpupm == PM_CPUPM_EVENT) 616 617 /* 618 * Returns true if cpupm is enabled in polling mode. 619 */ 620 #define PM_POLLING_CPUPM (cpupm == PM_CPUPM_POLLING) 621 622 /* 623 * Returns true if cpupm operating using the default mode. 624 */ 625 #define PM_DEFAULT_CPUPM (cpupm == cpupm_default_mode) 626 627 /* 628 * Returns true if is disabled. 629 */ 630 #define PM_CPUPM_DISABLED (cpupm == PM_CPUPM_DISABLE) 631 632 /* 633 * If ((autopm is enabled and 634 * (CPUPM is not disabled and we're not in event mode, or it isn't a cpu)) 635 * OR 636 * (CPUPM are enabled and it is one)) 637 */ 638 #define PM_SCANABLE(dip) ((autopm_enabled && \ 639 ((!PM_CPUPM_DISABLED && !PM_EVENT_CPUPM) || !PM_ISCPU(dip))) || \ 640 (PM_POLLING_CPUPM && PM_ISCPU(dip))) 641 642 #define PM_NOT_ALL_LOWEST 0x0 /* not all components are at lowest */ 643 #define PM_ALL_LOWEST 0x1 /* all components are at lowest lvl */ 644 645 #define PM_ADDR(dip) (ddi_get_name_addr(dip) ? ddi_get_name_addr(dip) : "") 646 #define PM_NAME(dip) (ddi_binding_name(dip)) 647 #define PM_NODE(dip) (ddi_node_name(dip)) 648 #define PM_INST(dip) (ddi_get_instance(dip)) 649 #define PM_DEVICE(dip) PM_NAME(dip), PM_ADDR(dip), PM_NODE(dip), PM_INST(dip) 650 651 #ifdef DEBUG 652 /* 653 * Flags passed to PMD to enable debug printfs. If the same flag is set in 654 * pm_debug below then the message is printed. The most generally useful 655 * ones are the first 3 or 4. 656 */ 657 #define PMD_ERROR 0x0000001 658 #define PMD_FAIL 0x0000002 659 #define PMD_IOCTL 0x0000004 660 #define PMD_SCAN 0x0000008 661 #define PMD_RESCAN 0x0000010 662 #define PMD_REMINFO 0x0000020 663 #define PMD_NAMETODIP 0x0000040 664 #define PMD_CLOSE 0x0000080 665 #define PMD_DIN 0x0000100 /* Dev Is Needed */ 666 #define PMD_PMC 0x0000200 /* for testing with sun4m pmc driver */ 667 #define PMD_PPM 0x0000400 668 #define PMD_DEP 0x0000800 /* dependency processing */ 669 #define PMD_IDLEDOWN 0x0001000 670 #define PMD_SET 0x0002000 671 #define PMD_BRING 0x0004000 672 #define PMD_ALLNORM 0x0008000 673 #define PMD_REMDEV 0x0010000 674 #define PMD_LEVEL 0x0020000 675 #define PMD_THRESH 0x0040000 676 #define PMD_DPM 0x0080000 /* Direct Power Management */ 677 #define PMD_NORM 0x0100000 678 #define PMD_STATS 0x0200000 679 #define PMD_DEREG 0x0400000 680 #define PMD_KEEPS 0x0800000 681 #define PMD_KIDSUP 0x1000000 682 #define PMD_TCHECK 0x2000000 683 #define PMD_NOINVOL 0x4000000 684 #define PMD_CFB 0x8000000 /* console fb pm */ 685 #define PMD_DHR 0x10000000 /* driver hold/rele changes */ 686 #define PMD_PIL 0x20000000 /* print out PIL when calling power */ 687 #define PMD_PHC 0x40000000 /* pm_power_has_changed messages */ 688 #define PMD_LOCK 0x80000000 689 #define PMD_SX 0x80000000 /* ACPI S[1234] states */ 690 #define PMD_PROTO PMD_SX /* and other Prototype stuff */ 691 692 extern uint_t pm_debug; 693 extern uint_t pm_divertdebug; 694 /*PRINTFLIKE1*/ 695 extern void pm_log(const char *fmt, ...) __KPRINTFLIKE(1); 696 697 #if !defined(__sparc) 698 /* 699 * On non-sparc machines, PMDDEBUG isn't as big a deal as Sparc, so we 700 * define PMDDEUG here for use on non-sparc platforms. 701 */ 702 #define PMDDEBUG 703 #endif /* !__sparc */ 704 705 #ifdef PMDDEBUG 706 #define PMD(level, arglist) { \ 707 if (pm_debug & (level)) { \ 708 pm_log arglist; \ 709 } \ 710 } 711 #else /* !PMDDEBUG */ 712 #define PMD(level, arglist) ((void)0); 713 #endif /* PMDDEBUG */ 714 #ifndef sparc 715 extern clock_t pt_sleep; 716 /* code is char hex number to display on POST LED */ 717 #define PT(code) {outb(0x80, (char)code); drv_usecwait(pt_sleep); } 718 #else 719 #define PT(code) 720 #endif 721 #else 722 #define PMD(level, arglist) 723 #define PT(code) 724 #endif 725 /* 726 * Code Value Indication 727 * 728 */ 729 #define PT_SPL7 0x01 /* pm_suspend spl7 */ 730 #define PT_PMSRET 0x02 /* pm_suspend returns */ 731 #define PT_PPMCTLOP 0x03 /* invoking ppm_ctlops */ 732 #define PT_ACPISDEV 0x04 /* acpi suspend devices */ 733 #define PT_IC 0x05 /* acpi intr_clear */ 734 #define PT_1to1 0x06 /* 1:1 mapping */ 735 #define PT_SC 0x07 /* save context */ 736 #define PT_SWV 0x08 /* set waking vector */ 737 #define PT_SWV_FAIL 0x09 /* set waking vector failed */ 738 #define PT_EWE 0x0a /* enable wake events */ 739 #define PT_EWE_FAIL 0x0b /* enable wake events failed */ 740 #define PT_RTCW 0x0c /* setting rtc wakeup */ 741 #define PT_RTCW_FAIL 0x0d /* setting rtc wakeup failed */ 742 #define PT_TOD 0x0e /* setting tod */ 743 #define PT_SXP 0x0f /* sx prep */ 744 #define PT_SXE 0x10 /* sx enter */ 745 #define PT_SXE_FAIL 0x11 /* sx enter failed */ 746 #define PT_INSOM 0x12 /* insomnia label */ 747 #define PT_WOKE 0x20 /* woke up */ 748 #define PT_UNDO1to1 0x21 /* Undo 1:1 mapping */ 749 #define PT_LSS 0x22 /* leave sleep state */ 750 #define PT_LSS_FAIL 0x23 /* leave sleep state failed */ 751 #define PT_CPB 0x24 /* clear power button event */ 752 #define PT_CPB_FAIL 0x25 /* clear power button event failed */ 753 #define PT_DRTC_FAIL 0x26 /* disable rtc fails */ 754 #define PT_ACPIREINIT 0x27 /* reinit apic */ 755 #define PT_ACPIRESTORE 0x28 /* restore apic */ 756 #define PT_INTRRESTORE 0x28 /* restore interrupts */ 757 #define PT_RESDEV 0x2a /* ressume acpi devices */ 758 #define PT_CPU 0x2b /* init_cpu_syscall */ 759 #define PT_PRESUME 0x30 /* pm_resume entered */ 760 #define PT_RSUS 0x31 /* pm_resume "suspended" */ 761 #define PT_RKERN 0x32 /* pm_resume "kernel" */ 762 #define PT_RDRV 0x33 /* pm_resume "driver" */ 763 #define PT_RDRV_FAIL 0x34 /* pm_resume "driver" failed */ 764 #define PT_RRNOINVOL 0x35 /* pm_resume "reattach_noinvol" */ 765 #define PT_RUSER 0x36 /* pm_resume "user" */ 766 #define PT_RAPMSIG 0x37 /* pm_resume APM/SRN signal */ 767 #define PT_RMPO 0x38 /* pm_resume "mp_online" */ 768 #define PT_RDONE 0x39 /* pm_resume done */ 769 770 extern void pm_detaching(dev_info_t *); 771 extern void pm_detach_failed(dev_info_t *); 772 extern int pm_power(dev_info_t *, int, int); 773 extern int pm_unmanage(dev_info_t *); 774 extern void pm_rem_info(dev_info_t *); 775 extern int pm_get_norm_pwrs(dev_info_t *, int **, size_t *); 776 extern dev_info_t *pm_name_to_dip(char *, int); 777 extern int pm_power_up(dev_info_t *, int, int, int, pm_info_t *); 778 extern int pm_default_idle_threshold; 779 extern void pm_set_device_threshold(dev_info_t *, int, int); 780 extern int pm_valid_power(dev_info_t *, int, int); 781 extern void pm_lock_power(dev_info_t *, int *); 782 extern void pm_unlock_power(dev_info_t *, int); 783 extern int pm_try_locking_power(dev_info_t *, int *); 784 extern void pm_lock_power_single(dev_info_t *, int *); 785 extern void pm_unlock_power_single(dev_info_t *, int); 786 extern int pm_try_locking_power_single(dev_info_t *, int *); 787 extern int pm_isbc(dev_info_t *dip); 788 extern int pm_isdirect(dev_info_t *dip); 789 extern int pm_ctlops(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t o, 790 void *a, void *v); 791 extern int pm_noinvol_detached(char *); 792 extern int pm_init_child(dev_info_t *); 793 extern int pm_uninit_child(dev_info_t *); 794 795 extern int pm_all_to_normal(dev_info_t *, pm_canblock_t); 796 extern int pm_set_power(dev_info_t *, int, int, int, pm_canblock_t, int, 797 int *); 798 extern void pm_scan_init(dev_info_t *dip); 799 extern void pm_scan_fini(dev_info_t *dip); 800 extern void pm_scan_stop(dev_info_t *dip); 801 extern int pm_scan_stop_walk(dev_info_t *dip, void *); 802 extern void pm_scan(void *); 803 extern time_t pm_scan_dev(dev_info_t *dip); 804 extern void pm_rescan(void *); 805 extern int pm_rescan_walk(dev_info_t *, void *); 806 extern void pm_forget_power_level(dev_info_t *); 807 extern int pm_pre_config(dev_info_t *, char *); 808 extern int pm_pre_unconfig(dev_info_t *, int, int *, char *); 809 extern void pm_post_config(dev_info_t *, char *); 810 extern void pm_post_unconfig(dev_info_t *, int, char *); 811 extern void pm_pre_probe(dev_info_t *, pm_ppm_cookie_t *); 812 extern void pm_post_probe(pm_ppm_cookie_t *, int, int); 813 extern void pm_post_attach(pm_ppm_cookie_t *, int); 814 extern void pm_pre_attach(dev_info_t *, pm_ppm_cookie_t *, 815 ddi_attach_cmd_t); 816 extern void pm_pre_detach(dev_info_t *, ddi_detach_cmd_t, 817 pm_ppm_cookie_t *); 818 extern void pm_post_detach(pm_ppm_cookie_t *, int); 819 extern int pm_powerup(dev_info_t *); 820 extern int pm_all_at_normal(dev_info_t *); 821 extern int pm_busop_bus_power(dev_info_t *, void *, 822 pm_bus_power_op_t, void *, void *); 823 extern void pm_hold_power(dev_info_t *); 824 extern void pm_rele_power(dev_info_t *); 825 extern void pm_driver_removed(major_t); 826 extern void pm_borrow_lock(kthread_t *); 827 extern void pm_return_lock(void); 828 extern int pm_reattach_noinvol(void); 829 extern void pm_reattach_noinvol_fini(); 830 extern void pm_restore_direct_levels(void); 831 extern void pm_save_direct_levels(void); 832 extern void pm_cfb_setup(const char *); 833 extern void pm_proceed(dev_info_t *, int, int, int); 834 extern void pm_get_timestamps(dev_info_t *, time_t *); 835 extern void pm_deregister_watcher(int, dev_info_t *); 836 extern void pm_dispatch_to_dep_thread(int, char *, char *, int, int *, int); 837 extern int e_pm_valid_comp(dev_info_t *, int, pm_component_t **); 838 extern int e_pm_valid_info(dev_info_t *, pm_info_t **); 839 extern int e_pm_valid_power(dev_info_t *, int, int); 840 extern void pm_init_locks(void); 841 extern int pm_register_ppm(int (*)(dev_info_t *), dev_info_t *); 842 extern int pm_is_cfb(dev_info_t *); 843 #ifdef DEBUG 844 extern int pm_cfb_is_up(void); 845 #endif 846 847 #ifdef DIPLOCKDEBUG 848 #define PM_LOCK_DIP(dip) { PMD(PMD_LOCK, ("dip lock %s@%s(%s#%d) " \ 849 "%s %d\n", PM_DEVICE(dip), \ 850 __FILE__, __LINE__)) \ 851 mutex_enter(&DEVI(dip)->devi_pm_lock); } 852 #define PM_UNLOCK_DIP(dip) { PMD(PMD_LOCK, ("dip unlock %s@%s(%s#%d) " \ 853 "%s %d\n", PM_DEVICE(dip), \ 854 __FILE__, __LINE__)) \ 855 mutex_exit(&DEVI(dip)->devi_pm_lock); } 856 #else 857 #define PM_LOCK_DIP(dip) mutex_enter(&DEVI(dip)->devi_pm_lock) 858 #define PM_UNLOCK_DIP(dip) mutex_exit(&DEVI(dip)->devi_pm_lock) 859 #endif 860 861 /* 862 * These are the same DEBUG or not 863 */ 864 #define PM_LOCK_BUSY(dip) mutex_enter(&DEVI(dip)->devi_pm_busy_lock) 865 #define PM_UNLOCK_BUSY(dip) mutex_exit(&DEVI(dip)->devi_pm_busy_lock) 866 #define PM_LOCK_POWER(dip, circp) pm_lock_power(dip, circp) 867 #define PM_UNLOCK_POWER(dip, circ) pm_unlock_power(dip, circ) 868 #define PM_TRY_LOCK_POWER(dip, circp) pm_try_locking_power(dip, circp) 869 #define PM_IAM_LOCKING_DIP(dip) (mutex_owned(&DEVI(dip)->devi_pm_lock)) 870 871 #define PM_DEFAULT_SYS_IDLENESS 1800 /* 30 minutes */ 872 873 /* 874 * Codes put into the pr_retval field of pm_rsvp_t that tell pm_block() 875 * how to proceed 876 */ 877 #define PMP_SUCCEED 0x1 /* return success, the process did it */ 878 #define PMP_FAIL 0x2 /* return fail, process did something else */ 879 #define PMP_RELEASE 0x3 /* let it go, the process has lost interest */ 880 /* also arg to pm_proceed to signal this */ 881 /* 882 * Values of "style" for e_pm_manage and pm_premanage 883 */ 884 #define PM_STYLE_NEW 0 885 #define PM_STYLE_UNKNOWN 1 886 887 /* 888 * Arg passed to pm_proceed that results in PMP_SUCCEED or PMP_FAIL being set 889 * in pr_retval depending on what is pending 890 */ 891 #define PMP_SETPOWER 0x4 892 893 #define PM_MAX_CLONE 256 894 895 typedef struct pm_rsvp { 896 dev_info_t *pr_dip; 897 int pr_comp; 898 int pr_newlevel; 899 int pr_oldlevel; 900 kcondvar_t pr_cv; /* a place to sleep */ 901 int pr_retval; /* what to do when you wake up */ 902 struct pm_rsvp *pr_next; 903 struct pm_rsvp *pr_prev; 904 } pm_rsvp_t; 905 906 typedef struct psce { /* pm_state_change_entries */ 907 struct pm_state_change *psce_first; 908 struct pm_state_change *psce_in; 909 struct pm_state_change *psce_out; 910 struct pm_state_change *psce_last; 911 int psce_overruns; 912 int psce_references; 913 kmutex_t psce_lock; 914 } psce_t; 915 916 typedef struct pscc { /* pm_state_change_control */ 917 int pscc_clone; 918 dev_info_t *pscc_dip; 919 psce_t *pscc_entries; 920 struct pscc *pscc_next; 921 struct pscc *pscc_prev; 922 } pscc_t; 923 924 #define PSCCOUNT 128 /* number of state change entries kept per process */ 925 926 /* 927 * Struct used to track the existence of devices exporting the 928 * no-involuntary-power-cycles property, and remember things from their 929 * devinfo node for later attach. 930 */ 931 typedef struct pm_noinvol { 932 struct pm_noinvol *ni_next; 933 char *ni_path; 934 major_t ni_major; /* for attaching at cpr time */ 935 uint_t ni_flags; /* selected PMC_* values */ 936 uint_t ni_noinvolpm; /* saved noinvolpm count */ 937 uint_t ni_volpmd; /* saved volpmd count */ 938 uint_t ni_wasvolpmd; /* was vol pm'd at detach */ 939 size_t ni_size; 940 int ni_persistent; /* still around */ 941 } pm_noinvol_t; 942 943 #define PMID_IOCTIMER 0x1 /* pm_ioctl sets during timer */ 944 #define PMID_CFBTIMER 0x2 /* cfb sets during timer */ 945 #define PMID_IOCSCAN 0x4 /* pm_ioctl sets during scan */ 946 #define PMID_CFBSCAN 0x8 /* cfb sets during scan */ 947 948 #define PMID_IOC (PMID_IOCTIMER | PMID_IOCSCAN) 949 #define PMID_CFB (PMID_CFBTIMER | PMID_CFBSCAN) 950 #define PMID_TIMERS (PMID_IOCTIMER | PMID_CFBTIMER) 951 #define PMID_SCANS (PMID_IOCSCAN | PMID_CFBSCAN) 952 #define PMID_SCANS_SHIFT 2 953 #define PMID_SET_SCANS(pmid) (pmid) |= (((pmid) & PMID_TIMERS) << \ 954 PMID_SCANS_SHIFT); 955 #define PMID_IS_IOC(pmid) ((pmid) & PMID_IOC) 956 #define PMID_IS_CFB(pmid, dip) (((pmid) & PMID_CFB) && \ 957 (DEVI(dip)->devi_pm_flags & \ 958 (PMC_DEF_THRESH | PMC_NEXDEF_THRESH))) 959 #define PM_IS_PID(dip) (PMID_IS_IOC(PM_GET_PM_SCAN(dip)->ps_idle_down) || \ 960 PMID_IS_CFB(PM_GET_PM_SCAN(dip)->ps_idle_down, dip)) 961 #define PM_IS_CFB(dip) (DEVI(dip)->devi_pm_flags & PMC_CONSOLE_FB) 962 #define PM_KUC(dip) (DEVI(dip)->devi_pm_kidsupcnt) 963 #define PM_CURPOWER(dip, comp) cur_power(PM_CP(dip, comp)) 964 965 #define PM_WANTS_NOTIFICATION(dip) \ 966 (DEVI(dip)->devi_pm_flags & PMC_WANTS_NOTIFY) 967 968 #define PM_HAS_BUS_POWER(dip) \ 969 ((DEVI(dip)->devi_ops->devo_bus_ops != NULL) && \ 970 (DEVI(dip)->devi_ops->devo_bus_ops->busops_rev >= BUSO_REV_7) &&\ 971 (DEVI(dip)->devi_ops->devo_bus_ops->bus_power != NULL)) 972 973 #define PM_BUS_POWER_FUNC(dip) \ 974 DEVI(dip)->devi_ops->devo_bus_ops->bus_power 975 976 /* 977 * Structure used to pass down sunpm's private data variables 978 * through the bus_power bus_op calls 979 */ 980 typedef struct pm_sp_misc { 981 pm_canblock_t pspm_canblock; 982 int pspm_scan; 983 int *pspm_errnop; 984 int pspm_direction; 985 } pm_sp_misc_t; 986 987 /* 988 * This structure is used in validating that the power level 989 * of the descendents are off, while a device is powered off. 990 */ 991 typedef struct pm_desc_pwrchk { 992 dev_info_t *pdpc_dip; 993 int pdpc_par_involved; 994 } pm_desc_pwrchk_t; 995 996 997 /* 998 * These defines are used by pm_trans_check() to calculate time. 999 * Mostly copied from "tzfile.h". 1000 */ 1001 #define DC_SPY (SECSPERDAY * DAYSPERNYEAR) 1002 #define DC_SPW (SECSPERDAY * DAYSPERWEEK) 1003 #define DC_SPD SECSPERDAY 1004 1005 #define DC_SCSI_YEAR_LEN 4 /* YYYY */ 1006 #define DC_SCSI_WEEK_LEN 2 /* WW */ 1007 #define DC_SCSI_NPY 5 /* # power-cycle years */ 1008 1009 #endif /* _KERNEL */ 1010 1011 #ifdef __cplusplus 1012 } 1013 #endif 1014 1015 #endif /* _SYS_EPM_H */ 1016