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 /*
  27  * pm   This driver now only handles the ioctl interface.  The scanning
  28  *      and policy stuff now lives in common/os/sunpm.c.
  29  *      Not DDI compliant
  30  */
  31 
  32 #include <sys/types.h>
  33 #include <sys/errno.h>
  34 #include <sys/modctl.h>
  35 #include <sys/callb.h>            /* callback registration for cpu_deep_idle */
  36 #include <sys/conf.h>             /* driver flags and functions */
  37 #include <sys/open.h>             /* OTYP_CHR definition */
  38 #include <sys/stat.h>             /* S_IFCHR definition */
  39 #include <sys/pathname.h> /* name -> dev_info xlation */
  40 #include <sys/kmem.h>             /* memory alloc stuff */
  41 #include <sys/debug.h>
  42 #include <sys/pm.h>
  43 #include <sys/ddi.h>
  44 #include <sys/sunddi.h>
  45 #include <sys/epm.h>
  46 #include <sys/vfs.h>
  47 #include <sys/mode.h>
  48 #include <sys/mkdev.h>
  49 #include <sys/promif.h>
  50 #include <sys/consdev.h>
  51 #include <sys/ddi_impldefs.h>
  52 #include <sys/poll.h>
  53 #include <sys/note.h>
  54 #include <sys/taskq.h>
  55 #include <sys/policy.h>
  56 #include <sys/cpu_pm.h>
  57 
  58 /*
  59  * Minor number is instance<<8 + clone minor from range 1-254; (0 reserved
  60  * for "original")
  61  */
  62 #define PM_MINOR_TO_CLONE(minor) ((minor) & (PM_MAX_CLONE -1))
  63 
  64 #define PM_NUMCMPTS(dip) (DEVI(dip)->devi_pm_num_components)
  65 #define PM_IS_CFB(dip) (DEVI(dip)->devi_pm_flags & PMC_CONSOLE_FB)
  66 #define PM_MAJOR(dip) ddi_driver_major(dip)
  67 #define PM_RELE(dip) ddi_release_devi(dip)
  68 
  69 #define PM_IDLEDOWN_TIME        10
  70 #define MAXSMBIOSSTRLEN 64      /* from SMBIOS spec */
  71 #define MAXCOPYBUF      (MAXSMBIOSSTRLEN + 1)
  72 
  73 extern kmutex_t pm_scan_lock;   /* protects autopm_enable, pm_scans_disabled */
  74 extern kmutex_t pm_clone_lock;  /* protects pm_clones array */
  75 extern int      autopm_enabled;
  76 extern pm_cpupm_t cpupm;
  77 extern pm_cpupm_t cpupm_default_mode;
  78 extern int      pm_default_idle_threshold;
  79 extern int      pm_system_idle_threshold;
  80 extern int      pm_cpu_idle_threshold;
  81 extern kcondvar_t pm_clones_cv[PM_MAX_CLONE];
  82 extern uint_t   pm_poll_cnt[PM_MAX_CLONE];
  83 extern int      autoS3_enabled;
  84 extern void     pm_record_thresh(pm_thresh_rec_t *);
  85 extern void     pm_register_watcher(int, dev_info_t *);
  86 extern int      pm_get_current_power(dev_info_t *, int, int *);
  87 extern int      pm_interest_registered(int);
  88 extern void     pm_all_to_default_thresholds(void);
  89 extern int      pm_current_threshold(dev_info_t *, int, int *);
  90 extern void     pm_deregister_watcher(int, dev_info_t *);
  91 extern void     pm_unrecord_threshold(char *);
  92 extern int      pm_S3_enabled;
  93 extern int      pm_ppm_searchlist(pm_searchargs_t *);
  94 extern psce_t   *pm_psc_clone_to_direct(int);
  95 extern psce_t   *pm_psc_clone_to_interest(int);
  96 
  97 /*
  98  * The soft state of the power manager.  Since there will only
  99  * one of these, just reference it through a static pointer.
 100  */
 101 static struct pmstate {
 102         dev_info_t      *pm_dip;                /* ptr to our dev_info node */
 103         int             pm_instance;            /* for ddi_get_instance() */
 104         timeout_id_t    pm_idledown_id;         /* pm idledown timeout id */
 105         uchar_t         pm_clones[PM_MAX_CLONE]; /* uniqueify multiple opens */
 106         struct cred     *pm_cred[PM_MAX_CLONE]; /* cred for each unique open */
 107 } pm_state = { NULL, -1, (timeout_id_t)0 };
 108 typedef struct pmstate *pm_state_t;
 109 static pm_state_t pmstp = &pm_state;
 110 
 111 static int      pm_open(dev_t *, int, int, cred_t *);
 112 static int      pm_close(dev_t, int, int, cred_t *);
 113 static int      pm_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 114 static int      pm_chpoll(dev_t, short, int, short *, struct pollhead **);
 115 
 116 static struct cb_ops pm_cb_ops = {
 117         pm_open,        /* open */
 118         pm_close,       /* close */
 119         nodev,          /* strategy */
 120         nodev,          /* print */
 121         nodev,          /* dump */
 122         nodev,          /* read */
 123         nodev,          /* write */
 124         pm_ioctl,       /* ioctl */
 125         nodev,          /* devmap */
 126         nodev,          /* mmap */
 127         nodev,          /* segmap */
 128         pm_chpoll,      /* poll */
 129         ddi_prop_op,    /* prop_op */
 130         NULL,           /* streamtab */
 131         D_NEW | D_MP    /* driver compatibility flag */
 132 };
 133 
 134 static int pm_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
 135     void **result);
 136 static int pm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
 137 static int pm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
 138 
 139 static struct dev_ops pm_ops = {
 140         DEVO_REV,               /* devo_rev */
 141         0,                      /* refcnt */
 142         pm_getinfo,             /* info */
 143         nulldev,                /* identify */
 144         nulldev,                /* probe */
 145         pm_attach,              /* attach */
 146         pm_detach,              /* detach */
 147         nodev,                  /* reset */
 148         &pm_cb_ops,         /* driver operations */
 149         NULL,                   /* bus operations */
 150         NULL,                   /* power */
 151         ddi_quiesce_not_needed,         /* quiesce */
 152 };
 153 
 154 static struct modldrv modldrv = {
 155         &mod_driverops,
 156         "power management driver",
 157         &pm_ops
 158 };
 159 
 160 static struct modlinkage modlinkage = {
 161         MODREV_1, &modldrv, 0
 162 };
 163 
 164 /* Local functions */
 165 #ifdef DEBUG
 166 static int      print_info(dev_info_t *, void *);
 167 
 168 #endif
 169 
 170 int
 171 _init(void)
 172 {
 173         return (mod_install(&modlinkage));
 174 }
 175 
 176 int
 177 _fini(void)
 178 {
 179         return (mod_remove(&modlinkage));
 180 }
 181 
 182 int
 183 _info(struct modinfo *modinfop)
 184 {
 185         return (mod_info(&modlinkage, modinfop));
 186 }
 187 
 188 static int
 189 pm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 190 {
 191         int             i;
 192 
 193         switch (cmd) {
 194 
 195         case DDI_ATTACH:
 196                 if (pmstp->pm_instance != -1)        /* Only allow one instance */
 197                         return (DDI_FAILURE);
 198                 pmstp->pm_instance = ddi_get_instance(dip);
 199                 if (ddi_create_minor_node(dip, "pm", S_IFCHR,
 200                     (pmstp->pm_instance << 8) + 0,
 201                     DDI_PSEUDO, 0) != DDI_SUCCESS) {
 202                         return (DDI_FAILURE);
 203                 }
 204                 pmstp->pm_dip = dip; /* pm_init and getinfo depend on it */
 205 
 206                 for (i = 0; i < PM_MAX_CLONE; i++)
 207                         cv_init(&pm_clones_cv[i], NULL, CV_DEFAULT, NULL);
 208 
 209                 ddi_report_dev(dip);
 210                 return (DDI_SUCCESS);
 211 
 212         default:
 213                 return (DDI_FAILURE);
 214         }
 215 }
 216 
 217 /* ARGSUSED */
 218 static int
 219 pm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 220 {
 221         int i;
 222 
 223         switch (cmd) {
 224         case DDI_DETACH:
 225                 /*
 226                  * Don't detach while idledown timeout is pending.  Note that
 227                  * we already know we're not in pm_ioctl() due to framework
 228                  * synchronization, so this is a sufficient test
 229                  */
 230                 if (pmstp->pm_idledown_id)
 231                         return (DDI_FAILURE);
 232 
 233                 for (i = 0; i < PM_MAX_CLONE; i++)
 234                         cv_destroy(&pm_clones_cv[i]);
 235 
 236                 ddi_remove_minor_node(dip, NULL);
 237                 pmstp->pm_instance = -1;
 238                 return (DDI_SUCCESS);
 239 
 240         default:
 241                 return (DDI_FAILURE);
 242         }
 243 }
 244 
 245 static int
 246 pm_close_direct_pm_device(dev_info_t *dip, void *arg)
 247 {
 248         int clone;
 249         char *pathbuf;
 250         pm_info_t *info = PM_GET_PM_INFO(dip);
 251 
 252         clone = *((int *)arg);
 253 
 254         if (!info)
 255                 return (DDI_WALK_CONTINUE);
 256 
 257         pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
 258         PM_LOCK_DIP(dip);
 259         if (clone == info->pmi_clone) {
 260                 PMD(PMD_CLOSE, ("pm_close: found %s@%s(%s#%d)\n",
 261                     PM_DEVICE(dip)))
 262                 ASSERT(PM_ISDIRECT(dip));
 263                 info->pmi_dev_pm_state &= ~PM_DIRECT;
 264                 PM_UNLOCK_DIP(dip);
 265                 pm_proceed(dip, PMP_RELEASE, -1, -1);
 266                 /* Bring ourselves up if there is a keeper that is up */
 267                 (void) ddi_pathname(dip, pathbuf);
 268                 pm_dispatch_to_dep_thread(PM_DEP_WK_BRINGUP_SELF, NULL,
 269                     pathbuf, PM_DEP_NOWAIT, NULL, 0);
 270                 PM_LOCK_DIP(dip);
 271                 info->pmi_clone = 0;
 272                 PM_UNLOCK_DIP(dip);
 273         } else {
 274                 PM_UNLOCK_DIP(dip);
 275         }
 276         kmem_free(pathbuf, MAXPATHLEN);
 277 
 278         /* restart autopm on device released from direct pm */
 279         pm_rescan(dip);
 280 
 281         return (DDI_WALK_CONTINUE);
 282 }
 283 
 284 #define PM_REQ          1
 285 #define NOSTRUCT        2
 286 #define DIP             3
 287 #define NODIP           4
 288 #define NODEP           5
 289 #define DEP             6
 290 #define PM_PSC          7
 291 #define PM_SRCH         8
 292 
 293 #define CHECKPERMS      0x001
 294 #define SU              0x002
 295 #define SG              0x004
 296 #define OWNER           0x008
 297 
 298 #define INWHO           0x001
 299 #define INDATAINT       0x002
 300 #define INDATASTRING    0x004
 301 #define INDEP           0x008
 302 #define INDATAOUT       0x010
 303 #define INDATA  (INDATAOUT | INDATAINT | INDATASTRING | INDEP)
 304 
 305 struct pm_cmd_info {
 306         int cmd;                /* command code */
 307         char *name;             /* printable string */
 308         int supported;          /* true if still supported */
 309         int str_type;           /* PM_REQ or NOSTRUCT */
 310         int inargs;             /* INWHO, INDATAINT, INDATASTRING, INDEP, */
 311                                 /* INDATAOUT */
 312         int diptype;            /* DIP or NODIP */
 313         int deptype;            /* DEP or NODEP */
 314         int permission;         /* SU, GU, or CHECKPERMS */
 315 };
 316 
 317 #ifdef DEBUG
 318 char *pm_cmd_string;
 319 int pm_cmd;
 320 #endif
 321 
 322 /*
 323  * Returns true if permission granted by credentials
 324  */
 325 static int
 326 pm_perms(int perm, cred_t *cr)
 327 {
 328         if (perm == 0)                  /* no restrictions */
 329                 return (1);
 330         if (perm == CHECKPERMS)         /* ok for now (is checked later) */
 331                 return (1);
 332         if ((perm & SU) && secpolicy_power_mgmt(cr) == 0) /* privileged? */
 333                 return (1);
 334         if ((perm & SG) && (crgetgid(cr) == 0))     /* group 0 is ok */
 335                 return (1);
 336         return (0);
 337 }
 338 
 339 #ifdef DEBUG
 340 static int
 341 print_info(dev_info_t *dip, void *arg)
 342 {
 343         _NOTE(ARGUNUSED(arg))
 344         pm_info_t       *info;
 345         int             i, j;
 346         struct pm_component *cp;
 347         extern int pm_cur_power(pm_component_t *cp);
 348 
 349         info = PM_GET_PM_INFO(dip);
 350         if (!info)
 351                 return (DDI_WALK_CONTINUE);
 352         cmn_err(CE_CONT, "pm_info for %s\n", ddi_node_name(dip));
 353         for (i = 0; i < PM_NUMCMPTS(dip); i++) {
 354                 cp = PM_CP(dip, i);
 355                 cmn_err(CE_CONT, "\tThresholds[%d] =",  i);
 356                 for (j = 0; j < cp->pmc_comp.pmc_numlevels; j++)
 357                         cmn_err(CE_CONT, " %d", cp->pmc_comp.pmc_thresh[i]);
 358                 cmn_err(CE_CONT, "\n");
 359                 cmn_err(CE_CONT, "\tCurrent power[%d] = %d\n", i,
 360                     pm_cur_power(cp));
 361         }
 362         if (PM_ISDIRECT(dip))
 363                 cmn_err(CE_CONT, "\tDirect power management\n");
 364         return (DDI_WALK_CONTINUE);
 365 }
 366 #endif
 367 
 368 /*
 369  * command, name, supported, str_type, inargs, diptype, deptype, permission
 370  */
 371 static struct pm_cmd_info pmci[] = {
 372         {PM_SCHEDULE, "PM_SCHEDULE", 0},
 373         {PM_GET_IDLE_TIME, "PM_GET_IDLE_TIME", 0},
 374         {PM_GET_NUM_CMPTS, "PM_GET_NUM_CMPTS", 0},
 375         {PM_GET_THRESHOLD, "PM_GET_THRESHOLD", 0},
 376         {PM_SET_THRESHOLD, "PM_SET_THRESHOLD", 0},
 377         {PM_GET_NORM_PWR, "PM_GET_NORM_PWR", 0},
 378         {PM_SET_CUR_PWR, "PM_SET_CUR_PWR", 0},
 379         {PM_GET_CUR_PWR, "PM_GET_CUR_PWR", 0},
 380         {PM_GET_NUM_DEPS, "PM_GET_NUM_DEPS", 0},
 381         {PM_GET_DEP, "PM_GET_DEP", 0},
 382         {PM_ADD_DEP, "PM_ADD_DEP", 0},
 383         {PM_REM_DEP, "PM_REM_DEP", 0},
 384         {PM_REM_DEVICE, "PM_REM_DEVICE", 0},
 385         {PM_REM_DEVICES, "PM_REM_DEVICES", 0},
 386         {PM_REPARSE_PM_PROPS, "PM_REPARSE_PM_PROPS", 1, PM_REQ, INWHO, DIP,
 387             NODEP},
 388         {PM_DISABLE_AUTOPM, "PM_DISABLE_AUTOPM", 0},
 389         {PM_REENABLE_AUTOPM, "PM_REENABLE_AUTOPM", 0},
 390         {PM_SET_NORM_PWR, "PM_SET_NORM_PWR", 0 },
 391         {PM_SET_DEVICE_THRESHOLD, "PM_SET_DEVICE_THRESHOLD", 1, PM_REQ,
 392             INWHO, NODIP, NODEP, SU},
 393         {PM_GET_SYSTEM_THRESHOLD, "PM_GET_SYSTEM_THRESHOLD", 1, NOSTRUCT},
 394         {PM_GET_DEFAULT_SYSTEM_THRESHOLD, "PM_GET_DEFAULT_SYSTEM_THRESHOLD",
 395             1, NOSTRUCT},
 396         {PM_SET_SYSTEM_THRESHOLD, "PM_SET_SYSTEM_THRESHOLD", 1, NOSTRUCT,
 397             0, 0, 0, SU},
 398         {PM_START_PM, "PM_START_PM", 1, NOSTRUCT, 0, 0, 0, SU},
 399         {PM_STOP_PM, "PM_STOP_PM", 1, NOSTRUCT, 0, 0, 0, SU},
 400         {PM_RESET_PM, "PM_RESET_PM", 1, NOSTRUCT, 0, 0, 0, SU},
 401         {PM_GET_STATS, "PM_GET_STATS", 1, PM_REQ, INWHO | INDATAOUT,
 402             DIP, NODEP},
 403         {PM_GET_DEVICE_THRESHOLD, "PM_GET_DEVICE_THRESHOLD", 1, PM_REQ, INWHO,
 404             DIP, NODEP},
 405         {PM_GET_POWER_NAME, "PM_GET_POWER_NAME", 1, PM_REQ, INWHO | INDATAOUT,
 406             DIP, NODEP},
 407         {PM_GET_POWER_LEVELS, "PM_GET_POWER_LEVELS", 1, PM_REQ,
 408             INWHO | INDATAOUT, DIP, NODEP},
 409         {PM_GET_NUM_COMPONENTS, "PM_GET_NUM_COMPONENTS", 1, PM_REQ, INWHO,
 410             DIP, NODEP},
 411         {PM_GET_COMPONENT_NAME, "PM_GET_COMPONENT_NAME", 1, PM_REQ,
 412             INWHO | INDATAOUT, DIP, NODEP},
 413         {PM_GET_NUM_POWER_LEVELS, "PM_GET_NUM_POWER_LEVELS", 1, PM_REQ, INWHO,
 414             DIP, NODEP},
 415         {PM_GET_STATE_CHANGE, "PM_GET_STATE_CHANGE", 1, PM_PSC},
 416         {PM_GET_STATE_CHANGE_WAIT, "PM_GET_STATE_CHANGE_WAIT", 1, PM_PSC},
 417         {PM_DIRECT_PM, "PM_DIRECT_PM", 1, PM_REQ, INWHO, DIP, NODEP,
 418             (SU | SG)},
 419         {PM_RELEASE_DIRECT_PM, "PM_RELEASE_DIRECT_PM", 1, PM_REQ, INWHO,
 420             DIP, NODEP},
 421         {PM_DIRECT_NOTIFY, "PM_DIRECT_NOTIFY", 1, PM_PSC},
 422         {PM_DIRECT_NOTIFY_WAIT, "PM_DIRECT_NOTIFY_WAIT", 1, PM_PSC},
 423         {PM_RESET_DEVICE_THRESHOLD, "PM_RESET_DEVICE_THRESHOLD", 1, PM_REQ,
 424             INWHO, DIP, NODEP, SU},
 425         {PM_GET_PM_STATE, "PM_GET_PM_STATE", 1, NOSTRUCT},
 426         {PM_GET_AUTOS3_STATE, "PM_GET_AUTOS3_STATE", 1, NOSTRUCT},
 427         {PM_GET_S3_SUPPORT_STATE, "PM_GET_S3_SUPPORT_STATE", 1, NOSTRUCT},
 428         {PM_GET_DEVICE_TYPE, "PM_GET_DEVICE_TYPE", 1, PM_REQ, INWHO,
 429             DIP, NODEP},
 430         {PM_SET_COMPONENT_THRESHOLDS, "PM_SET_COMPONENT_THRESHOLDS", 1, PM_REQ,
 431             INWHO | INDATAINT, NODIP, NODEP, SU},
 432         {PM_GET_COMPONENT_THRESHOLDS, "PM_GET_COMPONENT_THRESHOLDS", 1, PM_REQ,
 433             INWHO | INDATAOUT, DIP, NODEP},
 434         {PM_IDLE_DOWN, "PM_IDLE_DOWN", 1, NOSTRUCT, 0, 0, 0, SU},
 435         {PM_GET_DEVICE_THRESHOLD_BASIS, "PM_GET_DEVICE_THRESHOLD_BASIS", 1,
 436             PM_REQ, INWHO, DIP, NODEP},
 437         {PM_SET_CURRENT_POWER, "PM_SET_CURRENT_POWER", 1, PM_REQ, INWHO, DIP,
 438             NODEP},
 439         {PM_GET_CURRENT_POWER, "PM_GET_CURRENT_POWER", 1, PM_REQ, INWHO, DIP,
 440             NODEP},
 441         {PM_GET_FULL_POWER, "PM_GET_FULL_POWER", 1, PM_REQ, INWHO, DIP,
 442             NODEP},
 443         {PM_ADD_DEPENDENT, "PM_ADD_DEPENDENT", 1, PM_REQ, INWHO | INDATASTRING,
 444             DIP, DEP, SU},
 445         {PM_GET_TIME_IDLE, "PM_GET_TIME_IDLE", 1, PM_REQ, INWHO, DIP, NODEP},
 446         {PM_ADD_DEPENDENT_PROPERTY, "PM_ADD_DEPENDENT_PROPERTY", 1, PM_REQ,
 447             INWHO | INDATASTRING, NODIP, DEP, SU},
 448         {PM_START_CPUPM, "PM_START_CPUPM", 1, NOSTRUCT, 0, 0, 0, SU},
 449         {PM_START_CPUPM_EV, "PM_START_CPUPM_EV", 1, NOSTRUCT, 0,
 450             0, 0, SU},
 451         {PM_START_CPUPM_POLL, "PM_START_CPUPM_POLL", 1, NOSTRUCT, 0,
 452             0, 0, SU},
 453         {PM_STOP_CPUPM, "PM_STOP_CPUPM", 1, NOSTRUCT, 0, 0, 0, SU},
 454         {PM_GET_CPU_THRESHOLD, "PM_GET_CPU_THRESHOLD", 1, NOSTRUCT},
 455         {PM_SET_CPU_THRESHOLD, "PM_SET_CPU_THRESHOLD", 1, NOSTRUCT,
 456             0, 0, 0, SU},
 457         {PM_GET_CPUPM_STATE, "PM_GET_CPUPM_STATE", 1, NOSTRUCT},
 458         {PM_START_AUTOS3, "PM_START_AUTOS3", 1, NOSTRUCT, 0, 0, 0, SU},
 459         {PM_STOP_AUTOS3, "PM_STOP_AUTOS3", 1, NOSTRUCT, 0, 0, 0, SU},
 460         {PM_ENABLE_S3, "PM_ENABLE_S3", 1, NOSTRUCT, 0, 0, 0, SU},
 461         {PM_DISABLE_S3, "PM_DISABLE_S3", 1, NOSTRUCT, 0, 0, 0, SU},
 462         {PM_ENTER_S3, "PM_ENTER_S3", 1, NOSTRUCT, 0, 0, 0, SU},
 463         {PM_SEARCH_LIST, "PM_SEARCH_LIST", 1, PM_SRCH, 0, 0, 0, SU},
 464         {PM_GET_CMD_NAME, "PM_GET_CMD_NAME", 1, PM_REQ, INDATAOUT, NODIP,
 465             NODEP, 0},
 466         {PM_DISABLE_CPU_DEEP_IDLE, "PM_DISABLE_CPU_DEEP_IDLE", 1, NOSTRUCT, 0,
 467             0, 0, SU},
 468         {PM_ENABLE_CPU_DEEP_IDLE, "PM_START_CPU_DEEP_IDLE", 1, NOSTRUCT, 0,
 469             0, 0, SU},
 470         {PM_DEFAULT_CPU_DEEP_IDLE, "PM_DFLT_CPU_DEEP_IDLE", 1, NOSTRUCT, 0,
 471             0, 0, SU},
 472         {0, NULL}
 473 };
 474 
 475 struct pm_cmd_info *
 476 pc_info(int cmd)
 477 {
 478         struct pm_cmd_info *pcip;
 479 
 480         for (pcip = pmci; pcip->name; pcip++) {
 481                 if (cmd == pcip->cmd)
 482                         return (pcip);
 483         }
 484         return (NULL);
 485 }
 486 
 487 static char *
 488 pm_decode_cmd(int cmd)
 489 {
 490         static char invbuf[64];
 491         struct pm_cmd_info *pcip = pc_info(cmd);
 492         if (pcip != NULL)
 493                 return (pcip->name);
 494         (void) sprintf(invbuf, "ioctl: invalid command %d\n", cmd);
 495         return (invbuf);
 496 }
 497 
 498 /*
 499  * Allocate scan resource, create taskq, then dispatch scan,
 500  * called only if autopm is enabled.
 501  */
 502 int
 503 pm_start_pm_walk(dev_info_t *dip, void *arg)
 504 {
 505         int cmd = *((int *)arg);
 506 #ifdef PMDDEBUG
 507         char *cmdstr = pm_decode_cmd(cmd);
 508 #endif
 509 
 510         if (!PM_GET_PM_INFO(dip) || PM_ISBC(dip))
 511                 return (DDI_WALK_CONTINUE);
 512 
 513         switch (cmd) {
 514         case PM_START_CPUPM:
 515         case PM_START_CPUPM_POLL:
 516                 if (!PM_ISCPU(dip))
 517                         return (DDI_WALK_CONTINUE);
 518                 mutex_enter(&pm_scan_lock);
 519                 if (!PM_CPUPM_DISABLED && !PM_EVENT_CPUPM)
 520                         pm_scan_init(dip);
 521                 mutex_exit(&pm_scan_lock);
 522                 break;
 523         case PM_START_PM:
 524                 mutex_enter(&pm_scan_lock);
 525                 if (PM_ISCPU(dip) && (PM_CPUPM_DISABLED || PM_EVENT_CPUPM)) {
 526                         mutex_exit(&pm_scan_lock);
 527                         return (DDI_WALK_CONTINUE);
 528                 }
 529                 if (autopm_enabled)
 530                         pm_scan_init(dip);
 531                 mutex_exit(&pm_scan_lock);
 532                 break;
 533         }
 534 
 535         /*
 536          * Start doing pm on device: ensure pm_scan data structure initiated,
 537          * no need to guarantee a successful scan run.
 538          */
 539         PMD(PMD_SCAN | PMD_IOCTL, ("ioctl: %s: scan %s@%s(%s#%d)\n", cmdstr,
 540             PM_DEVICE(dip)))
 541         pm_rescan(dip);
 542 
 543         return (DDI_WALK_CONTINUE);
 544 }
 545 
 546 /*
 547  * Bring devices to full power level, then stop scan
 548  */
 549 int
 550 pm_stop_pm_walk(dev_info_t *dip, void *arg)
 551 {
 552         pm_info_t *info = PM_GET_PM_INFO(dip);
 553         int cmd = *((int *)arg);
 554 #ifdef PMDDEBUG
 555         char *cmdstr = pm_decode_cmd(cmd);
 556 #endif
 557 
 558         if (!info)
 559                 return (DDI_WALK_CONTINUE);
 560 
 561         switch (cmd) {
 562         case PM_STOP_PM:
 563                 /*
 564                  * If CPU devices are being managed independently, then don't
 565                  * stop them as part of PM_STOP_PM. Only stop them as part of
 566                  * PM_STOP_CPUPM and PM_RESET_PM.
 567                  */
 568                 if (PM_ISCPU(dip) && PM_POLLING_CPUPM)
 569                         return (DDI_WALK_CONTINUE);
 570                 break;
 571         case PM_STOP_CPUPM:
 572                 /*
 573                  * If stopping CPU devices and this device is not marked
 574                  * as a CPU device, then skip.
 575                  */
 576                 if (!PM_ISCPU(dip))
 577                         return (DDI_WALK_CONTINUE);
 578                 break;
 579         }
 580 
 581         /*
 582          * Stop the current scan, and then bring it back to normal power.
 583          */
 584         if (!PM_ISBC(dip)) {
 585                 PMD(PMD_SCAN | PMD_IOCTL, ("ioctl: %s: stop scan for "
 586                     "%s@%s(%s#%d)\n", cmdstr, PM_DEVICE(dip)))
 587                 pm_scan_stop(dip);
 588         }
 589 
 590         if (!PM_ISBC(dip) && !PM_ISDIRECT(dip) &&
 591             !pm_all_at_normal(dip)) {
 592                 PM_LOCK_DIP(dip);
 593                 if (info->pmi_dev_pm_state & PM_DETACHING) {
 594                         PMD(PMD_ALLNORM, ("ioctl: %s: deferring "
 595                             "all_to_normal because %s@%s(%s#%d) is detaching\n",
 596                             cmdstr, PM_DEVICE(dip)))
 597                         info->pmi_dev_pm_state |= PM_ALLNORM_DEFERRED;
 598                         PM_UNLOCK_DIP(dip);
 599                         return (DDI_WALK_CONTINUE);
 600                 }
 601                 PM_UNLOCK_DIP(dip);
 602                 if (pm_all_to_normal(dip, PM_CANBLOCK_FAIL) != DDI_SUCCESS) {
 603                         PMD(PMD_ERROR, ("ioctl: %s: could not bring %s@%s"
 604                             "(%s#%d) to normal\n", cmdstr, PM_DEVICE(dip)))
 605                 }
 606         }
 607 
 608         return (DDI_WALK_CONTINUE);
 609 }
 610 
 611 static int
 612 pm_start_idledown(dev_info_t *dip, void *arg)
 613 {
 614         int             flag = (int)(intptr_t)arg;
 615         pm_scan_t       *scanp = PM_GET_PM_SCAN(dip);
 616 
 617         if (!scanp)
 618                 return (DDI_WALK_CONTINUE);
 619 
 620         PM_LOCK_DIP(dip);
 621         scanp->ps_idle_down |= flag;
 622         PM_UNLOCK_DIP(dip);
 623         pm_rescan(dip);
 624 
 625         return (DDI_WALK_CONTINUE);
 626 }
 627 
 628 /*ARGSUSED*/
 629 static int
 630 pm_end_idledown(dev_info_t *dip, void *ignore)
 631 {
 632         pm_scan_t       *scanp = PM_GET_PM_SCAN(dip);
 633 
 634         if (!scanp)
 635                 return (DDI_WALK_CONTINUE);
 636 
 637         PM_LOCK_DIP(dip);
 638         /*
 639          * The PMID_TIMERS bits are place holder till idledown expires.
 640          * The bits are also the base for regenerating PMID_SCANS bits.
 641          * While it's up to scan thread to clear up the PMID_SCANS bits
 642          * after each scan run, PMID_TIMERS ensure aggressive scan down
 643          * performance throughout the idledown period.
 644          */
 645         scanp->ps_idle_down &= ~PMID_TIMERS;
 646         PM_UNLOCK_DIP(dip);
 647 
 648         return (DDI_WALK_CONTINUE);
 649 }
 650 
 651 /*ARGSUSED*/
 652 static void
 653 pm_end_idledown_walk(void *ignore)
 654 {
 655         PMD(PMD_IDLEDOWN, ("ioctl: end_idledown: idledown_id(%lx) timer is "
 656             "off\n", (ulong_t)pmstp->pm_idledown_id));
 657 
 658         mutex_enter(&pm_scan_lock);
 659         pmstp->pm_idledown_id = 0;
 660         mutex_exit(&pm_scan_lock);
 661 
 662         ddi_walk_devs(ddi_root_node(), pm_end_idledown, NULL);
 663 }
 664 
 665 /*
 666  * pm_timeout_idledown - keep idledown effect for 10 seconds.
 667  *
 668  * Return 0 if another competing caller scheduled idledown timeout,
 669  * otherwise, return idledown timeout_id.
 670  */
 671 static timeout_id_t
 672 pm_timeout_idledown(void)
 673 {
 674         timeout_id_t    to_id;
 675 
 676         /*
 677          * Keep idle-down in effect for either 10 seconds
 678          * or length of a scan interval, which ever is greater.
 679          */
 680         mutex_enter(&pm_scan_lock);
 681         if (pmstp->pm_idledown_id != 0) {
 682                 to_id = pmstp->pm_idledown_id;
 683                 pmstp->pm_idledown_id = 0;
 684                 mutex_exit(&pm_scan_lock);
 685                 (void) untimeout(to_id);
 686                 mutex_enter(&pm_scan_lock);
 687                 if (pmstp->pm_idledown_id != 0) {
 688                         PMD(PMD_IDLEDOWN, ("ioctl: timeout_idledown: "
 689                             "another caller got it, idledown_id(%lx)!\n",
 690                             (ulong_t)pmstp->pm_idledown_id))
 691                         mutex_exit(&pm_scan_lock);
 692                         return (0);
 693                 }
 694         }
 695         pmstp->pm_idledown_id = timeout(pm_end_idledown_walk, NULL,
 696             PM_IDLEDOWN_TIME * hz);
 697         PMD(PMD_IDLEDOWN, ("ioctl: timeout_idledown: idledown_id(%lx)\n",
 698             (ulong_t)pmstp->pm_idledown_id))
 699         mutex_exit(&pm_scan_lock);
 700 
 701         return (pmstp->pm_idledown_id);
 702 }
 703 
 704 static int
 705 pm_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
 706         struct pollhead **phpp)
 707 {
 708         extern struct pollhead pm_pollhead;     /* common/os/sunpm.c */
 709         int     clone;
 710 
 711         clone = PM_MINOR_TO_CLONE(getminor(dev));
 712         PMD(PMD_IOCTL, ("ioctl: pm_chpoll: clone %d\n", clone))
 713         if ((events & (POLLIN | POLLRDNORM)) && pm_poll_cnt[clone]) {
 714                 *reventsp |= (POLLIN | POLLRDNORM);
 715                 PMD(PMD_IOCTL, ("ioctl: pm_chpoll: reventsp set\n"))
 716         } else {
 717                 *reventsp = 0;
 718                 if (!anyyet) {
 719                         PMD(PMD_IOCTL, ("ioctl: pm_chpoll: not anyyet\n"))
 720                         *phpp = &pm_pollhead;
 721                 }
 722 #ifdef DEBUG
 723                 else {
 724                         PMD(PMD_IOCTL, ("ioctl: pm_chpoll: anyyet\n"))
 725                 }
 726 #endif
 727         }
 728         return (0);
 729 }
 730 
 731 /*
 732  * called by pm_dicard_entries to free up the memory. It also decrements
 733  * pm_poll_cnt, if direct is non zero.
 734  */
 735 static void
 736 pm_free_entries(psce_t *pscep, int clone, int direct)
 737 {
 738         pm_state_change_t       *p;
 739 
 740         if (pscep) {
 741                 p = pscep->psce_out;
 742                 while (p->size) {
 743                         if (direct) {
 744                                 PMD(PMD_IOCTL, ("ioctl: discard: "
 745                                     "pm_poll_cnt[%d] is %d before "
 746                                     "ASSERT\n", clone,
 747                                     pm_poll_cnt[clone]))
 748                                 ASSERT(pm_poll_cnt[clone]);
 749                                 pm_poll_cnt[clone]--;
 750                         }
 751                         kmem_free(p->physpath, p->size);
 752                         p->size = 0;
 753                         if (p == pscep->psce_last)
 754                                 p = pscep->psce_first;
 755                         else
 756                                 p++;
 757                 }
 758                 pscep->psce_out = pscep->psce_first;
 759                 pscep->psce_in = pscep->psce_first;
 760                 mutex_exit(&pscep->psce_lock);
 761         }
 762 }
 763 
 764 /*
 765  * Discard entries for this clone. Calls pm_free_entries to free up memory.
 766  */
 767 static void
 768 pm_discard_entries(int clone)
 769 {
 770         psce_t  *pscep;
 771         int                     direct = 0;
 772 
 773         mutex_enter(&pm_clone_lock);
 774         if ((pscep = pm_psc_clone_to_direct(clone)) != NULL)
 775                 direct = 1;
 776         pm_free_entries(pscep, clone, direct);
 777         pscep = pm_psc_clone_to_interest(clone);
 778         pm_free_entries(pscep, clone, 0);
 779         mutex_exit(&pm_clone_lock);
 780 }
 781 
 782 
 783 static void
 784 pm_set_idle_threshold(dev_info_t *dip, int thresh, int flag)
 785 {
 786         if (!PM_ISBC(dip) && !PM_ISDIRECT(dip)) {
 787                 switch (DEVI(dip)->devi_pm_flags & PMC_THRESH_ALL) {
 788                 case PMC_DEF_THRESH:
 789                 case PMC_CPU_THRESH:
 790                         PMD(PMD_IOCTL, ("ioctl: set_idle_threshold: set "
 791                             "%s@%s(%s#%d) default thresh to 0t%d\n",
 792                             PM_DEVICE(dip), thresh))
 793                         pm_set_device_threshold(dip, thresh, flag);
 794                         break;
 795                 default:
 796                         break;
 797                 }
 798         }
 799 }
 800 
 801 static int
 802 pm_set_idle_thresh_walk(dev_info_t *dip, void *arg)
 803 {
 804         int cmd = *((int *)arg);
 805 
 806         if (!PM_GET_PM_INFO(dip))
 807                 return (DDI_WALK_CONTINUE);
 808 
 809         switch (cmd) {
 810         case PM_SET_SYSTEM_THRESHOLD:
 811                 if (DEVI(dip)->devi_pm_flags & PMC_CPU_THRESH)
 812                         break;
 813                 pm_set_idle_threshold(dip, pm_system_idle_threshold,
 814                     PMC_DEF_THRESH);
 815                 pm_rescan(dip);
 816                 break;
 817         case PM_SET_CPU_THRESHOLD:
 818                 if (!PM_ISCPU(dip))
 819                         break;
 820                 pm_set_idle_threshold(dip, pm_cpu_idle_threshold,
 821                     PMC_CPU_THRESH);
 822                 pm_rescan(dip);
 823                 break;
 824         }
 825 
 826         return (DDI_WALK_CONTINUE);
 827 }
 828 
 829 /*ARGSUSED*/
 830 static int
 831 pm_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
 832 {
 833         dev_t   dev;
 834         int     instance;
 835 
 836         switch (infocmd) {
 837         case DDI_INFO_DEVT2DEVINFO:
 838                 if (pmstp->pm_instance == -1)
 839                         return (DDI_FAILURE);
 840                 *result = pmstp->pm_dip;
 841                 return (DDI_SUCCESS);
 842 
 843         case DDI_INFO_DEVT2INSTANCE:
 844                 dev = (dev_t)arg;
 845                 instance = getminor(dev) >> 8;
 846                 *result = (void *)(uintptr_t)instance;
 847                 return (DDI_SUCCESS);
 848 
 849         default:
 850                 return (DDI_FAILURE);
 851         }
 852 }
 853 
 854 
 855 /*ARGSUSED1*/
 856 static int
 857 pm_open(dev_t *devp, int flag, int otyp, cred_t *cr)
 858 {
 859         int             clone;
 860 
 861         if (otyp != OTYP_CHR)
 862                 return (EINVAL);
 863 
 864         mutex_enter(&pm_clone_lock);
 865         for (clone = 1; clone < PM_MAX_CLONE; clone++)
 866                 if (!pmstp->pm_clones[clone])
 867                         break;
 868 
 869         if (clone == PM_MAX_CLONE) {
 870                 mutex_exit(&pm_clone_lock);
 871                 return (ENXIO);
 872         }
 873         pmstp->pm_cred[clone] = cr;
 874         crhold(cr);
 875 
 876         *devp = makedevice(getmajor(*devp), (pmstp->pm_instance << 8) + clone);
 877         pmstp->pm_clones[clone] = 1;
 878         mutex_exit(&pm_clone_lock);
 879 
 880         return (0);
 881 }
 882 
 883 /*ARGSUSED1*/
 884 static int
 885 pm_close(dev_t dev, int flag, int otyp, cred_t *cr)
 886 {
 887         int clone;
 888 
 889         if (otyp != OTYP_CHR)
 890                 return (EINVAL);
 891 
 892         clone = PM_MINOR_TO_CLONE(getminor(dev));
 893         PMD(PMD_CLOSE, ("pm_close: minor %x, clone %x\n", getminor(dev),
 894             clone))
 895 
 896         /*
 897          * Walk the entire device tree to find the corresponding
 898          * device and operate on it.
 899          */
 900         ddi_walk_devs(ddi_root_node(), pm_close_direct_pm_device,
 901             (void *) &clone);
 902 
 903         crfree(pmstp->pm_cred[clone]);
 904         pmstp->pm_cred[clone] = 0;
 905         pmstp->pm_clones[clone] = 0;
 906         pm_discard_entries(clone);
 907         ASSERT(pm_poll_cnt[clone] == 0);
 908         pm_deregister_watcher(clone, NULL);
 909         return (0);
 910 }
 911 
 912 /*ARGSUSED*/
 913 static int
 914 pm_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval_p)
 915 {
 916         struct pm_cmd_info *pc_info(int);
 917         struct pm_cmd_info *pcip = pc_info(cmd);
 918         pm_req_t        req;
 919         dev_info_t      *dip = NULL;
 920         pm_info_t       *info = NULL;
 921         int             clone;
 922         char            *cmdstr = pm_decode_cmd(cmd);
 923         /*
 924          * To keep devinfo nodes from going away while we're holding a
 925          * pointer to their dip, pm_name_to_dip() optionally holds
 926          * the devinfo node.  If we've done that, we set dipheld
 927          * so we know at the end of the ioctl processing to release the
 928          * node again.
 929          */
 930         int             dipheld = 0;
 931         int             icount = 0;
 932         int             i;
 933         int             comps;
 934         size_t          lencopied;
 935         int             ret = ENOTTY;
 936         int             curpower;
 937         char            who[MAXNAMELEN];
 938         size_t          wholen;                 /* copyinstr length */
 939         size_t          deplen = MAXNAMELEN;
 940         char            *dep, i_dep_buf[MAXNAMELEN];
 941         char            pathbuf[MAXNAMELEN];
 942         struct pm_component *cp;
 943 #ifdef  _MULTI_DATAMODEL
 944         pm_state_change32_t             *pscp32;
 945         pm_state_change32_t             psc32;
 946         pm_searchargs32_t               psa32;
 947         size_t                          copysize32;
 948 #endif
 949         pm_state_change_t               *pscp;
 950         pm_state_change_t               psc;
 951         pm_searchargs_t         psa;
 952         char            listname[MAXCOPYBUF];
 953         char            manufacturer[MAXCOPYBUF];
 954         char            product[MAXCOPYBUF];
 955         size_t          copysize;
 956 
 957         PMD(PMD_IOCTL, ("ioctl: %s: begin\n", cmdstr))
 958 
 959 #ifdef DEBUG
 960         if (cmd == 666) {
 961                 ddi_walk_devs(ddi_root_node(), print_info, NULL);
 962                 return (0);
 963         }
 964         ret = 0x0badcafe;                       /* sanity checking */
 965         pm_cmd = cmd;                           /* for ASSERT debugging */
 966         pm_cmd_string = cmdstr; /* for ASSERT debugging */
 967 #endif
 968 
 969 
 970         if (pcip == NULL) {
 971                 PMD(PMD_ERROR, ("ioctl: unknown command %d\n", cmd))
 972                 return (ENOTTY);
 973         }
 974         if (pcip == NULL || pcip->supported == 0) {
 975                 PMD(PMD_ERROR, ("ioctl: command %s no longer supported\n",
 976                     pcip->name))
 977                 return (ENOTTY);
 978         }
 979 
 980         wholen = 0;
 981         dep = i_dep_buf;
 982         i_dep_buf[0] = 0;
 983         clone = PM_MINOR_TO_CLONE(getminor(dev));
 984         if (!pm_perms(pcip->permission, pmstp->pm_cred[clone])) {
 985                 ret = EPERM;
 986                 return (ret);
 987         }
 988         switch (pcip->str_type) {
 989         case PM_REQ:
 990         {
 991 #ifdef  _MULTI_DATAMODEL
 992                 if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
 993                         pm_req32_t      req32;
 994 
 995                         if (ddi_copyin((caddr_t)arg, &req32,
 996                             sizeof (req32), mode) != 0) {
 997                                 PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
 998                                     "EFAULT\n\n", cmdstr))
 999                                 ret = EFAULT;
1000                                 break;
1001                         }
1002                         req.component = req32.component;
1003                         req.value = req32.value;
1004                         req.datasize = req32.datasize;
1005                         if (pcip->inargs & INWHO) {
1006                                 ret = copyinstr((char *)(uintptr_t)
1007                                     req32.physpath, who, MAXNAMELEN, &wholen);
1008                                 if (ret) {
1009                                         PMD(PMD_ERROR, ("ioctl: %s: "
1010                                             "copyinstr fails returning %d\n",
1011                                             cmdstr, ret))
1012                                         break;
1013                                 }
1014                                 req.physpath = who;
1015                                 PMD(PMD_IOCTL, ("ioctl: %s: physpath=%s\n",
1016                                     cmdstr, req.physpath))
1017                         }
1018                         if (pcip->inargs & INDATA) {
1019                                 req.data = (void *)(uintptr_t)req32.data;
1020                                 req.datasize = req32.datasize;
1021                         } else {
1022                                 req.data = NULL;
1023                                 req.datasize = 0;
1024                         }
1025                         switch (pcip->diptype) {
1026                         case DIP:
1027                                 if (!(dip =
1028                                     pm_name_to_dip(req.physpath, 1))) {
1029                                         PMD(PMD_ERROR, ("ioctl: %s: "
1030                                             "pm_name_to_dip for %s failed\n",
1031                                             cmdstr, req.physpath))
1032                                         return (ENODEV);
1033                                 }
1034                                 ASSERT(!dipheld);
1035                                 dipheld++;
1036                                 break;
1037                         case NODIP:
1038                                 break;
1039                         default:
1040                                 /*
1041                                  * Internal error, invalid ioctl description
1042                                  * force debug entry even if pm_debug not set
1043                                  */
1044 #ifdef  DEBUG
1045                                 pm_log("invalid diptype %d for cmd %d (%s)\n",
1046                                     pcip->diptype, cmd, pcip->name);
1047 #endif
1048                                 ASSERT(0);
1049                                 return (EIO);
1050                         }
1051                         if (pcip->inargs & INDATAINT) {
1052                                 int32_t int32buf;
1053                                 int32_t *i32p;
1054                                 int *ip;
1055                                 icount = req32.datasize / sizeof (int32_t);
1056                                 if (icount <= 0) {
1057                                         PMD(PMD_ERROR, ("ioctl: %s: datasize"
1058                                             " 0 or neg EFAULT\n\n", cmdstr))
1059                                         ret = EFAULT;
1060                                         break;
1061                                 }
1062                                 ASSERT(!(pcip->inargs & INDATASTRING));
1063                                 req.datasize = icount * sizeof (int);
1064                                 req.data = kmem_alloc(req.datasize, KM_SLEEP);
1065                                 ip = req.data;
1066                                 ret = 0;
1067                                 for (i = 0,
1068                                     i32p = (int32_t *)(uintptr_t)req32.data;
1069                                     i < icount; i++, i32p++) {
1070                                         if (ddi_copyin((void *)i32p, &int32buf,
1071                                             sizeof (int32_t), mode)) {
1072                                                 kmem_free(req.data,
1073                                                     req.datasize);
1074                                                 PMD(PMD_ERROR, ("ioctl: %s: "
1075                                                     "entry %d EFAULT\n",
1076                                                     cmdstr, i))
1077                                                 ret = EFAULT;
1078                                                 break;
1079                                         }
1080                                         *ip++ = (int)int32buf;
1081                                 }
1082                                 if (ret)
1083                                         break;
1084                         }
1085                         if (pcip->inargs & INDATASTRING) {
1086                                 ASSERT(!(pcip->inargs & INDATAINT));
1087                                 ASSERT(pcip->deptype == DEP);
1088                                 if (req32.data != NULL) {
1089                                         if (copyinstr((void *)(uintptr_t)
1090                                             req32.data, dep, deplen, NULL)) {
1091                                                 PMD(PMD_ERROR, ("ioctl: %s: "
1092                                                     "0x%p dep size %lx, EFAULT"
1093                                                     "\n", cmdstr,
1094                                                     (void *)req.data, deplen))
1095                                                 ret = EFAULT;
1096                                                 break;
1097                                         }
1098 #ifdef DEBUG
1099                                         else {
1100                                                 PMD(PMD_DEP, ("ioctl: %s: "
1101                                                     "dep %s\n", cmdstr, dep))
1102                                         }
1103 #endif
1104                                 } else {
1105                                         PMD(PMD_ERROR, ("ioctl: %s: no "
1106                                             "dependent\n", cmdstr))
1107                                         ret = EINVAL;
1108                                         break;
1109                                 }
1110                         }
1111                 } else
1112 #endif /* _MULTI_DATAMODEL */
1113                 {
1114                         if (ddi_copyin((caddr_t)arg,
1115                             &req, sizeof (req), mode) != 0) {
1116                                 PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
1117                                     "EFAULT\n\n", cmdstr))
1118                                 ret = EFAULT;
1119                                 break;
1120                         }
1121                         if (pcip->inargs & INWHO) {
1122                                 ret = copyinstr((char *)req.physpath, who,
1123                                     MAXNAMELEN, &wholen);
1124                                 if (ret) {
1125                                         PMD(PMD_ERROR, ("ioctl: %s copyinstr"
1126                                             " fails returning %d\n", cmdstr,
1127                                             ret))
1128                                         break;
1129                                 }
1130                                 req.physpath = who;
1131                                 PMD(PMD_IOCTL, ("ioctl: %s: physpath=%s\n",
1132                                     cmdstr, req.physpath))
1133                         }
1134                         if (!(pcip->inargs & INDATA)) {
1135                                 req.data = NULL;
1136                                 req.datasize = 0;
1137                         }
1138                         switch (pcip->diptype) {
1139                         case DIP:
1140                                 if (!(dip =
1141                                     pm_name_to_dip(req.physpath, 1))) {
1142                                         PMD(PMD_ERROR, ("ioctl: %s: "
1143                                             "pm_name_to_dip for %s failed\n",
1144                                             cmdstr, req.physpath))
1145                                         return (ENODEV);
1146                                 }
1147                                 ASSERT(!dipheld);
1148                                 dipheld++;
1149                                 break;
1150                         case NODIP:
1151                                 break;
1152                         default:
1153                                 /*
1154                                  * Internal error, invalid ioctl description
1155                                  * force debug entry even if pm_debug not set
1156                                  */
1157 #ifdef  DEBUG
1158                                 pm_log("invalid diptype %d for cmd %d (%s)\n",
1159                                     pcip->diptype, cmd, pcip->name);
1160 #endif
1161                                 ASSERT(0);
1162                                 return (EIO);
1163                         }
1164                         if (pcip->inargs & INDATAINT) {
1165                                 int *ip;
1166 
1167                                 ASSERT(!(pcip->inargs & INDATASTRING));
1168                                 ip = req.data;
1169                                 icount = req.datasize / sizeof (int);
1170                                 if (icount <= 0) {
1171                                         PMD(PMD_ERROR, ("ioctl: %s: datasize"
1172                                             " 0 or neg EFAULT\n\n", cmdstr))
1173                                         ret = EFAULT;
1174                                         break;
1175                                 }
1176                                 req.data = kmem_alloc(req.datasize, KM_SLEEP);
1177                                 if (ddi_copyin((caddr_t)ip, req.data,
1178                                     req.datasize, mode) != 0) {
1179                                         PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
1180                                             "EFAULT\n\n", cmdstr))
1181                                         ret = EFAULT;
1182                                         break;
1183                                 }
1184                         }
1185                         if (pcip->inargs & INDATASTRING) {
1186                                 ASSERT(!(pcip->inargs & INDATAINT));
1187                                 ASSERT(pcip->deptype == DEP);
1188                                 if (req.data != NULL) {
1189                                         if (copyinstr((caddr_t)req.data,
1190                                             dep, deplen, NULL)) {
1191                                                 PMD(PMD_ERROR, ("ioctl: %s: "
1192                                                     "0x%p dep size %lu, "
1193                                                     "EFAULT\n", cmdstr,
1194                                                     (void *)req.data, deplen))
1195                                                 ret = EFAULT;
1196                                                 break;
1197                                         }
1198 #ifdef DEBUG
1199                                         else {
1200                                                 PMD(PMD_DEP, ("ioctl: %s: "
1201                                                     "dep %s\n", cmdstr, dep))
1202                                         }
1203 #endif
1204                                 } else {
1205                                         PMD(PMD_ERROR, ("ioctl: %s: no "
1206                                             "dependent\n", cmdstr))
1207                                         ret = EINVAL;
1208                                         break;
1209                                 }
1210                         }
1211                 }
1212                 /*
1213                  * Now we've got all the args in for the commands that
1214                  * use the new pm_req struct.
1215                  */
1216                 switch (cmd) {
1217                 case PM_REPARSE_PM_PROPS:
1218                 {
1219                         struct dev_ops  *drv;
1220                         struct cb_ops   *cb;
1221                         void            *propval;
1222                         int length;
1223                         /*
1224                          * This ioctl is provided only for the ddivs pm test.
1225                          * We only do it to a driver which explicitly allows
1226                          * us to do so by exporting a pm-reparse-ok property.
1227                          * We only care whether the property exists or not.
1228                          */
1229                         if ((drv = ddi_get_driver(dip)) == NULL) {
1230                                 ret = EINVAL;
1231                                 break;
1232                         }
1233                         if ((cb = drv->devo_cb_ops) != NULL) {
1234                                 if ((*cb->cb_prop_op)(DDI_DEV_T_ANY, dip,
1235                                     PROP_LEN_AND_VAL_ALLOC, (DDI_PROP_CANSLEEP |
1236                                     DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
1237                                     "pm-reparse-ok", (caddr_t)&propval,
1238                                     &length) != DDI_SUCCESS) {
1239                                         ret = EINVAL;
1240                                         break;
1241                                 }
1242                         } else if (ddi_prop_op(DDI_DEV_T_ANY, dip,
1243                             PROP_LEN_AND_VAL_ALLOC, (DDI_PROP_CANSLEEP |
1244                             DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
1245                             "pm-reparse-ok", (caddr_t)&propval,
1246                             &length) != DDI_SUCCESS) {
1247                                 ret = EINVAL;
1248                                 break;
1249                         }
1250                         kmem_free(propval, length);
1251                         ret =  e_new_pm_props(dip);
1252                         break;
1253                 }
1254 
1255                 case PM_GET_DEVICE_THRESHOLD:
1256                 {
1257                         PM_LOCK_DIP(dip);
1258                         if (!PM_GET_PM_INFO(dip) || PM_ISBC(dip)) {
1259                                 PM_UNLOCK_DIP(dip);
1260                                 PMD(PMD_ERROR, ("ioctl: %s: ENODEV\n",
1261                                     cmdstr))
1262                                 ret = ENODEV;
1263                                 break;
1264                         }
1265                         *rval_p = DEVI(dip)->devi_pm_dev_thresh;
1266                         PM_UNLOCK_DIP(dip);
1267                         ret = 0;
1268                         break;
1269                 }
1270 
1271                 case PM_DIRECT_PM:
1272                 {
1273                         int has_dep;
1274                         if ((info = PM_GET_PM_INFO(dip)) == NULL) {
1275                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1276                                     "ENODEV\n", cmdstr))
1277                                 ret = ENODEV;
1278                                 break;
1279                         }
1280                         /*
1281                          * Check to see if we are there is a dependency on
1282                          * this kept device, if so, return EBUSY.
1283                          */
1284                         (void) ddi_pathname(dip, pathbuf);
1285                         pm_dispatch_to_dep_thread(PM_DEP_WK_CHECK_KEPT,
1286                             NULL, pathbuf, PM_DEP_WAIT, &has_dep, 0);
1287                         if (has_dep) {
1288                                 PMD(PMD_ERROR | PMD_DPM, ("%s EBUSY\n",
1289                                     cmdstr))
1290                                 ret = EBUSY;
1291                                 break;
1292                         }
1293                         PM_LOCK_DIP(dip);
1294                         if (PM_ISDIRECT(dip) || (info->pmi_clone != 0)) {
1295                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1296                                     "%s@%s(%s#%d): EBUSY\n", cmdstr,
1297                                     PM_DEVICE(dip)))
1298                                 PM_UNLOCK_DIP(dip);
1299                                 ret = EBUSY;
1300                                 break;
1301                         }
1302                         info->pmi_dev_pm_state |= PM_DIRECT;
1303                         info->pmi_clone = clone;
1304                         PM_UNLOCK_DIP(dip);
1305                         PMD(PMD_DPM, ("ioctl: %s: info %p, pmi_clone %d\n",
1306                             cmdstr, (void *)info, clone))
1307                         mutex_enter(&pm_clone_lock);
1308                         pm_register_watcher(clone, dip);
1309                         mutex_exit(&pm_clone_lock);
1310                         ret = 0;
1311                         break;
1312                 }
1313 
1314                 case PM_RELEASE_DIRECT_PM:
1315                 {
1316                         if ((info = PM_GET_PM_INFO(dip)) == NULL) {
1317                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1318                                     "ENODEV\n", cmdstr))
1319                                 ret = ENODEV;
1320                                 break;
1321                         }
1322                         PM_LOCK_DIP(dip);
1323                         if (info->pmi_clone != clone) {
1324                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1325                                     "%s@%s(%s#%d) EINVAL\n", cmdstr,
1326                                     PM_DEVICE(dip)))
1327                                 ret = EINVAL;
1328                                 PM_UNLOCK_DIP(dip);
1329                                 break;
1330                         }
1331                         ASSERT(PM_ISDIRECT(dip));
1332                         info->pmi_dev_pm_state &= ~PM_DIRECT;
1333                         PM_UNLOCK_DIP(dip);
1334                         /* Bring ourselves up if there is a keeper. */
1335                         (void) ddi_pathname(dip, pathbuf);
1336                         pm_dispatch_to_dep_thread(PM_DEP_WK_BRINGUP_SELF,
1337                             NULL, pathbuf, PM_DEP_WAIT, NULL, 0);
1338                         pm_discard_entries(clone);
1339                         pm_deregister_watcher(clone, dip);
1340                         /*
1341                          * Now we could let the other threads that are
1342                          * trying to do a DIRECT_PM thru
1343                          */
1344                         PM_LOCK_DIP(dip);
1345                         info->pmi_clone = 0;
1346                         PM_UNLOCK_DIP(dip);
1347                         pm_proceed(dip, PMP_RELEASE, -1, -1);
1348                         PMD(PMD_RESCAN | PMD_DPM, ("ioctl: %s: rescan\n",
1349                             cmdstr))
1350                         pm_rescan(dip);
1351                         ret = 0;
1352                         break;
1353                 }
1354 
1355                 case PM_SET_CURRENT_POWER:
1356                 {
1357                         int comp = req.component;
1358                         int  value = req.value;
1359                         PMD(PMD_DPM, ("ioctl: %s: %s component %d to value "
1360                             "%d\n", cmdstr, req.physpath, comp, value))
1361                         if (!e_pm_valid_comp(dip, comp, NULL) ||
1362                             !e_pm_valid_power(dip, comp, value)) {
1363                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1364                                     "physpath=%s, comp=%d, level=%d, fails\n",
1365                                     cmdstr, req.physpath, comp, value))
1366                                 ret = EINVAL;
1367                                 break;
1368                         }
1369 
1370                         if ((info = PM_GET_PM_INFO(dip)) == NULL) {
1371                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1372                                     "ENODEV\n", cmdstr))
1373                                 ret = ENODEV;
1374                                 break;
1375                         }
1376                         if (info->pmi_clone != clone) {
1377                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1378                                     "(not owner) %s fails; clone %d, owner %d"
1379                                     "\n", cmdstr, req.physpath, clone,
1380                                     info->pmi_clone))
1381                                 ret = EINVAL;
1382                                 break;
1383                         }
1384                         ASSERT(PM_ISDIRECT(dip));
1385 
1386                         if (pm_set_power(dip, comp, value, PM_LEVEL_EXACT,
1387                             PM_CANBLOCK_BLOCK, 0, &ret) != DDI_SUCCESS) {
1388                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s: "
1389                                     "pm_set_power for %s fails, errno=%d\n",
1390                                     cmdstr, req.physpath, ret))
1391                                 break;
1392                         }
1393 
1394                         pm_proceed(dip, PMP_SETPOWER, comp, value);
1395 
1396                         /*
1397                          * Power down all idle components if console framebuffer
1398                          * is powered off.
1399                          */
1400                         if (PM_IS_CFB(dip) && (pm_system_idle_threshold ==
1401                             pm_default_idle_threshold)) {
1402                                 dev_info_t      *root = ddi_root_node();
1403                                 if (PM_ISBC(dip)) {
1404                                         if (comp == 0 && value == 0 &&
1405                                             (pm_timeout_idledown() != 0)) {
1406                                                 ddi_walk_devs(root,
1407                                                     pm_start_idledown,
1408                                                     (void *)PMID_CFB);
1409                                         }
1410                                 } else {
1411                                         int count = 0;
1412                                         for (i = 0; i < PM_NUMCMPTS(dip); i++) {
1413                                                 ret = pm_get_current_power(dip,
1414                                                     i, &curpower);
1415                                                 if (ret == DDI_SUCCESS &&
1416                                                     curpower == 0)
1417                                                         count++;
1418                                         }
1419                                         if ((count == PM_NUMCMPTS(dip)) &&
1420                                             (pm_timeout_idledown() != 0)) {
1421                                                 ddi_walk_devs(root,
1422                                                     pm_start_idledown,
1423                                                     (void *)PMID_CFB);
1424                                         }
1425                                 }
1426                         }
1427 
1428                         PMD(PMD_RESCAN | PMD_DPM, ("ioctl: %s: rescan\n",
1429                             cmdstr))
1430                         pm_rescan(dip);
1431                         *rval_p = 0;
1432                         ret = 0;
1433                         break;
1434                 }
1435 
1436                 case PM_GET_FULL_POWER:
1437                 {
1438                         int normal;
1439                         ASSERT(dip);
1440                         PMD(PMD_NORM, ("ioctl: %s: %s component %d\n",
1441                             cmdstr, req.physpath, req.component))
1442                         normal =  pm_get_normal_power(dip, req.component);
1443 
1444                         if (normal == DDI_FAILURE) {
1445                                 PMD(PMD_ERROR | PMD_NORM, ("ioctl: %s: "
1446                                     "returns EINVAL\n", cmdstr))
1447                                 ret = EINVAL;
1448                                 break;
1449                         }
1450                         *rval_p = normal;
1451                         PMD(PMD_NORM, ("ioctl: %s: returns %d\n",
1452                             cmdstr, normal))
1453                         ret = 0;
1454                         break;
1455                 }
1456 
1457                 case PM_GET_CURRENT_POWER:
1458                 {
1459                         if (pm_get_current_power(dip, req.component,
1460                             rval_p) != DDI_SUCCESS) {
1461                                 PMD(PMD_ERROR | PMD_DPM, ("ioctl: %s "
1462                                     "EINVAL\n", cmdstr))
1463                                 ret = EINVAL;
1464                                 break;
1465                         }
1466                         PMD(PMD_DPM, ("ioctl: %s: %s comp %d returns %d\n",
1467                             cmdstr, req.physpath, req.component, *rval_p))
1468                         if (*rval_p == PM_LEVEL_UNKNOWN)
1469                                 ret = EAGAIN;
1470                         else
1471                                 ret = 0;
1472                         break;
1473                 }
1474 
1475                 case PM_GET_TIME_IDLE:
1476                 {
1477                         time_t timestamp;
1478                         int comp = req.component;
1479                         pm_component_t *cp;
1480                         if (!e_pm_valid_comp(dip, comp, &cp)) {
1481                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
1482                                     "component %d > numcmpts - 1 %d--EINVAL\n",
1483                                     cmdstr, PM_DEVICE(dip), comp,
1484                                     PM_NUMCMPTS(dip) - 1))
1485                                 ret = EINVAL;
1486                                 break;
1487                         }
1488                         timestamp = cp->pmc_timestamp;
1489                         if (timestamp) {
1490                                 time_t now;
1491                                 (void) drv_getparm(TIME, &now);
1492                                 *rval_p = (now - timestamp);
1493                         } else {
1494                                 *rval_p = 0;
1495                         }
1496                         ret = 0;
1497                         break;
1498                 }
1499 
1500                 case PM_ADD_DEPENDENT:
1501                 {
1502                         dev_info_t      *kept_dip;
1503 
1504                         PMD(PMD_KEEPS, ("%s, kept %s, keeper %s\n", cmdstr,
1505                             dep, req.physpath))
1506 
1507                         /*
1508                          * hold and install kept while processing dependency
1509                          * keeper (in .physpath) has already been held.
1510                          */
1511                         if (dep[0] == '\0') {
1512                                 PMD(PMD_ERROR, ("kept NULL or null\n"))
1513                                 ret = EINVAL;
1514                                 break;
1515                         } else if ((kept_dip =
1516                             pm_name_to_dip(dep, 1)) == NULL) {
1517                                 PMD(PMD_ERROR, ("no dip for kept %s\n", dep))
1518                                 ret = ENODEV;
1519                                 break;
1520                         } else if (kept_dip == dip) {
1521                                 PMD(PMD_ERROR, ("keeper(%s, %p) - kept(%s, %p) "
1522                                     "self-dependency not allowed.\n",
1523                                     dep, (void *)kept_dip, req.physpath,
1524                                     (void *) dip))
1525                                 PM_RELE(dip);   /* release "double" hold */
1526                                 ret = EINVAL;
1527                                 break;
1528                         }
1529                         ASSERT(!(strcmp(req.physpath, (char *)dep) == 0));
1530 
1531                         /*
1532                          * record dependency, then walk through device tree
1533                          * independently on behalf of kept and keeper to
1534                          * establish newly created dependency.
1535                          */
1536                         pm_dispatch_to_dep_thread(PM_DEP_WK_RECORD_KEEPER,
1537                             req.physpath, dep, PM_DEP_WAIT, NULL, 0);
1538 
1539                         /*
1540                          * release kept after establishing dependency, keeper
1541                          * is released as part of ioctl exit processing.
1542                          */
1543                         PM_RELE(kept_dip);
1544                         *rval_p = 0;
1545                         ret = 0;
1546                         break;
1547                 }
1548 
1549                 case PM_ADD_DEPENDENT_PROPERTY:
1550                 {
1551                         char *keeper, *kept;
1552 
1553                         if (dep[0] == '\0') {
1554                                 PMD(PMD_ERROR, ("ioctl: %s: dep NULL or "
1555                                     "null\n", cmdstr))
1556                                 ret = EINVAL;
1557                                 break;
1558                         }
1559                         kept = dep;
1560                         keeper = req.physpath;
1561                         /*
1562                          * record keeper - kept dependency, then walk through
1563                          * device tree to find out all attached keeper, walk
1564                          * through again to apply dependency to all the
1565                          * potential kept.
1566                          */
1567                         pm_dispatch_to_dep_thread(
1568                             PM_DEP_WK_RECORD_KEEPER_PROP, keeper, kept,
1569                             PM_DEP_WAIT, NULL, 0);
1570 
1571                         *rval_p = 0;
1572                         ret = 0;
1573                         break;
1574                 }
1575 
1576                 case PM_SET_DEVICE_THRESHOLD:
1577                 {
1578                         pm_thresh_rec_t *rp;
1579                         pm_pte_t *ep;   /* threshold header storage */
1580                         int *tp;        /* threshold storage */
1581                         size_t size;
1582                         extern int pm_thresh_specd(dev_info_t *);
1583 
1584                         /*
1585                          * The header struct plus one entry struct plus one
1586                          * threshold plus the length of the string
1587                          */
1588                         size = sizeof (pm_thresh_rec_t) +
1589                             (sizeof (pm_pte_t) * 1) +
1590                             (1 * sizeof (int)) +
1591                             strlen(req.physpath) + 1;
1592 
1593                         rp = kmem_zalloc(size, KM_SLEEP);
1594                         rp->ptr_size = size;
1595                         rp->ptr_numcomps = 0;        /* means device threshold */
1596                         ep = (pm_pte_t *)((intptr_t)rp + sizeof (*rp));
1597                         rp->ptr_entries = ep;
1598                         tp = (int *)((intptr_t)ep +
1599                             (1 * sizeof (pm_pte_t)));
1600                         ep->pte_numthresh = 1;
1601                         ep->pte_thresh = tp;
1602                         *tp++ = req.value;
1603                         (void) strcat((char *)tp, req.physpath);
1604                         rp->ptr_physpath = (char *)tp;
1605                         ASSERT((intptr_t)tp + strlen(req.physpath) + 1 ==
1606                             (intptr_t)rp + rp->ptr_size);
1607                         PMD(PMD_THRESH, ("ioctl: %s: record thresh %d for "
1608                             "%s\n", cmdstr, req.value, req.physpath))
1609                         pm_record_thresh(rp);
1610                         /*
1611                          * Don't free rp, pm_record_thresh() keeps it.
1612                          * We don't try to apply it ourselves because we'd need
1613                          * to know too much about locking.  Since we don't
1614                          * hold a lock the entry could be removed before
1615                          * we get here
1616                          */
1617                         ASSERT(dip == NULL);
1618                         ret = 0;                /* can't fail now */
1619                         if (!(dip = pm_name_to_dip(req.physpath, 1))) {
1620                                 break;
1621                         }
1622                         (void) pm_thresh_specd(dip);
1623                         PMD(PMD_DHR, ("ioctl: %s: releasing %s@%s(%s#%d)\n",
1624                             cmdstr, PM_DEVICE(dip)))
1625                         PM_RELE(dip);
1626                         break;
1627                 }
1628 
1629                 case PM_RESET_DEVICE_THRESHOLD:
1630                 {
1631                         /*
1632                          * This only applies to a currently attached and power
1633                          * managed node
1634                          */
1635                         /*
1636                          * We don't do this to old-style drivers
1637                          */
1638                         info = PM_GET_PM_INFO(dip);
1639                         if (info == NULL) {
1640                                 PMD(PMD_ERROR, ("ioctl: %s: %s not power "
1641                                     "managed\n", cmdstr, req.physpath))
1642                                 ret = EINVAL;
1643                                 break;
1644                         }
1645                         if (PM_ISBC(dip)) {
1646                                 PMD(PMD_ERROR, ("ioctl: %s: %s is BC\n",
1647                                     cmdstr, req.physpath))
1648                                 ret = EINVAL;
1649                                 break;
1650                         }
1651                         pm_unrecord_threshold(req.physpath);
1652                         if (DEVI(dip)->devi_pm_flags & PMC_CPU_THRESH)
1653                                 pm_set_device_threshold(dip,
1654                                     pm_cpu_idle_threshold, PMC_CPU_THRESH);
1655                         else
1656                                 pm_set_device_threshold(dip,
1657                                     pm_system_idle_threshold, PMC_DEF_THRESH);
1658                         ret = 0;
1659                         break;
1660                 }
1661 
1662                 case PM_GET_NUM_COMPONENTS:
1663                 {
1664                         ret = 0;
1665                         *rval_p = PM_NUMCMPTS(dip);
1666                         break;
1667                 }
1668 
1669                 case PM_GET_DEVICE_TYPE:
1670                 {
1671                         ret = 0;
1672                         if ((info = PM_GET_PM_INFO(dip)) == NULL) {
1673                                 PMD(PMD_ERROR, ("ioctl: %s: "
1674                                     "PM_NO_PM_COMPONENTS\n", cmdstr))
1675                                 *rval_p = PM_NO_PM_COMPONENTS;
1676                                 break;
1677                         }
1678                         if (PM_ISBC(dip)) {
1679                                 *rval_p = PM_CREATE_COMPONENTS;
1680                         } else {
1681                                 *rval_p = PM_AUTOPM;
1682                         }
1683                         break;
1684                 }
1685 
1686                 case PM_SET_COMPONENT_THRESHOLDS:
1687                 {
1688                         int comps = 0;
1689                         int *end = (int *)req.data + icount;
1690                         pm_thresh_rec_t *rp;
1691                         pm_pte_t *ep;   /* threshold header storage */
1692                         int *tp;        /* threshold storage */
1693                         int *ip;
1694                         int j;
1695                         size_t size;
1696                         extern int pm_thresh_specd(dev_info_t *);
1697                         extern int pm_valid_thresh(dev_info_t *,
1698                             pm_thresh_rec_t *);
1699 
1700                         for (ip = req.data; *ip; ip++) {
1701                                 if (ip >= end) {
1702                                         ret = EFAULT;
1703                                         break;
1704                                 }
1705                                 comps++;
1706                                 /* skip over indicated number of entries */
1707                                 for (j = *ip; j; j--) {
1708                                         if (++ip >= end) {
1709                                                 ret = EFAULT;
1710                                                 break;
1711                                         }
1712                                 }
1713                                 if (ret)
1714                                         break;
1715                         }
1716                         if (ret)
1717                                 break;
1718                         if ((intptr_t)ip != (intptr_t)end - sizeof (int)) {
1719                                 /* did not exactly fill buffer */
1720                                 ret = EINVAL;
1721                                 break;
1722                         }
1723                         if (comps == 0) {
1724                                 PMD(PMD_ERROR, ("ioctl: %s: %s 0 components"
1725                                     "--EINVAL\n", cmdstr, req.physpath))
1726                                 ret = EINVAL;
1727                                 break;
1728                         }
1729                         /*
1730                          * The header struct plus one entry struct per component
1731                          * plus the size of the lists minus the counts
1732                          * plus the length of the string
1733                          */
1734                         size = sizeof (pm_thresh_rec_t) +
1735                             (sizeof (pm_pte_t) * comps) + req.datasize -
1736                             ((comps + 1) * sizeof (int)) +
1737                             strlen(req.physpath) + 1;
1738 
1739                         rp = kmem_zalloc(size, KM_SLEEP);
1740                         rp->ptr_size = size;
1741                         rp->ptr_numcomps = comps;
1742                         ep = (pm_pte_t *)((intptr_t)rp + sizeof (*rp));
1743                         rp->ptr_entries = ep;
1744                         tp = (int *)((intptr_t)ep +
1745                             (comps * sizeof (pm_pte_t)));
1746                         for (ip = req.data; *ip; ep++) {
1747                                 ep->pte_numthresh = *ip;
1748                                 ep->pte_thresh = tp;
1749                                 for (j = *ip++; j; j--) {
1750                                         *tp++ = *ip++;
1751                                 }
1752                         }
1753                         (void) strcat((char *)tp, req.physpath);
1754                         rp->ptr_physpath = (char *)tp;
1755                         ASSERT((intptr_t)end == (intptr_t)ip + sizeof (int));
1756                         ASSERT((intptr_t)tp + strlen(req.physpath) + 1 ==
1757                             (intptr_t)rp + rp->ptr_size);
1758 
1759                         ASSERT(dip == NULL);
1760                         /*
1761                          * If this is not a currently power managed node,
1762                          * then we can't check for validity of the thresholds
1763                          */
1764                         if (!(dip = pm_name_to_dip(req.physpath, 1))) {
1765                                 /* don't free rp, pm_record_thresh uses it */
1766                                 pm_record_thresh(rp);
1767                                 PMD(PMD_ERROR, ("ioctl: %s: pm_name_to_dip "
1768                                     "for %s failed\n", cmdstr, req.physpath))
1769                                 ret = 0;
1770                                 break;
1771                         }
1772                         ASSERT(!dipheld);
1773                         dipheld++;
1774 
1775                         if (!pm_valid_thresh(dip, rp)) {
1776                                 PMD(PMD_ERROR, ("ioctl: %s: invalid thresh "
1777                                     "for %s@%s(%s#%d)\n", cmdstr,
1778                                     PM_DEVICE(dip)))
1779                                 kmem_free(rp, size);
1780                                 ret = EINVAL;
1781                                 break;
1782                         }
1783                         /*
1784                          * We don't just apply it ourselves because we'd need
1785                          * to know too much about locking.  Since we don't
1786                          * hold a lock the entry could be removed before
1787                          * we get here
1788                          */
1789                         pm_record_thresh(rp);
1790                         (void) pm_thresh_specd(dip);
1791                         ret = 0;
1792                         break;
1793                 }
1794 
1795                 case PM_GET_COMPONENT_THRESHOLDS:
1796                 {
1797                         int musthave;
1798                         int numthresholds = 0;
1799                         int wordsize;
1800                         int numcomps;
1801                         caddr_t uaddr = req.data;       /* user address */
1802                         int val;        /* int value to be copied out */
1803                         int32_t val32;  /* int32 value to be copied out */
1804                         caddr_t vaddr;  /* address to copyout from */
1805                         int j;
1806 
1807 #ifdef  _MULTI_DATAMODEL
1808                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
1809                                 wordsize = sizeof (int32_t);
1810                         } else
1811 #endif /* _MULTI_DATAMODEL */
1812                         {
1813                                 wordsize = sizeof (int);
1814                         }
1815 
1816                         ASSERT(dip);
1817 
1818                         numcomps = PM_NUMCMPTS(dip);
1819                         for (i = 0; i < numcomps; i++) {
1820                                 cp = PM_CP(dip, i);
1821                                 numthresholds += cp->pmc_comp.pmc_numlevels - 1;
1822                         }
1823                         musthave = (numthresholds + numcomps + 1) *  wordsize;
1824                         if (req.datasize < musthave) {
1825                                 PMD(PMD_ERROR, ("ioctl: %s: size %ld, need "
1826                                     "%d--EINVAL\n", cmdstr, req.datasize,
1827                                     musthave))
1828                                 ret = EINVAL;
1829                                 break;
1830                         }
1831                         PM_LOCK_DIP(dip);
1832                         for (i = 0; i < numcomps; i++) {
1833                                 int *thp;
1834                                 cp = PM_CP(dip, i);
1835                                 thp = cp->pmc_comp.pmc_thresh;
1836                                 /* first copyout the count */
1837                                 if (wordsize == sizeof (int32_t)) {
1838                                         val32 = cp->pmc_comp.pmc_numlevels - 1;
1839                                         vaddr = (caddr_t)&val32;
1840                                 } else {
1841                                         val = cp->pmc_comp.pmc_numlevels - 1;
1842                                         vaddr = (caddr_t)&val;
1843                                 }
1844                                 if (ddi_copyout(vaddr, (void *)uaddr,
1845                                     wordsize, mode) != 0) {
1846                                         PM_UNLOCK_DIP(dip);
1847                                         PMD(PMD_ERROR, ("ioctl: %s: %s@%s"
1848                                             "(%s#%d) vaddr %p EFAULT\n",
1849                                             cmdstr, PM_DEVICE(dip),
1850                                             (void*)vaddr))
1851                                         ret = EFAULT;
1852                                         break;
1853                                 }
1854                                 vaddr = uaddr;
1855                                 vaddr += wordsize;
1856                                 uaddr = (caddr_t)vaddr;
1857                                 /* then copyout each threshold value */
1858                                 for (j = 0; j < cp->pmc_comp.pmc_numlevels - 1;
1859                                     j++) {
1860                                         if (wordsize == sizeof (int32_t)) {
1861                                                 val32 = thp[j + 1];
1862                                                 vaddr = (caddr_t)&val32;
1863                                         } else {
1864                                                 val = thp[i + 1];
1865                                                 vaddr = (caddr_t)&val;
1866                                         }
1867                                         if (ddi_copyout(vaddr, (void *) uaddr,
1868                                             wordsize, mode) != 0) {
1869                                                 PM_UNLOCK_DIP(dip);
1870                                                 PMD(PMD_ERROR, ("ioctl: %s: "
1871                                                     "%s@%s(%s#%d) uaddr %p "
1872                                                     "EFAULT\n", cmdstr,
1873                                                     PM_DEVICE(dip),
1874                                                     (void *)uaddr))
1875                                                 ret = EFAULT;
1876                                                 break;
1877                                         }
1878                                         vaddr = uaddr;
1879                                         vaddr += wordsize;
1880                                         uaddr = (caddr_t)vaddr;
1881                                 }
1882                         }
1883                         if (ret)
1884                                 break;
1885                         /* last copyout a terminating 0 count */
1886                         if (wordsize == sizeof (int32_t)) {
1887                                 val32 = 0;
1888                                 vaddr = (caddr_t)&val32;
1889                         } else {
1890                                 ASSERT(wordsize == sizeof (int));
1891                                 val = 0;
1892                                 vaddr = (caddr_t)&val;
1893                         }
1894                         if (ddi_copyout(vaddr, uaddr, wordsize, mode) != 0) {
1895                                 PM_UNLOCK_DIP(dip);
1896                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
1897                                     "vaddr %p (0 count) EFAULT\n", cmdstr,
1898                                     PM_DEVICE(dip), (void *)vaddr))
1899                                 ret = EFAULT;
1900                                 break;
1901                         }
1902                         /* finished, so don't need to increment addresses */
1903                         PM_UNLOCK_DIP(dip);
1904                         ret = 0;
1905                         break;
1906                 }
1907 
1908                 case PM_GET_STATS:
1909                 {
1910                         time_t now;
1911                         time_t *timestamp;
1912                         extern int pm_cur_power(pm_component_t *cp);
1913                         int musthave;
1914                         int wordsize;
1915 
1916 #ifdef  _MULTI_DATAMODEL
1917                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
1918                                 wordsize = sizeof (int32_t);
1919                         } else
1920 #endif /* _MULTI_DATAMODEL */
1921                         {
1922                                 wordsize = sizeof (int);
1923                         }
1924 
1925                         comps = PM_NUMCMPTS(dip);
1926                         if (comps == 0 || PM_GET_PM_INFO(dip) == NULL) {
1927                                 PMD(PMD_ERROR, ("ioctl: %s: %s no components"
1928                                     " or not power managed--EINVAL\n", cmdstr,
1929                                     req.physpath))
1930                                 ret = EINVAL;
1931                                 break;
1932                         }
1933                         musthave = comps * 2 * wordsize;
1934                         if (req.datasize < musthave) {
1935                                 PMD(PMD_ERROR, ("ioctl: %s: size %lu, need "
1936                                     "%d--EINVAL\n", cmdstr, req.datasize,
1937                                     musthave))
1938                                 ret = EINVAL;
1939                                 break;
1940                         }
1941 
1942                         PM_LOCK_DIP(dip);
1943                         (void) drv_getparm(TIME, &now);
1944                         timestamp = kmem_zalloc(comps * sizeof (time_t),
1945                             KM_SLEEP);
1946                         pm_get_timestamps(dip, timestamp);
1947                         /*
1948                          * First the current power levels
1949                          */
1950                         for (i = 0; i < comps; i++) {
1951                                 int curpwr;
1952                                 int32_t curpwr32;
1953                                 caddr_t cpaddr;
1954 
1955                                 cp = PM_CP(dip, i);
1956                                 if (wordsize == sizeof (int)) {
1957                                         curpwr = pm_cur_power(cp);
1958                                         cpaddr = (caddr_t)&curpwr;
1959                                 } else {
1960                                         ASSERT(wordsize == sizeof (int32_t));
1961                                         curpwr32 = pm_cur_power(cp);
1962                                         cpaddr = (caddr_t)&curpwr32;
1963                                 }
1964                                 if (ddi_copyout(cpaddr, (void *) req.data,
1965                                     wordsize, mode) != 0) {
1966                                         PM_UNLOCK_DIP(dip);
1967                                         PMD(PMD_ERROR, ("ioctl: %s: %s@%s"
1968                                             "(%s#%d) req.data %p EFAULT\n",
1969                                             cmdstr, PM_DEVICE(dip),
1970                                             (void *)req.data))
1971                                         ASSERT(!dipheld);
1972                                         return (EFAULT);
1973                                 }
1974                                 cpaddr = (caddr_t)req.data;
1975                                 cpaddr += wordsize;
1976                                 req.data = cpaddr;
1977                         }
1978                         /*
1979                          * Then the times remaining
1980                          */
1981                         for (i = 0; i < comps; i++) {
1982                                 int retval;
1983                                 int32_t retval32;
1984                                 caddr_t rvaddr;
1985                                 int curpwr;
1986 
1987                                 cp = PM_CP(dip, i);
1988                                 curpwr = cp->pmc_cur_pwr;
1989                                 if (curpwr == 0 || timestamp[i] == 0) {
1990                                         PMD(PMD_STATS, ("ioctl: %s: "
1991                                             "cur_pwer %x, timestamp %lx\n",
1992                                             cmdstr, curpwr, timestamp[i]))
1993                                         retval = INT_MAX;
1994                                 } else {
1995                                         int thresh;
1996                                         (void) pm_current_threshold(dip, i,
1997                                             &thresh);
1998                                         retval = thresh - (now - timestamp[i]);
1999                                         PMD(PMD_STATS, ("ioctl: %s: current "
2000                                             "thresh %x, now %lx, timestamp %lx,"
2001                                             " retval %x\n", cmdstr, thresh, now,
2002                                             timestamp[i], retval))
2003                                 }
2004                                 if (wordsize == sizeof (int)) {
2005                                         rvaddr = (caddr_t)&retval;
2006                                 } else {
2007                                         ASSERT(wordsize == sizeof (int32_t));
2008                                         retval32 = retval;
2009                                         rvaddr = (caddr_t)&retval32;
2010                                 }
2011                                 if (ddi_copyout(rvaddr, (void *) req.data,
2012                                     wordsize, mode) != 0) {
2013                                         PM_UNLOCK_DIP(dip);
2014                                         PMD(PMD_ERROR, ("ioctl: %s: %s@%s"
2015                                             "(%s#%d) req.data %p EFAULT\n",
2016                                             cmdstr, PM_DEVICE(dip),
2017                                             (void *)req.data))
2018                                         ASSERT(!dipheld);
2019                                         kmem_free(timestamp,
2020                                             comps * sizeof (time_t));
2021                                         return (EFAULT);
2022                                 }
2023                                 rvaddr = (caddr_t)req.data;
2024                                 rvaddr += wordsize;
2025                                 req.data = (int *)rvaddr;
2026                         }
2027                         PM_UNLOCK_DIP(dip);
2028                         *rval_p = comps;
2029                         ret = 0;
2030                         kmem_free(timestamp, comps * sizeof (time_t));
2031                         break;
2032                 }
2033 
2034                 case PM_GET_CMD_NAME:
2035                 {
2036                         PMD(PMD_IOCTL, ("%s: %s\n", cmdstr,
2037                             pm_decode_cmd(req.value)))
2038                         if (ret = copyoutstr(pm_decode_cmd(req.value),
2039                             (char *)req.data, req.datasize, &lencopied)) {
2040                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2041                                     "copyoutstr %p failed--EFAULT\n", cmdstr,
2042                                     PM_DEVICE(dip), (void *)req.data))
2043                                 break;
2044                         }
2045                         *rval_p = lencopied;
2046                         ret = 0;
2047                         break;
2048                 }
2049 
2050                 case PM_GET_COMPONENT_NAME:
2051                 {
2052                         ASSERT(dip);
2053                         if (!e_pm_valid_comp(dip, req.component, &cp)) {
2054                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2055                                     "component %d > numcmpts - 1 %d--EINVAL\n",
2056                                     cmdstr, PM_DEVICE(dip), req.component,
2057                                     PM_NUMCMPTS(dip) - 1))
2058                                 ret = EINVAL;
2059                                 break;
2060                         }
2061                         if (ret = copyoutstr(cp->pmc_comp.pmc_name,
2062                             (char *)req.data, req.datasize, &lencopied)) {
2063                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2064                                     "copyoutstr %p failed--EFAULT\n", cmdstr,
2065                                     PM_DEVICE(dip), (void *)req.data))
2066                                 break;
2067                         }
2068                         *rval_p = lencopied;
2069                         ret = 0;
2070                         break;
2071                 }
2072 
2073                 case PM_GET_POWER_NAME:
2074                 {
2075                         int i;
2076 
2077                         ASSERT(dip);
2078                         if (!e_pm_valid_comp(dip, req.component, &cp)) {
2079                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2080                                     "component %d > numcmpts - 1 %d--EINVAL\n",
2081                                     cmdstr, PM_DEVICE(dip), req.component,
2082                                     PM_NUMCMPTS(dip) - 1))
2083                                 ret = EINVAL;
2084                                 break;
2085                         }
2086                         if ((i = req.value) < 0 ||
2087                             i > cp->pmc_comp.pmc_numlevels - 1) {
2088                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2089                                     "value %d > num_levels - 1 %d--EINVAL\n",
2090                                     cmdstr, PM_DEVICE(dip), req.value,
2091                                     cp->pmc_comp.pmc_numlevels - 1))
2092                                 ret = EINVAL;
2093                                 break;
2094                         }
2095                         dep = cp->pmc_comp.pmc_lnames[req.value];
2096                         if (ret = copyoutstr(dep,
2097                             req.data, req.datasize, &lencopied)) {
2098                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2099                                     "copyoutstr %p failed--EFAULT\n", cmdstr,
2100                                     PM_DEVICE(dip), (void *)req.data))
2101                                 break;
2102                         }
2103                         *rval_p = lencopied;
2104                         ret = 0;
2105                         break;
2106                 }
2107 
2108                 case PM_GET_POWER_LEVELS:
2109                 {
2110                         int musthave;
2111                         int numlevels;
2112                         int wordsize;
2113 
2114 #ifdef  _MULTI_DATAMODEL
2115                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2116                                 wordsize = sizeof (int32_t);
2117                         } else
2118 #endif /* _MULTI_DATAMODEL */
2119                         {
2120                                 wordsize = sizeof (int);
2121                         }
2122                         ASSERT(dip);
2123 
2124                         if (!e_pm_valid_comp(dip, req.component, &cp)) {
2125                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2126                                     "has %d components, component %d requested"
2127                                     "--EINVAL\n", cmdstr, PM_DEVICE(dip),
2128                                     PM_NUMCMPTS(dip), req.component))
2129                                 ret = EINVAL;
2130                                 break;
2131                         }
2132                         numlevels = cp->pmc_comp.pmc_numlevels;
2133                         musthave = numlevels *  wordsize;
2134                         if (req.datasize < musthave) {
2135                                 PMD(PMD_ERROR, ("ioctl: %s: size %lu, need "
2136                                     "%d--EINVAL\n", cmdstr, req.datasize,
2137                                     musthave))
2138                                 ret = EINVAL;
2139                                 break;
2140                         }
2141                         PM_LOCK_DIP(dip);
2142                         for (i = 0; i < numlevels; i++) {
2143                                 int level;
2144                                 int32_t level32;
2145                                 caddr_t laddr;
2146 
2147                                 if (wordsize == sizeof (int)) {
2148                                         level = cp->pmc_comp.pmc_lvals[i];
2149                                         laddr = (caddr_t)&level;
2150                                 } else {
2151                                         level32 = cp->pmc_comp.pmc_lvals[i];
2152                                         laddr = (caddr_t)&level32;
2153                                 }
2154                                 if (ddi_copyout(laddr, (void *) req.data,
2155                                     wordsize, mode) != 0) {
2156                                         PM_UNLOCK_DIP(dip);
2157                                         PMD(PMD_ERROR, ("ioctl: %s: %s@%s"
2158                                             "(%s#%d) laddr %p EFAULT\n",
2159                                             cmdstr, PM_DEVICE(dip),
2160                                             (void *)laddr))
2161                                         ASSERT(!dipheld);
2162                                         return (EFAULT);
2163                                 }
2164                                 laddr = (caddr_t)req.data;
2165                                 laddr += wordsize;
2166                                 req.data = (int *)laddr;
2167                         }
2168                         PM_UNLOCK_DIP(dip);
2169                         *rval_p = numlevels;
2170                         ret = 0;
2171                         break;
2172                 }
2173 
2174 
2175                 case PM_GET_NUM_POWER_LEVELS:
2176                 {
2177                         if (!e_pm_valid_comp(dip, req.component, &cp)) {
2178                                 PMD(PMD_ERROR, ("ioctl: %s: %s@%s(%s#%d) "
2179                                     "component %d > numcmpts - 1 %d--EINVAL\n",
2180                                     cmdstr, PM_DEVICE(dip), req.component,
2181                                     PM_NUMCMPTS(dip) - 1))
2182                                 ret = EINVAL;
2183                                 break;
2184                         }
2185                         *rval_p = cp->pmc_comp.pmc_numlevels;
2186                         ret = 0;
2187                         break;
2188                 }
2189 
2190                 case PM_GET_DEVICE_THRESHOLD_BASIS:
2191                 {
2192                         ret = 0;
2193                         PM_LOCK_DIP(dip);
2194                         if ((info = PM_GET_PM_INFO(dip)) == NULL) {
2195                                 PM_UNLOCK_DIP(dip);
2196                                 PMD(PMD_ERROR, ("ioctl: %s: "
2197                                     "PM_NO_PM_COMPONENTS\n", cmdstr))
2198                                 *rval_p = PM_NO_PM_COMPONENTS;
2199                                 break;
2200                         }
2201                         if (PM_ISDIRECT(dip)) {
2202                                 PM_UNLOCK_DIP(dip);
2203                                 *rval_p = PM_DIRECTLY_MANAGED;
2204                                 break;
2205                         }
2206                         switch (DEVI(dip)->devi_pm_flags & PMC_THRESH_ALL) {
2207                         case PMC_DEF_THRESH:
2208                         case PMC_NEXDEF_THRESH:
2209                                 *rval_p = PM_DEFAULT_THRESHOLD;
2210                                 break;
2211                         case PMC_DEV_THRESH:
2212                                 *rval_p = PM_DEVICE_THRESHOLD;
2213                                 break;
2214                         case PMC_COMP_THRESH:
2215                                 *rval_p = PM_COMPONENT_THRESHOLD;
2216                                 break;
2217                         case PMC_CPU_THRESH:
2218                                 *rval_p = PM_CPU_THRESHOLD;
2219                                 break;
2220                         default:
2221                                 if (PM_ISBC(dip)) {
2222                                         *rval_p = PM_OLD_THRESHOLD;
2223                                         break;
2224                                 }
2225                                 PMD(PMD_ERROR, ("ioctl: %s: default, not "
2226                                     "BC--EINVAL", cmdstr))
2227                                 ret = EINVAL;
2228                                 break;
2229                         }
2230                         PM_UNLOCK_DIP(dip);
2231                         break;
2232                 }
2233                 default:
2234                         /*
2235                          * Internal error, invalid ioctl description
2236                          * force debug entry even if pm_debug not set
2237                          */
2238 #ifdef  DEBUG
2239                         pm_log("invalid diptype %d for cmd %d (%s)\n",
2240                             pcip->diptype, cmd, pcip->name);
2241 #endif
2242                         ASSERT(0);
2243                         return (EIO);
2244                 }
2245                 break;
2246         }
2247 
2248         case PM_PSC:
2249         {
2250                 /*
2251                  * Commands that require pm_state_change_t as arg
2252                  */
2253 #ifdef  _MULTI_DATAMODEL
2254                 if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2255                         pscp32 = (pm_state_change32_t *)arg;
2256                         if (ddi_copyin((caddr_t)arg, &psc32,
2257                             sizeof (psc32), mode) != 0) {
2258                                 PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
2259                                     "EFAULT\n\n", cmdstr))
2260                                 ASSERT(!dipheld);
2261                                 return (EFAULT);
2262                         }
2263                         psc.physpath = (caddr_t)(uintptr_t)psc32.physpath;
2264                         psc.size = psc32.size;
2265                 } else
2266 #endif /* _MULTI_DATAMODEL */
2267                 {
2268                         pscp = (pm_state_change_t *)arg;
2269                         if (ddi_copyin((caddr_t)arg, &psc,
2270                             sizeof (psc), mode) != 0) {
2271                                 PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
2272                                     "EFAULT\n\n", cmdstr))
2273                                 ASSERT(!dipheld);
2274                                 return (EFAULT);
2275                         }
2276                 }
2277                 switch (cmd) {
2278 
2279                 case PM_GET_STATE_CHANGE:
2280                 case PM_GET_STATE_CHANGE_WAIT:
2281                 {
2282                         psce_t                  *pscep;
2283                         pm_state_change_t       *p;
2284                         caddr_t                 physpath;
2285                         size_t                  physlen;
2286 
2287                         /*
2288                          * We want to know if any device has changed state.
2289                          * We look up by clone.  In case we have another thread
2290                          * from the same process, we loop.
2291                          * pm_psc_clone_to_interest() returns a locked entry.
2292                          * We create an internal copy of the event entry prior
2293                          * to copyout to user space because we don't want to
2294                          * hold the psce_lock while doing copyout as we might
2295                          * hit page fault  which eventually brings us back
2296                          * here requesting the same lock.
2297                          */
2298                         mutex_enter(&pm_clone_lock);
2299                         if (!pm_interest_registered(clone))
2300                                 pm_register_watcher(clone, NULL);
2301                         while ((pscep =
2302                             pm_psc_clone_to_interest(clone)) == NULL) {
2303                                 if (cmd == PM_GET_STATE_CHANGE) {
2304                                         PMD(PMD_IOCTL, ("ioctl: %s: "
2305                                             "EWOULDBLOCK\n", cmdstr))
2306                                         mutex_exit(&pm_clone_lock);
2307                                         ASSERT(!dipheld);
2308                                         return (EWOULDBLOCK);
2309                                 } else {
2310                                         if (cv_wait_sig(&pm_clones_cv[clone],
2311                                             &pm_clone_lock) == 0) {
2312                                                 mutex_exit(&pm_clone_lock);
2313                                                 PMD(PMD_ERROR, ("ioctl: %s "
2314                                                     "EINTR\n", cmdstr))
2315                                                 ASSERT(!dipheld);
2316                                                 return (EINTR);
2317                                         }
2318                                 }
2319                         }
2320                         mutex_exit(&pm_clone_lock);
2321 
2322                         physlen = pscep->psce_out->size;
2323                         physpath = NULL;
2324                         /*
2325                          * If we were unable to store the path while bringing
2326                          * up the console fb upon entering the prom, we give
2327                          * a "" name with the overrun event set
2328                          */
2329                         if (physlen == (size_t)-1) {    /* kmemalloc failed */
2330                                 physpath = kmem_zalloc(1, KM_SLEEP);
2331                                 physlen = 1;
2332                         }
2333                         if ((psc.physpath == NULL) || (psc.size < physlen)) {
2334                                 PMD(PMD_ERROR, ("ioctl: %s: EFAULT\n", cmdstr))
2335                                 mutex_exit(&pscep->psce_lock);
2336                                 ret = EFAULT;
2337                                 break;
2338                         }
2339                         if (physpath == NULL) {
2340                                 physpath = kmem_zalloc(physlen, KM_SLEEP);
2341                                 bcopy((const void *) pscep->psce_out->physpath,
2342                                     (void *) physpath, physlen);
2343                         }
2344 
2345                         p = pscep->psce_out;
2346 #ifdef  _MULTI_DATAMODEL
2347                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2348 #ifdef DEBUG
2349                                 size_t usrcopysize;
2350 #endif
2351                                 psc32.flags = (ushort_t)p->flags;
2352                                 psc32.event = (ushort_t)p->event;
2353                                 psc32.timestamp = (int32_t)p->timestamp;
2354                                 psc32.component = (int32_t)p->component;
2355                                 psc32.old_level = (int32_t)p->old_level;
2356                                 psc32.new_level = (int32_t)p->new_level;
2357                                 copysize32 = ((intptr_t)&psc32.size -
2358                                     (intptr_t)&psc32.component);
2359 #ifdef DEBUG
2360                                 usrcopysize = ((intptr_t)&pscp32->size -
2361                                     (intptr_t)&pscp32->component);
2362                                 ASSERT(usrcopysize == copysize32);
2363 #endif
2364                         } else
2365 #endif /* _MULTI_DATAMODEL */
2366                         {
2367                                 psc.flags = p->flags;
2368                                 psc.event = p->event;
2369                                 psc.timestamp = p->timestamp;
2370                                 psc.component = p->component;
2371                                 psc.old_level = p->old_level;
2372                                 psc.new_level = p->new_level;
2373                                 copysize = ((long)&p->size -
2374                                     (long)&p->component);
2375                         }
2376                         if (p->size != (size_t)-1)
2377                                 kmem_free(p->physpath, p->size);
2378                         p->size = 0;
2379                         p->physpath = NULL;
2380                         if (pscep->psce_out == pscep->psce_last)
2381                                 p = pscep->psce_first;
2382                         else
2383                                 p++;
2384                         pscep->psce_out = p;
2385                         mutex_exit(&pscep->psce_lock);
2386 
2387                         ret = copyoutstr(physpath, psc.physpath,
2388                             physlen, &lencopied);
2389                         kmem_free(physpath, physlen);
2390                         if (ret) {
2391                                 PMD(PMD_ERROR, ("ioctl: %s: copyoutstr %p "
2392                                     "failed--EFAULT\n", cmdstr,
2393                                     (void *)psc.physpath))
2394                                 break;
2395                         }
2396 
2397 #ifdef  _MULTI_DATAMODEL
2398                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2399                                 if (ddi_copyout(&psc32.component,
2400                                     &pscp32->component, copysize32, mode)
2401                                     != 0) {
2402                                         PMD(PMD_ERROR, ("ioctl: %s: copyout "
2403                                             "failed--EFAULT\n", cmdstr))
2404                                         ret = EFAULT;
2405                                         break;
2406                                 }
2407                         } else
2408 #endif  /* _MULTI_DATAMODEL */
2409                         {
2410                                 if (ddi_copyout(&psc.component,
2411                                     &pscp->component, copysize, mode) != 0) {
2412                                         PMD(PMD_ERROR, ("ioctl: %s: copyout "
2413                                             "failed--EFAULT\n", cmdstr))
2414                                         ret = EFAULT;
2415                                         break;
2416                                 }
2417                         }
2418                         ret = 0;
2419                         break;
2420                 }
2421 
2422                 case PM_DIRECT_NOTIFY:
2423                 case PM_DIRECT_NOTIFY_WAIT:
2424                 {
2425                         psce_t                  *pscep;
2426                         pm_state_change_t       *p;
2427                         caddr_t                 physpath;
2428                         size_t                  physlen;
2429                         /*
2430                          * We want to know if any direct device of ours has
2431                          * something we should know about.  We look up by clone.
2432                          * In case we have another thread from the same process,
2433                          * we loop.
2434                          * pm_psc_clone_to_direct() returns a locked entry.
2435                          */
2436                         mutex_enter(&pm_clone_lock);
2437                         while (pm_poll_cnt[clone] == 0 ||
2438                             (pscep = pm_psc_clone_to_direct(clone)) == NULL) {
2439                                 if (cmd == PM_DIRECT_NOTIFY) {
2440                                         PMD(PMD_IOCTL, ("ioctl: %s: "
2441                                             "EWOULDBLOCK\n", cmdstr))
2442                                         mutex_exit(&pm_clone_lock);
2443                                         ASSERT(!dipheld);
2444                                         return (EWOULDBLOCK);
2445                                 } else {
2446                                         if (cv_wait_sig(&pm_clones_cv[clone],
2447                                             &pm_clone_lock) == 0) {
2448                                                 mutex_exit(&pm_clone_lock);
2449                                                 PMD(PMD_ERROR, ("ioctl: %s: "
2450                                                     "EINTR\n", cmdstr))
2451                                                 ASSERT(!dipheld);
2452                                                 return (EINTR);
2453                                         }
2454                                 }
2455                         }
2456                         mutex_exit(&pm_clone_lock);
2457                         physlen = pscep->psce_out->size;
2458                         if ((psc.physpath == NULL) || (psc.size < physlen)) {
2459                                 mutex_exit(&pscep->psce_lock);
2460                                 PMD(PMD_ERROR, ("ioctl: %s: EFAULT\n",
2461                                     cmdstr))
2462                                 ret = EFAULT;
2463                                 break;
2464                         }
2465                         physpath = kmem_zalloc(physlen, KM_SLEEP);
2466                         bcopy((const void *) pscep->psce_out->physpath,
2467                             (void *) physpath, physlen);
2468 
2469                         p = pscep->psce_out;
2470 #ifdef  _MULTI_DATAMODEL
2471                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2472 #ifdef DEBUG
2473                                 size_t usrcopysize;
2474 #endif
2475                                 psc32.component = (int32_t)p->component;
2476                                 psc32.flags = (ushort_t)p->flags;
2477                                 psc32.event = (ushort_t)p->event;
2478                                 psc32.timestamp = (int32_t)p->timestamp;
2479                                 psc32.old_level = (int32_t)p->old_level;
2480                                 psc32.new_level = (int32_t)p->new_level;
2481                                 copysize32 = (intptr_t)&psc32.size -
2482                                     (intptr_t)&psc32.component;
2483                                 PMD(PMD_DPM, ("ioctl: %s: PDN32 %s, comp %d "
2484                                     "%d -> %d\n", cmdstr, physpath,
2485                                     p->component, p->old_level, p->new_level))
2486 #ifdef DEBUG
2487                                 usrcopysize = (intptr_t)&pscp32->size -
2488                                     (intptr_t)&pscp32->component;
2489                                 ASSERT(usrcopysize == copysize32);
2490 #endif
2491                         } else
2492 #endif
2493                         {
2494                                 psc.component = p->component;
2495                                 psc.flags = p->flags;
2496                                 psc.event = p->event;
2497                                 psc.timestamp = p->timestamp;
2498                                 psc.old_level = p->old_level;
2499                                 psc.new_level = p->new_level;
2500                                 copysize = (intptr_t)&p->size -
2501                                     (intptr_t)&p->component;
2502                                 PMD(PMD_DPM, ("ioctl: %s: PDN %s, comp %d "
2503                                     "%d -> %d\n", cmdstr, physpath,
2504                                     p->component, p->old_level, p->new_level))
2505                         }
2506                         mutex_enter(&pm_clone_lock);
2507                         PMD(PMD_IOCTL, ("ioctl: %s: pm_poll_cnt[%d] is %d "
2508                             "before decrement\n", cmdstr, clone,
2509                             pm_poll_cnt[clone]))
2510                         pm_poll_cnt[clone]--;
2511                         mutex_exit(&pm_clone_lock);
2512                         kmem_free(p->physpath, p->size);
2513                         p->size = 0;
2514                         p->physpath = NULL;
2515                         if (pscep->psce_out == pscep->psce_last)
2516                                 p = pscep->psce_first;
2517                         else
2518                                 p++;
2519                         pscep->psce_out = p;
2520                         mutex_exit(&pscep->psce_lock);
2521 
2522                         ret = copyoutstr(physpath, psc.physpath,
2523                             physlen, &lencopied);
2524                         kmem_free(physpath, physlen);
2525                         if (ret) {
2526                                 PMD(PMD_ERROR, ("ioctl: %s: copyoutstr %p "
2527                                     "failed--EFAULT\n", cmdstr,
2528                                     (void *)psc.physpath))
2529                                 break;
2530                         }
2531 
2532 #ifdef  _MULTI_DATAMODEL
2533                         if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2534                                 if (ddi_copyout(&psc32.component,
2535                                     &pscp32->component, copysize32, mode)
2536                                     != 0) {
2537                                         PMD(PMD_ERROR, ("ioctl: %s: copyout "
2538                                             "failed--EFAULT\n", cmdstr))
2539                                         ret = EFAULT;
2540                                         break;
2541                                 }
2542                         } else
2543 #endif  /* _MULTI_DATAMODEL */
2544                         {
2545                                 if (ddi_copyout(&psc.component,
2546                                     &pscp->component, copysize, mode) != 0) {
2547                                         PMD(PMD_ERROR, ("ioctl: %s: copyout "
2548                                             "failed--EFAULT\n", cmdstr))
2549                                         ret = EFAULT;
2550                                         break;
2551                                 }
2552                         }
2553                         ret = 0;
2554                         break;
2555                 }
2556                 default:
2557                         /*
2558                          * Internal error, invalid ioctl description
2559                          * force debug entry even if pm_debug not set
2560                          */
2561 #ifdef  DEBUG
2562                         pm_log("invalid diptype %d for cmd %d (%s)\n",
2563                             pcip->diptype, cmd, pcip->name);
2564 #endif
2565                         ASSERT(0);
2566                         return (EIO);
2567                 }
2568                 break;
2569         }
2570 
2571         case PM_SRCH:           /* command that takes a pm_searchargs_t arg */
2572         {
2573                 /*
2574                  * If no ppm, then there is nothing to search.
2575                  */
2576                 if (DEVI(ddi_root_node())->devi_pm_ppm == NULL) {
2577                         ret = ENODEV;
2578                         break;
2579                 }
2580 
2581 #ifdef  _MULTI_DATAMODEL
2582                 if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2583                         if (ddi_copyin((caddr_t)arg, &psa32,
2584                             sizeof (psa32), mode) != 0) {
2585                                 PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
2586                                     "EFAULT\n\n", cmdstr))
2587                                 return (EFAULT);
2588                         }
2589                         if (copyinstr((void *)(uintptr_t)psa32.pms_listname,
2590                             listname, MAXCOPYBUF, NULL)) {
2591                                 PMD(PMD_ERROR, ("ioctl: %s: 0x%p MAXCOPYBUF "
2592                                     "%d, " "EFAULT\n", cmdstr,
2593                                     (void *)(uintptr_t)psa32.pms_listname,
2594                                     MAXCOPYBUF))
2595                                 ret = EFAULT;
2596                                 break;
2597                         }
2598                         if (copyinstr((void *)(uintptr_t)psa32.pms_manufacturer,
2599                             manufacturer, MAXCOPYBUF, NULL)) {
2600                                 PMD(PMD_ERROR, ("ioctl: %s: 0x%p MAXCOPYBUF "
2601                                     "%d, " "EFAULT\n", cmdstr,
2602                                     (void *)(uintptr_t)psa32.pms_manufacturer,
2603                                     MAXCOPYBUF))
2604                                 ret = EFAULT;
2605                                 break;
2606                         }
2607                         if (copyinstr((void *)(uintptr_t)psa32.pms_product,
2608                             product, MAXCOPYBUF, NULL)) {
2609                                 PMD(PMD_ERROR, ("ioctl: %s: 0x%p MAXCOPYBUF "
2610                                     "%d, " "EFAULT\n", cmdstr,
2611                                     (void *)(uintptr_t)psa32.pms_product,
2612                                     MAXCOPYBUF))
2613                                 ret = EFAULT;
2614                                 break;
2615                         }
2616                 } else
2617 #endif /* _MULTI_DATAMODEL */
2618                 {
2619                         if (ddi_copyin((caddr_t)arg, &psa,
2620                             sizeof (psa), mode) != 0) {
2621                                 PMD(PMD_ERROR, ("ioctl: %s: ddi_copyin "
2622                                     "EFAULT\n\n", cmdstr))
2623                                 return (EFAULT);
2624                         }
2625                         if (copyinstr(psa.pms_listname,
2626                             listname, MAXCOPYBUF, NULL)) {
2627                                 PMD(PMD_ERROR, ("ioctl: %s: 0x%p MAXCOPYBUF "
2628                                     "%d, " "EFAULT\n", cmdstr,
2629                                     (void *)psa.pms_listname, MAXCOPYBUF))
2630                                 ret = EFAULT;
2631                                 break;
2632                         }
2633                         if (copyinstr(psa.pms_manufacturer,
2634                             manufacturer, MAXCOPYBUF, NULL)) {
2635                                 PMD(PMD_ERROR, ("ioctl: %s: 0x%p MAXCOPYBUF "
2636                                     "%d, " "EFAULT\n", cmdstr,
2637                                     (void *)psa.pms_manufacturer, MAXCOPYBUF))
2638                                 ret = EFAULT;
2639                                 break;
2640                         }
2641                         if (copyinstr(psa.pms_product,
2642                             product, MAXCOPYBUF, NULL)) {
2643                                 PMD(PMD_ERROR, ("ioctl: %s: 0x%p MAXCOPYBUF "
2644                                     "%d, " "EFAULT\n", cmdstr,
2645                                     (void *)psa.pms_product, MAXCOPYBUF))
2646                                 ret = EFAULT;
2647                                 break;
2648                         }
2649                 }
2650                 psa.pms_listname = listname;
2651                 psa.pms_manufacturer = manufacturer;
2652                 psa.pms_product = product;
2653                 switch (cmd) {
2654                 case PM_SEARCH_LIST:
2655                         ret = pm_ppm_searchlist(&psa);
2656                         break;
2657 
2658                 default:
2659                         /*
2660                          * Internal error, invalid ioctl description
2661                          * force debug entry even if pm_debug not set
2662                          */
2663 #ifdef  DEBUG
2664                         pm_log("invalid diptype %d for cmd %d (%s)\n",
2665                             pcip->diptype, cmd, pcip->name);
2666 #endif
2667                         ASSERT(0);
2668                         return (EIO);
2669                 }
2670                 break;
2671         }
2672 
2673         case NOSTRUCT:
2674         {
2675                 switch (cmd) {
2676                 case PM_START_PM:
2677                 case PM_START_CPUPM:
2678                 case PM_START_CPUPM_EV:
2679                 case PM_START_CPUPM_POLL:
2680                 {
2681                         pm_cpupm_t      new_mode = PM_CPUPM_NOTSET;
2682                         pm_cpupm_t      old_mode = PM_CPUPM_NOTSET;
2683                         int             r;
2684 
2685                         mutex_enter(&pm_scan_lock);
2686                         if ((cmd == PM_START_PM && autopm_enabled) ||
2687                             (cmd == PM_START_CPUPM && PM_DEFAULT_CPUPM) ||
2688                             (cmd == PM_START_CPUPM_EV && PM_EVENT_CPUPM) ||
2689                             (cmd == PM_START_CPUPM_POLL && PM_POLLING_CPUPM)) {
2690                                 mutex_exit(&pm_scan_lock);
2691                                 PMD(PMD_ERROR, ("ioctl: %s: EBUSY\n", cmdstr))
2692                                 ret = EBUSY;
2693                                 break;
2694                         }
2695 
2696                         if (cmd == PM_START_PM) {
2697                                 autopm_enabled = 1;
2698                         } else if (cmd == PM_START_CPUPM) {
2699                                 old_mode = cpupm;
2700                                 new_mode = cpupm = cpupm_default_mode;
2701                         } else if (cmd == PM_START_CPUPM_EV) {
2702                                 old_mode = cpupm;
2703                                 new_mode = cpupm = PM_CPUPM_EVENT;
2704                         } else if (cmd == PM_START_CPUPM_POLL) {
2705                                 old_mode = cpupm;
2706                                 new_mode = cpupm = PM_CPUPM_POLLING;
2707                         }
2708 
2709                         mutex_exit(&pm_scan_lock);
2710 
2711                         /*
2712                          * If we are changing CPUPM modes, and it is active,
2713                          * then stop it from operating in the old mode.
2714                          */
2715                         if (old_mode == PM_CPUPM_POLLING) {
2716                                 int c = PM_STOP_CPUPM;
2717                                 ddi_walk_devs(ddi_root_node(), pm_stop_pm_walk,
2718                                     &c);
2719                         } else if (old_mode == PM_CPUPM_EVENT) {
2720                                 r = cpupm_set_policy(CPUPM_POLICY_DISABLED);
2721 
2722                                 /*
2723                                  * Disabling CPUPM policy should always
2724                                  * succeed
2725                                  */
2726                                 ASSERT(r == 0);
2727                         }
2728 
2729                         /*
2730                          * If we are changing to event based CPUPM, enable it.
2731                          * In the event it's not supported, fall back to
2732                          * polling based CPUPM.
2733                          */
2734                         if (new_mode == PM_CPUPM_EVENT &&
2735                             cpupm_set_policy(CPUPM_POLICY_ELASTIC) < 0) {
2736                                 mutex_enter(&pm_scan_lock);
2737                                 new_mode = cpupm = PM_CPUPM_POLLING;
2738                                 cmd = PM_START_CPUPM_POLL;
2739                                 mutex_exit(&pm_scan_lock);
2740                         }
2741                         if (new_mode == PM_CPUPM_POLLING ||
2742                             cmd == PM_START_PM) {
2743                                 ddi_walk_devs(ddi_root_node(), pm_start_pm_walk,
2744                                     &cmd);
2745                         }
2746                         ret = 0;
2747                         break;
2748                 }
2749 
2750                 case PM_RESET_PM:
2751                 case PM_STOP_PM:
2752                 case PM_STOP_CPUPM:
2753                 {
2754                         extern void pm_discard_thresholds(void);
2755                         pm_cpupm_t old_mode = PM_CPUPM_NOTSET;
2756 
2757                         mutex_enter(&pm_scan_lock);
2758                         if ((cmd == PM_STOP_PM && !autopm_enabled) ||
2759                             (cmd == PM_STOP_CPUPM && PM_CPUPM_DISABLED)) {
2760                                 mutex_exit(&pm_scan_lock);
2761                                 PMD(PMD_ERROR, ("ioctl: %s: EINVAL\n",
2762                                     cmdstr))
2763                                 ret = EINVAL;
2764                                 break;
2765                         }
2766 
2767                         if (cmd == PM_STOP_PM) {
2768                                 autopm_enabled = 0;
2769                                 pm_S3_enabled = 0;
2770                                 autoS3_enabled = 0;
2771                         } else if (cmd == PM_STOP_CPUPM) {
2772                                 old_mode = cpupm;
2773                                 cpupm = PM_CPUPM_DISABLE;
2774                         } else {
2775                                 autopm_enabled = 0;
2776                                 autoS3_enabled = 0;
2777                                 old_mode = cpupm;
2778                                 cpupm = PM_CPUPM_NOTSET;
2779                         }
2780                         mutex_exit(&pm_scan_lock);
2781 
2782                         /*
2783                          * bring devices to full power level, stop scan
2784                          * If CPUPM was operating in event driven mode, disable
2785                          * that.
2786                          */
2787                         if (old_mode == PM_CPUPM_EVENT) {
2788                                 (void) cpupm_set_policy(CPUPM_POLICY_DISABLED);
2789                         }
2790                         ddi_walk_devs(ddi_root_node(), pm_stop_pm_walk, &cmd);
2791                         ret = 0;
2792                         if (cmd == PM_STOP_PM || cmd == PM_STOP_CPUPM)
2793                                 break;
2794                         /*
2795                          * Now do only PM_RESET_PM stuff.
2796                          */
2797                         pm_system_idle_threshold = pm_default_idle_threshold;
2798                         pm_cpu_idle_threshold = 0;
2799                         pm_discard_thresholds();
2800                         pm_all_to_default_thresholds();
2801                         pm_dispatch_to_dep_thread(PM_DEP_WK_REMOVE_DEP,
2802                             NULL, NULL, PM_DEP_WAIT, NULL, 0);
2803                         break;
2804                 }
2805 
2806                 case PM_GET_SYSTEM_THRESHOLD:
2807                 {
2808                         *rval_p = pm_system_idle_threshold;
2809                         ret = 0;
2810                         break;
2811                 }
2812 
2813                 case PM_GET_DEFAULT_SYSTEM_THRESHOLD:
2814                 {
2815                         *rval_p = pm_default_idle_threshold;
2816                         ret = 0;
2817                         break;
2818                 }
2819 
2820                 case PM_GET_CPU_THRESHOLD:
2821                 {
2822                         *rval_p = pm_cpu_idle_threshold;
2823                         ret = 0;
2824                         break;
2825                 }
2826 
2827                 case PM_SET_SYSTEM_THRESHOLD:
2828                 case PM_SET_CPU_THRESHOLD:
2829                 {
2830                         if ((int)arg < 0) {
2831                                 PMD(PMD_ERROR, ("ioctl: %s: arg 0x%x < 0"
2832                                     "--EINVAL\n", cmdstr, (int)arg))
2833                                 ret = EINVAL;
2834                                 break;
2835                         }
2836                         PMD(PMD_IOCTL, ("ioctl: %s: 0x%x 0t%d\n", cmdstr,
2837                             (int)arg, (int)arg))
2838                         if (cmd == PM_SET_SYSTEM_THRESHOLD)
2839                                 pm_system_idle_threshold = (int)arg;
2840                         else {
2841                                 pm_cpu_idle_threshold = (int)arg;
2842                         }
2843                         ddi_walk_devs(ddi_root_node(), pm_set_idle_thresh_walk,
2844                             (void *) &cmd);
2845 
2846                         ret = 0;
2847                         break;
2848                 }
2849 
2850                 case PM_IDLE_DOWN:
2851                 {
2852                         if (pm_timeout_idledown() != 0) {
2853                                 ddi_walk_devs(ddi_root_node(),
2854                                     pm_start_idledown, (void *)PMID_IOC);
2855                         }
2856                         ret = 0;
2857                         break;
2858                 }
2859 
2860                 case PM_GET_PM_STATE:
2861                 {
2862                         if (autopm_enabled) {
2863                                 *rval_p = PM_SYSTEM_PM_ENABLED;
2864                         } else {
2865                                 *rval_p = PM_SYSTEM_PM_DISABLED;
2866                         }
2867                         ret = 0;
2868                         break;
2869                 }
2870 
2871                 case PM_GET_CPUPM_STATE:
2872                 {
2873                         if (PM_POLLING_CPUPM || PM_EVENT_CPUPM)
2874                                 *rval_p = PM_CPU_PM_ENABLED;
2875                         else if (PM_CPUPM_DISABLED)
2876                                 *rval_p = PM_CPU_PM_DISABLED;
2877                         else
2878                                 *rval_p = PM_CPU_PM_NOTSET;
2879                         ret = 0;
2880                         break;
2881                 }
2882 
2883                 case PM_GET_AUTOS3_STATE:
2884                 {
2885                         if (autoS3_enabled) {
2886                                 *rval_p = PM_AUTOS3_ENABLED;
2887                         } else {
2888                                 *rval_p = PM_AUTOS3_DISABLED;
2889                         }
2890                         ret = 0;
2891                         break;
2892                 }
2893 
2894                 case PM_GET_S3_SUPPORT_STATE:
2895                 {
2896                         if (pm_S3_enabled) {
2897                                 *rval_p = PM_S3_SUPPORT_ENABLED;
2898                         } else {
2899                                 *rval_p = PM_S3_SUPPORT_DISABLED;
2900                         }
2901                         ret = 0;
2902                         break;
2903                 }
2904 
2905                 /*
2906                  * pmconfig tells us if the platform supports S3
2907                  */
2908                 case PM_ENABLE_S3:
2909                 {
2910                         mutex_enter(&pm_scan_lock);
2911                         if (pm_S3_enabled) {
2912                                 mutex_exit(&pm_scan_lock);
2913                                 PMD(PMD_ERROR, ("ioctl: %s: EBUSY\n",
2914                                     cmdstr))
2915                                 ret = EBUSY;
2916                                 break;
2917                         }
2918                         pm_S3_enabled = 1;
2919                         mutex_exit(&pm_scan_lock);
2920                         ret = 0;
2921                         break;
2922                 }
2923 
2924                 case PM_DISABLE_S3:
2925                 {
2926                         mutex_enter(&pm_scan_lock);
2927                         pm_S3_enabled = 0;
2928                         mutex_exit(&pm_scan_lock);
2929                         ret = 0;
2930                         break;
2931                 }
2932 
2933                 case PM_START_AUTOS3:
2934                 {
2935                         mutex_enter(&pm_scan_lock);
2936                         if (autoS3_enabled) {
2937                                 mutex_exit(&pm_scan_lock);
2938                                 PMD(PMD_ERROR, ("ioctl: %s: EBUSY\n",
2939                                     cmdstr))
2940                                 ret = EBUSY;
2941                                 break;
2942                         }
2943                         autoS3_enabled = 1;
2944                         mutex_exit(&pm_scan_lock);
2945                         ret = 0;
2946                         break;
2947                 }
2948 
2949                 case PM_STOP_AUTOS3:
2950                 {
2951                         mutex_enter(&pm_scan_lock);
2952                         autoS3_enabled = 0;
2953                         mutex_exit(&pm_scan_lock);
2954                         ret = 0;
2955                         break;
2956                 }
2957 
2958                 case PM_ENABLE_CPU_DEEP_IDLE:
2959                 {
2960                         if (callb_execute_class(CB_CL_CPU_DEEP_IDLE,
2961                             PM_ENABLE_CPU_DEEP_IDLE) == NULL)
2962                                 ret = 0;
2963                         else
2964                                 ret = EBUSY;
2965                         break;
2966                 }
2967                 case PM_DISABLE_CPU_DEEP_IDLE:
2968                 {
2969                         if (callb_execute_class(CB_CL_CPU_DEEP_IDLE,
2970                             PM_DISABLE_CPU_DEEP_IDLE) == NULL)
2971                                 ret = 0;
2972                         else
2973                                 ret = EINVAL;
2974                         break;
2975                 }
2976                 case PM_DEFAULT_CPU_DEEP_IDLE:
2977                 {
2978                         if (callb_execute_class(CB_CL_CPU_DEEP_IDLE,
2979                             PM_DEFAULT_CPU_DEEP_IDLE) == NULL)
2980                                 ret = 0;
2981                         else
2982                                 ret = EBUSY;
2983                         break;
2984                 }
2985 
2986                 default:
2987                         /*
2988                          * Internal error, invalid ioctl description
2989                          * force debug entry even if pm_debug not set
2990                          */
2991 #ifdef  DEBUG
2992                         pm_log("invalid diptype %d for cmd %d (%s)\n",
2993                             pcip->diptype, cmd, pcip->name);
2994 #endif
2995                         ASSERT(0);
2996                         return (EIO);
2997                 }
2998                 break;
2999         }
3000 
3001 default:
3002                 /*
3003                  * Internal error, invalid ioctl description
3004                  * force debug entry even if pm_debug not set
3005                  */
3006 #ifdef  DEBUG
3007                 pm_log("ioctl: invalid str_type %d for cmd %d (%s)\n",
3008                     pcip->str_type, cmd, pcip->name);
3009 #endif
3010                 ASSERT(0);
3011                 return (EIO);
3012         }
3013         ASSERT(ret != 0x0badcafe);      /* some cmd in wrong case! */
3014         if (dipheld) {
3015                 ASSERT(dip);
3016                 PMD(PMD_DHR, ("ioctl: %s: releasing %s@%s(%s#%d) for "
3017                     "exiting pm_ioctl\n", cmdstr, PM_DEVICE(dip)))
3018                 PM_RELE(dip);
3019         }
3020         PMD(PMD_IOCTL, ("ioctl: %s: end, ret=%d\n", cmdstr, ret))
3021         return (ret);
3022 }