xref: /titanic_51/usr/src/uts/common/os/sunpm.c (revision 20ed34cc7e9de957ef6251e20c0f2d8e43847ea0)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * sunpm.c builds sunpm.o	"power management framework"
 *	kernel-resident power management code.  Implements power management
 *	policy
 *	Assumes: all backwards compat. device components wake up on &
 *		 the pm_info pointer in dev_info is initially NULL
 *
 * PM - (device) Power Management
 *
 * Each device may have 0 or more components.  If a device has no components,
 * then it can't be power managed.  Each component has 2 or more
 * power states.
 *
 * "Backwards Compatible" (bc) devices:
 * There are two different types of devices from the point of view of this
 * code.  The original type, left over from the original PM implementation on
 * the voyager platform are known in this code as "backwards compatible"
 * devices (PM_ISBC(dip) returns true).
 * They are recognized by the pm code by the lack of a pm-components property
 * and a call made by the driver to pm_create_components(9F).
 * For these devices, component 0 is special, and represents the power state
 * of the device.  If component 0 is to be set to power level 0 (off), then
 * the framework must first call into the driver's detach(9E) routine with
 * DDI_PM_SUSPEND, to get the driver to save the hardware state of the device.
 * After setting component 0 from 0 to a non-zero power level, a call must be
 * made into the driver's attach(9E) routine with DDI_PM_RESUME.
 *
 * Currently, the only way to get a bc device power managed is via a set of
 * ioctls (PM_DIRECT_PM, PM_SET_CURRENT_POWER) issued to /dev/pm.
 *
 * For non-bc devices, the driver describes the components by exporting a
 * pm-components(9P) property that tells how many components there are,
 * tells what each component's power state values are, and provides human
 * readable strings (currently unused) for each component name and power state.
 * Devices which export pm-components(9P) are automatically power managed
 * whenever autopm is enabled (via PM_START_PM ioctl issued by pmconfig(1M)
 * after parsing power.conf(4)). The exception to this rule is that power
 * manageable CPU devices may be automatically managed independently of autopm
 * by either enabling or disabling (via PM_START_CPUPM and PM_STOP_CPUPM
 * ioctls) cpupm. If the CPU devices are not managed independently, then they
 * are managed by autopm. In either case, for automatically power managed
 * devices, all components are considered independent of each other, and it is
 * up to the driver to decide when a transition requires saving or restoring
 * hardware state.
 *
 * Each device component also has a threshold time associated with each power
 * transition (see power.conf(4)), and a busy/idle state maintained by the
 * driver calling pm_idle_component(9F) and pm_busy_component(9F).
 * Components are created idle.
 *
 * The PM framework provides several functions:
 * -implement PM policy as described in power.conf(4)
 *  Policy is set by pmconfig(1M) issuing pm ioctls based on power.conf(4).
 *  Policies consist of:
 *    -set threshold values (defaults if none provided by pmconfig)
 *    -set dependencies among devices
 *    -enable/disable autopm
 *    -enable/disable cpupm
 *    -turn down idle components based on thresholds (if autopm or cpupm is
 *     enabled) (aka scanning)
 *    -maintain power states based on dependencies among devices
 *    -upon request, or when the frame buffer powers off, attempt to turn off
 *     all components that are idle or become idle over the next (10 sec)
 *     period in an attempt to get down to an EnergyStar compliant state
 *    -prevent powering off of a device which exported the
 *     pm-no-involuntary-power-cycles property without active involvement of
 *     the device's driver (so no removing power when the device driver is
 *     not attached)
 * -provide a mechanism for a device driver to request that a device's component
 *  be brought back to the power level necessary for the use of the device
 * -allow a process to directly control the power levels of device components
 *  (via ioctls issued to /dev/pm--see usr/src/uts/common/io/pm.c)
 * -ensure that the console frame buffer is powered up before being referenced
 *  via prom_printf() or other prom calls that might generate console output
 * -maintain implicit dependencies (e.g. parent must be powered up if child is)
 * -provide "backwards compatible" behavior for devices without pm-components
 *  property
 *
 * Scanning:
 * Whenever autopm or cpupm  is enabled, the framework attempts to bring each
 * component of each managed device to its lowest power based on the threshold
 * of idleness associated with each transition and the busy/idle state of the
 * component.
 *
 * The actual work of this is done by pm_scan_dev(), which cycles through each
 * component of a device, checking its idleness against its current threshold,
 * and calling pm_set_power() as appropriate to change the power level.
 * This function also indicates when it would next be profitable to scan the
 * device again, and a new scan is scheduled after that time.
 *
 * Dependencies:
 * It is possible to establish a dependency between the power states of two
 * otherwise unrelated devices.  This is currently done to ensure that the
 * cdrom is always up whenever the console framebuffer is up, so that the user
 * can insert a cdrom and see a popup as a result.
 *
 * The dependency terminology used in power.conf(4) is not easy to understand,
 * so we've adopted a different terminology in the implementation.  We write
 * of a "keeps up" and a "kept up" device.  A relationship can be established
 * where one device keeps up another.  That means that if the keepsup device
 * has any component that is at a non-zero power level, all components of the
 * "kept up" device must be brought to full power.  This relationship is
 * asynchronous.  When the keeping device is powered up, a request is queued
 * to a worker thread to bring up the kept device.  The caller does not wait.
 * Scan will not turn down a kept up device.
 *
 * Direct PM:
 * A device may be directly power managed by a process.  If a device is
 * directly pm'd, then it will not be scanned, and dependencies will not be
 * enforced.  * If a directly pm'd device's driver requests a power change (via
 * pm_raise_power(9F)), then the request is blocked and notification is sent
 * to the controlling process, which must issue the requested power change for
 * the driver to proceed.
 *
 */

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/callb.h>		/* callback registration during CPR */
#include <sys/conf.h>		/* driver flags and functions */
#include <sys/open.h>		/* OTYP_CHR definition */
#include <sys/stat.h>		/* S_IFCHR definition */
#include <sys/pathname.h>	/* name -> dev_info xlation */
#include <sys/ddi_impldefs.h>	/* dev_info node fields */
#include <sys/kmem.h>		/* memory alloc stuff */
#include <sys/debug.h>
#include <sys/archsystm.h>
#include <sys/pm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/sunpm.h>
#include <sys/epm.h>
#include <sys/vfs.h>
#include <sys/mode.h>
#include <sys/mkdev.h>
#include <sys/promif.h>
#include <sys/consdev.h>
#include <sys/esunddi.h>
#include <sys/modctl.h>
#include <sys/fs/ufs_fs.h>
#include <sys/note.h>
#include <sys/taskq.h>
#include <sys/bootconf.h>
#include <sys/reboot.h>
#include <sys/spl.h>
#include <sys/disp.h>
#include <sys/sobject.h>
#include <sys/sunmdi.h>
#include <sys/systm.h>
#include <sys/cpuvar.h>
#include <sys/cyclic.h>
#include <sys/uadmin.h>
#include <sys/srn.h>


/*
 * PM LOCKING
 *	The list of locks:
 * Global pm mutex locks.
 *
 * pm_scan_lock:
 *		It protects the timeout id of the scan thread, and the value
 *		of autopm_enabled and cpupm.  This lock is not held
 *		concurrently with any other PM locks.
 *
 * pm_clone_lock:	Protects the clone list and count of poll events
 *		pending for the pm driver.
 *		Lock ordering:
 *			pm_clone_lock -> pm_pscc_interest_rwlock,
 *			pm_clone_lock -> pm_pscc_direct_rwlock.
 *
 * pm_rsvp_lock:
 *		Used to synchronize the data structures used for processes
 *		to rendezvous with state change information when doing
 *		direct PM.
 *		Lock ordering:
 *			pm_rsvp_lock -> pm_pscc_interest_rwlock,
 *			pm_rsvp_lock -> pm_pscc_direct_rwlock,
 *			pm_rsvp_lock -> pm_clone_lock.
 *
 * ppm_lock:	protects the list of registered ppm drivers
 *		Lock ordering:
 *			ppm_lock -> ppm driver unit_lock
 *
 * pm_compcnt_lock:
 *		Protects count of components that are not at their lowest
 *		power level.
 *		Lock ordering:
 *			pm_compcnt_lock -> ppm_lock.
 *
 * pm_dep_thread_lock:
 *		Protects work list for pm_dep_thread.  Not taken concurrently
 *		with any other pm lock.
 *
 * pm_remdrv_lock:
 *		Serializes the operation of removing noinvol data structure
 *		entries for a branch of the tree when a driver has been
 *		removed from the system (modctl_rem_major).
 *		Lock ordering:
 *			pm_remdrv_lock -> pm_noinvol_rwlock.
 *
 * pm_cfb_lock: (High level spin lock)
 *		Protects the count of how many components of the console
 *		frame buffer are off (so we know if we have to bring up the
 *		console as a result of a prom_printf, etc.
 *		No other locks are taken while holding this lock.
 *
 * pm_loan_lock:
 *		Protects the lock_loan list.  List is used to record that one
 *		thread has acquired a power lock but has launched another thread
 *		to complete its processing.  An entry in the list indicates that
 *		the worker thread can borrow the lock held by the other thread,
 *		which must block on the completion of the worker.  Use is
 *		specific to module loading.
 *		No other locks are taken while holding this lock.
 *
 * Global PM rwlocks
 *
 * pm_thresh_rwlock:
 *		Protects the list of thresholds recorded for future use (when
 *		devices attach).
 *		Lock ordering:
 *			pm_thresh_rwlock -> devi_pm_lock
 *
 * pm_noinvol_rwlock:
 *		Protects list of detached nodes that had noinvol registered.
 *		No other PM locks are taken while holding pm_noinvol_rwlock.
 *
 * pm_pscc_direct_rwlock:
 *		Protects the list that maps devices being directly power
 *		managed to the processes that manage them.
 *		Lock ordering:
 *			pm_pscc_direct_rwlock -> psce_lock
 *
 * pm_pscc_interest_rwlock;
 *		Protects the list that maps state change events to processes
 *		that want to know about them.
 *		Lock ordering:
 *			pm_pscc_interest_rwlock -> psce_lock
 *
 * per-dip locks:
 *
 * Each node has these per-dip locks, which are only used if the device is
 * a candidate for power management (e.g. has pm components)
 *
 * devi_pm_lock:
 *		Protects all power management state of the node except for
 *		power level, which is protected by ndi_devi_enter().
 *		Encapsulated in macros PM_LOCK_DIP()/PM_UNLOCK_DIP().
 *		Lock ordering:
 *			devi_pm_lock -> pm_rsvp_lock,
 *			devi_pm_lock -> pm_dep_thread_lock,
 *			devi_pm_lock -> pm_noinvol_rwlock,
 *			devi_pm_lock -> power lock
 *
 * power lock (ndi_devi_enter()):
 *		Since changing power level is possibly a slow operation (30
 *		seconds to spin up a disk drive), this is locked separately.
 *		Since a call into the driver to change the power level of one
 *		component may result in a call back into the framework to change
 *		the power level of another, this lock allows re-entrancy by
 *		the same thread (ndi_devi_enter is used for this because
 *		the USB framework uses ndi_devi_enter in its power entry point,
 *		and use of any other lock would produce a deadlock.
 *
 * devi_pm_busy_lock:
 *		This lock protects the integrity of the busy count.  It is
 *		only taken by pm_busy_component() and pm_idle_component and
 *		some code that adjust the busy time after the timer gets set
 *		up or after a CPR operation.  It is per-dip to keep from
 *		single-threading all the disk drivers on a system.
 *		It could be per component instead, but most devices have
 *		only one component.
 *		No other PM locks are taken while holding this lock.
 *
 */

static int stdout_is_framebuffer;
static kmutex_t	e_pm_power_lock;
static kmutex_t pm_loan_lock;
kmutex_t	pm_scan_lock;
callb_id_t	pm_cpr_cb_id;
callb_id_t	pm_panic_cb_id;
callb_id_t	pm_halt_cb_id;
int		pm_comps_notlowest;	/* no. of comps not at lowest power */
int		pm_powering_down;	/* cpr is source of DDI_SUSPEND calls */

clock_t pm_id_ticks = 5;	/* ticks to wait before scan during idle-down */
clock_t pm_default_min_scan = PM_DEFAULT_MIN_SCAN;
clock_t pm_cpu_min_scan = PM_CPU_MIN_SCAN;

#define	PM_MIN_SCAN(dip)	(PM_ISCPU(dip) ? pm_cpu_min_scan : \
				    pm_default_min_scan)

static int pm_busop_set_power(dev_info_t *,
    void *, pm_bus_power_op_t, void *, void *);
static int pm_busop_match_request(dev_info_t *, void *);
static int pm_all_to_normal_nexus(dev_info_t *, pm_canblock_t);
static void e_pm_set_max_power(dev_info_t *, int, int);
static int e_pm_get_max_power(dev_info_t *, int);

/*
 * Dependency Processing is done thru a seperate thread.
 */
kmutex_t	pm_dep_thread_lock;
kcondvar_t	pm_dep_thread_cv;
pm_dep_wk_t	*pm_dep_thread_workq = NULL;
pm_dep_wk_t	*pm_dep_thread_tail = NULL;

/*
 * Autopm  must be turned on by a PM_START_PM ioctl, so we don't end up
 * power managing things in single user mode that have been suppressed via
 * power.conf entries.  Protected by pm_scan_lock.
 */
int		autopm_enabled;

/*
 * cpupm is turned on and off, by the PM_START_CPUPM and PM_STOP_CPUPM ioctls,
 * to define the power management behavior of CPU devices separate from
 * autopm. Protected by pm_scan_lock.
 */
pm_cpupm_t	cpupm = PM_CPUPM_NOTSET;

/*
 * AutoS3 depends on autopm being enabled, and must be enabled by
 * PM_START_AUTOS3 command.
 */
int		autoS3_enabled;

#if !defined(__sparc)
/*
 * on sparc these live in fillsysinfo.c
 *
 * If this variable is non-zero, cpr should return "not supported" when
 * it is queried even though it would normally be supported on this platform.
 */
int cpr_supported_override;

/*
 * Some platforms may need to support CPR even in the absence of
 * having the correct platform id information.  If this
 * variable is non-zero, cpr should proceed even in the absence
 * of otherwise being qualified.
 */
int cpr_platform_enable = 0;

#endif

/*
 * pm_S3_enabled indicates that we believe the platform can support S3,
 * which we get from pmconfig(1M)
 */
int		pm_S3_enabled;

/*
 * This flag is true while processes are stopped for a checkpoint/resume.
 * Controlling processes of direct pm'd devices are not available to
 * participate in power level changes, so we bypass them when this is set.
 */
static int	pm_processes_stopped;

#ifdef	DEBUG

/*
 * see common/sys/epm.h for PMD_* values
 */

uint_t		pm_debug = 0;

/*
 * If pm_divertdebug is set, then no prom_printf calls will be made by
 * PMD(), which will prevent debug output from bringing up the console
 * frame buffer.  Clearing this variable before setting pm_debug will result
 * in PMD output going to the console.
 *
 * pm_divertdebug is incremented in pm_set_power() if dip == cfb_dip to avoid
 * deadlocks and decremented at the end of pm_set_power()
 */
uint_t		pm_divertdebug = 1;
volatile uint_t pm_debug_to_console = 0;
kmutex_t	pm_debug_lock;		/* protects pm_divertdebug */

void prdeps(char *);
#endif

/* Globals */

/*
 * List of recorded thresholds and dependencies
 */
pm_thresh_rec_t *pm_thresh_head;
krwlock_t pm_thresh_rwlock;

pm_pdr_t *pm_dep_head;
static int pm_unresolved_deps = 0;
static int pm_prop_deps = 0;

/*
 * List of devices that exported no-involuntary-power-cycles property
 */
pm_noinvol_t *pm_noinvol_head;

/*
 * Locks used in noinvol processing
 */
krwlock_t pm_noinvol_rwlock;
kmutex_t pm_remdrv_lock;

int pm_default_idle_threshold = PM_DEFAULT_SYS_IDLENESS;
int pm_system_idle_threshold;
int pm_cpu_idle_threshold;

/*
 * By default nexus has 0 threshold, and depends on its children to keep it up
 */
int pm_default_nexus_threshold = 0;

/*
 * Data structures shared with common/io/pm.c
 */
kmutex_t	pm_clone_lock;
kcondvar_t	pm_clones_cv[PM_MAX_CLONE];
uint_t		pm_poll_cnt[PM_MAX_CLONE];	/* count of events for poll */
unsigned char	pm_interest[PM_MAX_CLONE];
struct pollhead	pm_pollhead;

/*
 * Data structures shared with common/io/srn.c
 */
kmutex_t	srn_clone_lock;		/* protects srn_signal, srn_inuse */
void (*srn_signal)(int type, int event);
int srn_inuse;				/* stop srn detach */

extern int	hz;
extern char	*platform_module_list[];

/*
 * Wrappers for use in ddi_walk_devs
 */

static int		pm_set_dev_thr_walk(dev_info_t *, void *);
static int		pm_restore_direct_lvl_walk(dev_info_t *, void *);
static int		pm_save_direct_lvl_walk(dev_info_t *, void *);
static int		pm_discard_dep_walk(dev_info_t *, void *);
#ifdef DEBUG
static int		pm_desc_pwrchk_walk(dev_info_t *, void *);
#endif

/*
 * Routines for managing noinvol devices
 */
int			pm_noinvol_update(int, int, int, char *, dev_info_t *);
void			pm_noinvol_update_node(dev_info_t *,
			    pm_bp_noinvol_t *req);

kmutex_t pm_rsvp_lock;
kmutex_t pm_compcnt_lock;
krwlock_t pm_pscc_direct_rwlock;
krwlock_t pm_pscc_interest_rwlock;

#define	PSC_INTEREST	0	/* belongs to interest psc list */
#define	PSC_DIRECT	1	/* belongs to direct psc list */

pscc_t *pm_pscc_interest;
pscc_t *pm_pscc_direct;

#define	PM_MAJOR(dip) ddi_name_to_major(ddi_binding_name(dip))
#define	PM_IS_NEXUS(dip) NEXUS_DRV(devopsp[PM_MAJOR(dip)])
#define	POWERING_ON(old, new) ((old) == 0 && (new) != 0)
#define	POWERING_OFF(old, new) ((old) != 0 && (new) == 0)

#define	PM_INCR_NOTLOWEST(dip) {					\
	mutex_enter(&pm_compcnt_lock);					\
	if (!PM_IS_NEXUS(dip) ||					\
	    (DEVI(dip)->devi_pm_flags & (PMC_DEV_THRESH|PMC_COMP_THRESH))) {\
		if (pm_comps_notlowest == 0)				\
			pm_ppm_notify_all_lowest(dip, PM_NOT_ALL_LOWEST);\
		pm_comps_notlowest++;					\
		PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d) incr notlowest->%d\n",\
		    pmf, PM_DEVICE(dip), pm_comps_notlowest))		\
	}								\
	mutex_exit(&pm_compcnt_lock);					\
}
#define	PM_DECR_NOTLOWEST(dip) {					\
	mutex_enter(&pm_compcnt_lock);					\
	if (!PM_IS_NEXUS(dip) ||					\
	    (DEVI(dip)->devi_pm_flags & (PMC_DEV_THRESH|PMC_COMP_THRESH))) {\
		ASSERT(pm_comps_notlowest);				\
		pm_comps_notlowest--;					\
		PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d) decr notlowest to "	\
			    "%d\n", pmf, PM_DEVICE(dip), pm_comps_notlowest))\
		if (pm_comps_notlowest == 0)				\
			pm_ppm_notify_all_lowest(dip, PM_ALL_LOWEST);	\
	}								\
	mutex_exit(&pm_compcnt_lock);					\
}

/*
 * console frame-buffer power-management is not enabled when
 * debugging services are present.  to override, set pm_cfb_override
 * to non-zero.
 */
uint_t pm_cfb_comps_off = 0;	/* PM_LEVEL_UNKNOWN is considered on */
kmutex_t pm_cfb_lock;
int pm_cfb_enabled = 1;		/* non-zero allows pm of console frame buffer */
#ifdef DEBUG
int pm_cfb_override = 1;	/* non-zero allows pm of cfb with debuggers */
#else
int pm_cfb_override = 0;	/* non-zero allows pm of cfb with debuggers */
#endif

static dev_info_t *cfb_dip = 0;
static dev_info_t *cfb_dip_detaching = 0;
uint_t cfb_inuse = 0;
static ddi_softintr_t pm_soft_id;
static clock_t pm_soft_pending;
int	pm_scans_disabled = 0;

/*
 * A structure to record the fact that one thread has borrowed a lock held
 * by another thread.  The context requires that the lender block on the
 * completion of the borrower.
 */
typedef struct lock_loan {
	struct lock_loan	*pmlk_next;
	kthread_t		*pmlk_borrower;
	kthread_t		*pmlk_lender;
	dev_info_t		*pmlk_dip;
} lock_loan_t;
static lock_loan_t lock_loan_head;	/* list head is a dummy element */

#ifdef	DEBUG
#ifdef	PMDDEBUG
#define	PMD_FUNC(func, name)	char *(func) = (name);
#else	/* !PMDDEBUG */
#define	PMD_FUNC(func, name)
#endif	/* PMDDEBUG */
#else	/* !DEBUG */
#define	PMD_FUNC(func, name)
#endif	/* DEBUG */


/*
 * Must be called before first device (including pseudo) attach
 */
void
pm_init_locks(void)
{
	mutex_init(&pm_scan_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&pm_rsvp_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&pm_compcnt_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&pm_dep_thread_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&pm_remdrv_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&pm_loan_lock, NULL, MUTEX_DRIVER, NULL);
	rw_init(&pm_thresh_rwlock, NULL, RW_DEFAULT, NULL);
	rw_init(&pm_noinvol_rwlock, NULL, RW_DEFAULT, NULL);
	cv_init(&pm_dep_thread_cv, NULL, CV_DEFAULT, NULL);
}

static boolean_t
pm_cpr_callb(void *arg, int code)
{
	_NOTE(ARGUNUSED(arg))
	static int auto_save;
	static pm_cpupm_t cpupm_save;
	static int pm_reset_timestamps(dev_info_t *, void *);

	switch (code) {
	case CB_CODE_CPR_CHKPT:
		/*
		 * Cancel scan or wait for scan in progress to finish
		 * Other threads may be trying to restart the scan, so we
		 * have to keep at it unil it sticks
		 */
		mutex_enter(&pm_scan_lock);
		ASSERT(!pm_scans_disabled);
		pm_scans_disabled = 1;
		auto_save = autopm_enabled;
		autopm_enabled = 0;
		cpupm_save = cpupm;
		cpupm = PM_CPUPM_NOTSET;
		mutex_exit(&pm_scan_lock);
		ddi_walk_devs(ddi_root_node(), pm_scan_stop_walk, NULL);
		break;

	case CB_CODE_CPR_RESUME:
		ASSERT(!autopm_enabled);
		ASSERT(cpupm == PM_CPUPM_NOTSET);
		ASSERT(pm_scans_disabled);
		pm_scans_disabled = 0;
		/*
		 * Call pm_reset_timestamps to reset timestamps of each
		 * device to the time when the system is resumed so that their
		 * idleness can be re-calculated. That's to avoid devices from
		 * being powered down right after resume if the system was in
		 * suspended mode long enough.
		 */
		ddi_walk_devs(ddi_root_node(), pm_reset_timestamps, NULL);

		autopm_enabled = auto_save;
		cpupm = cpupm_save;
		/*
		 * If there is any auto-pm device, get the scanning
		 * going. Otherwise don't bother.
		 */
		ddi_walk_devs(ddi_root_node(), pm_rescan_walk, NULL);
		break;
	}
	return (B_TRUE);
}

/*
 * This callback routine is called when there is a system panic.  This function
 * exists for prototype matching.
 */
static boolean_t
pm_panic_callb(void *arg, int code)
{
	_NOTE(ARGUNUSED(arg, code))
	void pm_cfb_check_and_powerup(void);
	PMD(PMD_CFB, ("pm_panic_callb\n"))
	pm_cfb_check_and_powerup();
	return (B_TRUE);
}

static boolean_t
pm_halt_callb(void *arg, int code)
{
	_NOTE(ARGUNUSED(arg, code))
	return (B_TRUE);
}

/*
 * This needs to be called after the root and platform drivers are loaded
 * and be single-threaded with respect to driver attach/detach
 */
void
pm_init(void)
{
	PMD_FUNC(pmf, "pm_init")
	char **mod;
	extern pri_t minclsyspri;
	static void pm_dep_thread(void);

	pm_comps_notlowest = 0;
	pm_system_idle_threshold = pm_default_idle_threshold;
	pm_cpu_idle_threshold = 0;

	pm_cpr_cb_id = callb_add(pm_cpr_callb, (void *)NULL,
	    CB_CL_CPR_PM, "pm_cpr");
	pm_panic_cb_id = callb_add(pm_panic_callb, (void *)NULL,
	    CB_CL_PANIC, "pm_panic");
	pm_halt_cb_id = callb_add(pm_halt_callb, (void *)NULL,
	    CB_CL_HALT, "pm_halt");

	/*
	 * Create a thread to do dependency processing.
	 */
	(void) thread_create(NULL, 0, (void (*)())pm_dep_thread, NULL, 0, &p0,
	    TS_RUN, minclsyspri);

	/*
	 * loadrootmodules already loaded these ppm drivers, now get them
	 * attached so they can claim the root drivers as they attach
	 */
	for (mod = platform_module_list; *mod; mod++) {
		if (i_ddi_attach_hw_nodes(*mod) != DDI_SUCCESS) {
			cmn_err(CE_WARN, "!cannot load platform pm driver %s\n",
			    *mod);
		} else {
			PMD(PMD_DHR, ("%s: %s (%s)\n", pmf, *mod,
			    ddi_major_to_name(ddi_name_to_major(*mod))))
		}
	}
}

/*
 * pm_scan_init - create pm scan data structure.  Called (if autopm or cpupm
 * enabled) when device becomes power managed or after a failed detach and
 * when autopm is started via PM_START_PM or PM_START_CPUPM ioctls, and after
 * a CPR resume to get all the devices scanning again.
 */
void
pm_scan_init(dev_info_t *dip)
{
	PMD_FUNC(pmf, "scan_init")
	pm_scan_t	*scanp;

	ASSERT(!PM_ISBC(dip));

	PM_LOCK_DIP(dip);
	scanp = PM_GET_PM_SCAN(dip);
	if (!scanp) {
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): create scan data\n",
		    pmf, PM_DEVICE(dip)))
		scanp =  kmem_zalloc(sizeof (pm_scan_t), KM_SLEEP);
		DEVI(dip)->devi_pm_scan = scanp;
	} else if (scanp->ps_scan_flags & PM_SCAN_STOP) {
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): "
		    "clear PM_SCAN_STOP flag\n", pmf, PM_DEVICE(dip)))
		scanp->ps_scan_flags &= ~PM_SCAN_STOP;
	}
	PM_UNLOCK_DIP(dip);
}

/*
 * pm_scan_fini - remove pm scan data structure when stopping pm on the device
 */
void
pm_scan_fini(dev_info_t *dip)
{
	PMD_FUNC(pmf, "scan_fini")
	pm_scan_t	*scanp;

	PMD(PMD_SCAN, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	ASSERT(!PM_ISBC(dip));
	PM_LOCK_DIP(dip);
	scanp = PM_GET_PM_SCAN(dip);
	if (!scanp) {
		PM_UNLOCK_DIP(dip);
		return;
	}

	ASSERT(!scanp->ps_scan_id && !(scanp->ps_scan_flags &
	    (PM_SCANNING | PM_SCAN_DISPATCHED | PM_SCAN_AGAIN)));

	kmem_free(scanp, sizeof (pm_scan_t));
	DEVI(dip)->devi_pm_scan = NULL;
	PM_UNLOCK_DIP(dip);
}

/*
 * Given a pointer to a component struct, return the current power level
 * (struct contains index unless it is a continuous level).
 * Located here in hopes of getting both this and dev_is_needed into the
 * cache together
 */
static int
cur_power(pm_component_t *cp)
{
	if (cp->pmc_cur_pwr == PM_LEVEL_UNKNOWN)
		return (cp->pmc_cur_pwr);

	return (cp->pmc_comp.pmc_lvals[cp->pmc_cur_pwr]);
}

static char *
pm_decode_direction(int direction)
{
	switch (direction) {
	case PM_LEVEL_UPONLY:
		return ("up");

	case PM_LEVEL_EXACT:
		return ("exact");

	case PM_LEVEL_DOWNONLY:
		return ("down");

	default:
		return ("INVALID DIRECTION");
	}
}

char *
pm_decode_op(pm_bus_power_op_t op)
{
	switch (op) {
	case BUS_POWER_CHILD_PWRCHG:
		return ("CHILD_PWRCHG");
	case BUS_POWER_NEXUS_PWRUP:
		return ("NEXUS_PWRUP");
	case BUS_POWER_PRE_NOTIFICATION:
		return ("PRE_NOTIFICATION");
	case BUS_POWER_POST_NOTIFICATION:
		return ("POST_NOTIFICATION");
	case BUS_POWER_HAS_CHANGED:
		return ("HAS_CHANGED");
	case BUS_POWER_NOINVOL:
		return ("NOINVOL");
	default:
		return ("UNKNOWN OP");
	}
}

/*
 * Returns true if level is a possible (valid) power level for component
 */
int
e_pm_valid_power(dev_info_t *dip, int cmpt, int level)
{
	PMD_FUNC(pmf, "e_pm_valid_power")
	pm_component_t *cp = PM_CP(dip, cmpt);
	int i;
	int *ip = cp->pmc_comp.pmc_lvals;
	int limit = cp->pmc_comp.pmc_numlevels;

	if (level < 0)
		return (0);
	for (i = 0; i < limit; i++) {
		if (level == *ip++)
			return (1);
	}
#ifdef DEBUG
	if (pm_debug & PMD_FAIL) {
		ip = cp->pmc_comp.pmc_lvals;

		for (i = 0; i < limit; i++)
			PMD(PMD_FAIL, ("%s: index=%d, level=%d\n",
			    pmf, i, *ip++))
	}
#endif
	return (0);
}

/*
 * Returns true if device is pm'd (after calling pm_start if need be)
 */
int
e_pm_valid_info(dev_info_t *dip, pm_info_t **infop)
{
	pm_info_t *info;
	static int pm_start(dev_info_t *dip);

	/*
	 * Check if the device is power managed if not.
	 * To make the common case (device is power managed already)
	 * fast, we check without the lock.  If device is not already
	 * power managed, then we take the lock and the long route through
	 * go get it managed.  Devices never go unmanaged until they
	 * detach.
	 */
	info = PM_GET_PM_INFO(dip);
	if (!info) {
		if (!DEVI_IS_ATTACHING(dip)) {
			return (0);
		}
		if (pm_start(dip) != DDI_SUCCESS) {
			return (0);
		}
		info = PM_GET_PM_INFO(dip);
	}
	ASSERT(info);
	if (infop != NULL)
		*infop = info;
	return (1);
}

int
e_pm_valid_comp(dev_info_t *dip, int cmpt, pm_component_t **cpp)
{
	if (cmpt >= 0 && cmpt < PM_NUMCMPTS(dip)) {
		if (cpp != NULL)
			*cpp = PM_CP(dip, cmpt);
		return (1);
	} else {
		return (0);
	}
}

/*
 * Internal guts of ddi_dev_is_needed and pm_raise/lower_power
 */
static int
dev_is_needed(dev_info_t *dip, int cmpt, int level, int direction)
{
	PMD_FUNC(pmf, "din")
	pm_component_t *cp;
	char *pathbuf;
	int result;

	ASSERT(direction == PM_LEVEL_UPONLY || direction == PM_LEVEL_DOWNONLY);
	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, cmpt, &cp) ||
	    !e_pm_valid_power(dip, cmpt, level))
		return (DDI_FAILURE);

	PMD(PMD_DIN, ("%s: %s@%s(%s#%d) cmpt=%d, dir=%s, new=%d, cur=%d\n",
	    pmf, PM_DEVICE(dip), cmpt, pm_decode_direction(direction),
	    level, cur_power(cp)))

	if (pm_set_power(dip, cmpt, level,  direction,
	    PM_CANBLOCK_BLOCK, 0, &result) != DDI_SUCCESS) {
		if (direction == PM_LEVEL_UPONLY) {
			pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
			(void) ddi_pathname(dip, pathbuf);
			cmn_err(CE_WARN, "Device %s failed to power up.",
			    pathbuf);
			kmem_free(pathbuf, MAXPATHLEN);
		}
		PMD(PMD_DIN | PMD_FAIL, ("%s: %s@%s(%s#%d) [%d] %s->%d failed, "
		    "errno %d\n", pmf, PM_DEVICE(dip), cmpt,
		    pm_decode_direction(direction), level, result))
		return (DDI_FAILURE);
	}

	PMD(PMD_RESCAN | PMD_DIN, ("%s: pm_rescan %s@%s(%s#%d)\n", pmf,
	    PM_DEVICE(dip)))
	pm_rescan(dip);
	return (DDI_SUCCESS);
}

/*
 * We can get multiple pm_rescan() threads, if one of them discovers
 * that no scan is running at the moment, it kicks it into action.
 * Otherwise, it tells the current scanning thread to scan again when
 * it is done by asserting the PM_SCAN_AGAIN flag. The PM_SCANNING and
 * PM_SCAN_AGAIN flags are used to regulate scan, to make sure only one
 * thread at a time runs the pm_scan_dev() code.
 */
void
pm_rescan(void *arg)
{
	PMD_FUNC(pmf, "rescan")
	dev_info_t	*dip = (dev_info_t *)arg;
	pm_info_t	*info;
	pm_scan_t	*scanp;
	timeout_id_t	scanid;

	PMD(PMD_SCAN, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	PM_LOCK_DIP(dip);
	info = PM_GET_PM_INFO(dip);
	scanp = PM_GET_PM_SCAN(dip);
	if (pm_scans_disabled || !PM_SCANABLE(dip) || !info || !scanp ||
	    (scanp->ps_scan_flags & PM_SCAN_STOP)) {
		PM_UNLOCK_DIP(dip);
		return;
	}
	if (scanp->ps_scan_flags & PM_SCANNING) {
		scanp->ps_scan_flags |= PM_SCAN_AGAIN;
		PM_UNLOCK_DIP(dip);
		return;
	} else if (scanp->ps_scan_id) {
		scanid = scanp->ps_scan_id;
		scanp->ps_scan_id = 0;
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): cancel timeout scanid %lx\n",
		    pmf, PM_DEVICE(dip), (ulong_t)scanid))
		PM_UNLOCK_DIP(dip);
		(void) untimeout(scanid);
		PM_LOCK_DIP(dip);
	}

	/*
	 * Dispatching pm_scan during attach time is risky due to the fact that
	 * attach might soon fail and dip dissolved, and panic may happen while
	 * attempting to stop scan. So schedule a pm_rescan instead.
	 * (Note that if either of the first two terms are true, taskq_dispatch
	 * will not be invoked).
	 *
	 * Multiple pm_scan dispatching is unecessary and costly to keep track
	 * of. The PM_SCAN_DISPATCHED flag is used between pm_rescan and pm_scan
	 * to regulate the dispatching.
	 *
	 * Scan is stopped before the device is detached (in pm_detaching())
	 * but it may get re-started during the post_detach processing if the
	 * driver fails to detach.
	 */
	if (DEVI_IS_ATTACHING(dip) ||
	    (scanp->ps_scan_flags & PM_SCAN_DISPATCHED) ||
	    !taskq_dispatch(system_taskq, pm_scan, (void *)dip, TQ_NOSLEEP)) {
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): attaching, pm_scan already "
		    "dispatched or dispatching failed\n", pmf, PM_DEVICE(dip)))
		if (scanp->ps_scan_id) {
			scanid = scanp->ps_scan_id;
			scanp->ps_scan_id = 0;
			PM_UNLOCK_DIP(dip);
			(void) untimeout(scanid);
			PM_LOCK_DIP(dip);
			if (scanp->ps_scan_id) {
				PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): a competing "
				    "thread scheduled pm_rescan, scanid %lx\n",
				    pmf, PM_DEVICE(dip),
				    (ulong_t)scanp->ps_scan_id))
				PM_UNLOCK_DIP(dip);
				return;
			}
		}
		scanp->ps_scan_id = timeout(pm_rescan, (void *)dip,
		    (scanp->ps_idle_down ? pm_id_ticks :
		    (PM_MIN_SCAN(dip) * hz)));
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): scheduled next pm_rescan, "
		    "scanid %lx\n", pmf, PM_DEVICE(dip),
		    (ulong_t)scanp->ps_scan_id))
	} else {
		PMD(PMD_SCAN, ("%s: dispatched pm_scan for %s@%s(%s#%d)\n",
		    pmf, PM_DEVICE(dip)))
		scanp->ps_scan_flags |= PM_SCAN_DISPATCHED;
	}
	PM_UNLOCK_DIP(dip);
}

void
pm_scan(void *arg)
{
	PMD_FUNC(pmf, "scan")
	dev_info_t	*dip = (dev_info_t *)arg;
	pm_scan_t	*scanp;
	time_t		nextscan;

	PMD(PMD_SCAN, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))

	PM_LOCK_DIP(dip);
	scanp = PM_GET_PM_SCAN(dip);
	ASSERT(scanp && PM_GET_PM_INFO(dip));

	if (pm_scans_disabled || !PM_SCANABLE(dip) ||
	    (scanp->ps_scan_flags & PM_SCAN_STOP)) {
		scanp->ps_scan_flags &= ~(PM_SCAN_AGAIN | PM_SCAN_DISPATCHED);
		PM_UNLOCK_DIP(dip);
		return;
	}

	if (scanp->ps_idle_down) {
		/*
		 * make sure we remember idledown was in affect until
		 * we've completed the scan
		 */
		PMID_SET_SCANS(scanp->ps_idle_down)
		PMD(PMD_IDLEDOWN, ("%s: %s@%s(%s#%d): idledown starts "
		    "(pmid %x)\n", pmf, PM_DEVICE(dip), scanp->ps_idle_down))
	}

	/* possible having two threads running pm_scan() */
	if (scanp->ps_scan_flags & PM_SCANNING) {
		scanp->ps_scan_flags |= PM_SCAN_AGAIN;
		PMD(PMD_SCAN, ("%s: scanning, will scan %s@%s(%s#%d) again\n",
		    pmf, PM_DEVICE(dip)))
		scanp->ps_scan_flags &= ~PM_SCAN_DISPATCHED;
		PM_UNLOCK_DIP(dip);
		return;
	}

	scanp->ps_scan_flags |= PM_SCANNING;
	scanp->ps_scan_flags &= ~PM_SCAN_DISPATCHED;
	do {
		scanp->ps_scan_flags &= ~PM_SCAN_AGAIN;
		PM_UNLOCK_DIP(dip);
		nextscan = pm_scan_dev(dip);
		PM_LOCK_DIP(dip);
	} while (scanp->ps_scan_flags & PM_SCAN_AGAIN);

	ASSERT(scanp->ps_scan_flags & PM_SCANNING);
	scanp->ps_scan_flags &= ~PM_SCANNING;

	if (scanp->ps_idle_down) {
		scanp->ps_idle_down &= ~PMID_SCANS;
		PMD(PMD_IDLEDOWN, ("%s: %s@%s(%s#%d): idledown ends "
		    "(pmid %x)\n", pmf, PM_DEVICE(dip), scanp->ps_idle_down))
	}

	/* schedule for next idle check */
	if (nextscan != LONG_MAX) {
		if (nextscan > (LONG_MAX / hz))
			nextscan = (LONG_MAX - 1) / hz;
		if (scanp->ps_scan_id) {
			PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): while scanning "
			    "another rescan scheduled scanid(%lx)\n", pmf,
			    PM_DEVICE(dip), (ulong_t)scanp->ps_scan_id))
			PM_UNLOCK_DIP(dip);
			return;
		} else if (!(scanp->ps_scan_flags & PM_SCAN_STOP)) {
			scanp->ps_scan_id = timeout(pm_rescan, (void *)dip,
			    (clock_t)(nextscan * hz));
			PMD(PMD_SCAN, ("%s: nextscan for %s@%s(%s#%d) in "
			    "%lx sec, scanid(%lx) \n", pmf, PM_DEVICE(dip),
			    (ulong_t)nextscan, (ulong_t)scanp->ps_scan_id))
		}
	}
	PM_UNLOCK_DIP(dip);
}

void
pm_get_timestamps(dev_info_t *dip, time_t *valuep)
{
	int components = PM_NUMCMPTS(dip);
	int i;

	ASSERT(components > 0);
	PM_LOCK_BUSY(dip);	/* so we get a consistent view */
	for (i = 0; i < components; i++) {
		valuep[i] = PM_CP(dip, i)->pmc_timestamp;
	}
	PM_UNLOCK_BUSY(dip);
}

/*
 * Returns true if device needs to be kept up because it exported the
 * "no-involuntary-power-cycles" property or we're pretending it did (console
 * fb case) or it is an ancestor of such a device and has used up the "one
 * free cycle" allowed when all such leaf nodes have voluntarily powered down
 * upon detach
 */
int
pm_noinvol(dev_info_t *dip)
{
	PMD_FUNC(pmf, "noinvol")

	/*
	 * This doesn't change over the life of a driver, so no locking needed
	 */
	if (PM_IS_CFB(dip)) {
		PMD(PMD_NOINVOL | PMD_CFB, ("%s: inhibits CFB %s@%s(%s#%d)\n",
		    pmf, PM_DEVICE(dip)))
		return (1);
	}
	/*
	 * Not an issue if no such kids
	 */
	if (DEVI(dip)->devi_pm_noinvolpm == 0) {
#ifdef DEBUG
		if (DEVI(dip)->devi_pm_volpmd != 0) {
			dev_info_t *pdip = dip;
			do {
				PMD(PMD_NOINVOL, ("%s: %s@%s(%s#%d) noinvol %d "
				    "volpmd %d\n", pmf, PM_DEVICE(pdip),
				    DEVI(pdip)->devi_pm_noinvolpm,
				    DEVI(pdip)->devi_pm_volpmd))
				pdip = ddi_get_parent(pdip);
			} while (pdip);
		}
#endif
		ASSERT(DEVI(dip)->devi_pm_volpmd == 0);
		return (0);
	}

	/*
	 * Since we now maintain the counts correct at every node, we no longer
	 * need to look up the tree.  An ancestor cannot use up the free cycle
	 * without the children getting their counts adjusted.
	 */

#ifdef	DEBUG
	if (DEVI(dip)->devi_pm_noinvolpm != DEVI(dip)->devi_pm_volpmd)
		PMD(PMD_NOINVOL, ("%s: (%d != %d) inhibits %s@%s(%s#%d)\n", pmf,
		    DEVI(dip)->devi_pm_noinvolpm, DEVI(dip)->devi_pm_volpmd,
		    PM_DEVICE(dip)))
#endif
	return (DEVI(dip)->devi_pm_noinvolpm != DEVI(dip)->devi_pm_volpmd);
}

/*
 * This function performs the actual scanning of the device.
 * It attempts to power off the indicated device's components if they have
 * been idle and other restrictions are met.
 * pm_scan_dev calculates and returns when the next scan should happen for
 * this device.
 */
time_t
pm_scan_dev(dev_info_t *dip)
{
	PMD_FUNC(pmf, "scan_dev")
	pm_scan_t	*scanp;
	time_t		*timestamp, idletime, now, thresh;
	time_t		timeleft = 0;
#ifdef PMDDEBUG
	int		curpwr;
#endif
	int		i, nxtpwr, pwrndx, unused;
	size_t		size;
	pm_component_t	 *cp;
	dev_info_t	*pdip = ddi_get_parent(dip);
	int		circ;
	static int	cur_threshold(dev_info_t *, int);
	static int	pm_next_lower_power(pm_component_t *, int);
	clock_t		min_scan = pm_default_min_scan;

	/*
	 * skip attaching device
	 */
	if (DEVI_IS_ATTACHING(dip)) {
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) is attaching, timeleft(%lx)\n",
		    pmf, PM_DEVICE(dip), min_scan))
		return (min_scan);
	}

	PM_LOCK_DIP(dip);
	scanp = PM_GET_PM_SCAN(dip);
	min_scan = PM_MIN_SCAN(dip);
	ASSERT(scanp && PM_GET_PM_INFO(dip));

	PMD(PMD_SCAN, ("%s: [BEGIN %s@%s(%s#%d)]\n", pmf, PM_DEVICE(dip)))
	PMD(PMD_SCAN, ("%s: %s@%s(%s#%d): kuc is %d\n", pmf, PM_DEVICE(dip),
	    PM_KUC(dip)))

	/* no scan under the following conditions */
	if (pm_scans_disabled || !PM_SCANABLE(dip) ||
	    (scanp->ps_scan_flags & PM_SCAN_STOP) ||
	    (PM_KUC(dip) != 0) ||
	    PM_ISDIRECT(dip) || pm_noinvol(dip)) {
		PM_UNLOCK_DIP(dip);
		PMD(PMD_SCAN, ("%s: [END, %s@%s(%s#%d)] no scan, "
		    "scan_disabled(%d), apm_enabled(%d), cpupm(%d), "
		    "kuc(%d), %s directpm, %s pm_noinvol\n",
		    pmf, PM_DEVICE(dip), pm_scans_disabled, autopm_enabled,
		    cpupm, PM_KUC(dip),
		    PM_ISDIRECT(dip) ? "is" : "is not",
		    pm_noinvol(dip) ? "is" : "is not"))
		return (LONG_MAX);
	}
	PM_UNLOCK_DIP(dip);

	if (!ndi_devi_tryenter(pdip, &circ)) {
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) can't hold pdip",
		    pmf, PM_DEVICE(pdip)))
		return ((time_t)1);
	}
	now = gethrestime_sec();
	size = PM_NUMCMPTS(dip) * sizeof (time_t);
	timestamp = kmem_alloc(size, KM_SLEEP);
	pm_get_timestamps(dip, timestamp);

	/*
	 * Since we removed support for backwards compatible devices,
	 * (see big comment at top of file)
	 * it is no longer required to deal with component 0 last.
	 */
	for (i = 0; i < PM_NUMCMPTS(dip); i++) {
		/*
		 * If already off (an optimization, perhaps)
		 */
		cp = PM_CP(dip, i);
		pwrndx = cp->pmc_cur_pwr;
#ifdef PMDDEBUG
		curpwr = (pwrndx == PM_LEVEL_UNKNOWN) ?
		    PM_LEVEL_UNKNOWN :
		    cp->pmc_comp.pmc_lvals[pwrndx];
#endif

		if (pwrndx == 0) {
			PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d off or "
			    "lowest\n", pmf, PM_DEVICE(dip), i))
			/* skip device if off or at its lowest */
			continue;
		}

		thresh = cur_threshold(dip, i);		/* comp i threshold */
		if ((timestamp[i] == 0) || (cp->pmc_busycount > 0)) {
			/* were busy or newly became busy by another thread */
			if (timeleft == 0)
				timeleft = max(thresh, min_scan);
			else
				timeleft = min(
				    timeleft, max(thresh, min_scan));
			continue;
		}

		idletime = now - timestamp[i];		/* idle time */
		PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d idle time %lx\n",
		    pmf, PM_DEVICE(dip), i, idletime))
		if (idletime >= thresh || PM_IS_PID(dip)) {
			nxtpwr = pm_next_lower_power(cp, pwrndx);
			PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, %d->%d\n",
			    pmf, PM_DEVICE(dip), i, curpwr, nxtpwr))
			if (pm_set_power(dip, i, nxtpwr, PM_LEVEL_DOWNONLY,
			    PM_CANBLOCK_FAIL, 1, &unused) != DDI_SUCCESS &&
			    PM_CURPOWER(dip, i) != nxtpwr) {
				PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, "
				    "%d->%d Failed\n", pmf, PM_DEVICE(dip),
				    i, curpwr, nxtpwr))
				timeleft = min_scan;
				continue;
			} else {
				PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, "
				    "%d->%d, GOOD curpwr %d\n", pmf,
				    PM_DEVICE(dip), i, curpwr, nxtpwr,
				    cur_power(cp)))

				if (nxtpwr == 0)	/* component went off */
					continue;

				/*
				 * scan to next lower level
				 */
				if (timeleft == 0)
					timeleft = max(
					    1, cur_threshold(dip, i));
				else
					timeleft = min(timeleft,
					    max(1, cur_threshold(dip, i)));
				PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, "
				    "timeleft(%lx)\n", pmf, PM_DEVICE(dip),
				    i, timeleft))
			}
		} else {	/* comp not idle long enough */
			if (timeleft == 0)
				timeleft = thresh - idletime;
			else
				timeleft = min(timeleft, (thresh - idletime));
			PMD(PMD_SCAN, ("%s: %s@%s(%s#%d) comp %d, timeleft="
			    "%lx\n", pmf, PM_DEVICE(dip), i, timeleft))
		}
	}
	ndi_devi_exit(pdip, circ);
	kmem_free(timestamp, size);
	PMD(PMD_SCAN, ("%s: [END %s@%s(%s#%d)] timeleft(%lx)\n", pmf,
	    PM_DEVICE(dip), timeleft))

	/*
	 * if components are already at lowest level, timeleft is left 0
	 */
	return ((timeleft == 0) ? LONG_MAX : timeleft);
}

/*
 * pm_scan_stop - cancel scheduled pm_rescan,
 *                wait for termination of dispatched pm_scan thread
 *                     and active pm_scan_dev thread.
 */
void
pm_scan_stop(dev_info_t *dip)
{
	PMD_FUNC(pmf, "scan_stop")
	pm_scan_t	*scanp;
	timeout_id_t	scanid;

	PMD(PMD_SCAN, ("%s: [BEGIN %s@%s(%s#%d)]\n", pmf, PM_DEVICE(dip)))
	PM_LOCK_DIP(dip);
	scanp = PM_GET_PM_SCAN(dip);
	if (!scanp) {
		PMD(PMD_SCAN, ("%s: [END %s@%s(%s#%d)] scan not initialized\n",
		    pmf, PM_DEVICE(dip)))
		PM_UNLOCK_DIP(dip);
		return;
	}
	scanp->ps_scan_flags |= PM_SCAN_STOP;

	/* cancel scheduled scan taskq */
	while (scanp->ps_scan_id) {
		scanid = scanp->ps_scan_id;
		scanp->ps_scan_id = 0;
		PM_UNLOCK_DIP(dip);
		(void) untimeout(scanid);
		PM_LOCK_DIP(dip);
	}

	while (scanp->ps_scan_flags & (PM_SCANNING | PM_SCAN_DISPATCHED)) {
		PM_UNLOCK_DIP(dip);
		delay(1);
		PM_LOCK_DIP(dip);
	}
	PM_UNLOCK_DIP(dip);
	PMD(PMD_SCAN, ("%s: [END %s@%s(%s#%d)]\n", pmf, PM_DEVICE(dip)))
}

int
pm_scan_stop_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))

	if (!PM_GET_PM_SCAN(dip))
		return (DDI_WALK_CONTINUE);
	ASSERT(!PM_ISBC(dip));
	pm_scan_stop(dip);
	return (DDI_WALK_CONTINUE);
}

/*
 * Converts a power level value to its index
 */
static int
power_val_to_index(pm_component_t *cp, int val)
{
	int limit, i, *ip;

	ASSERT(val != PM_LEVEL_UPONLY && val != PM_LEVEL_DOWNONLY &&
	    val != PM_LEVEL_EXACT);
	/*  convert power value into index (i) */
	limit = cp->pmc_comp.pmc_numlevels;
	ip = cp->pmc_comp.pmc_lvals;
	for (i = 0; i < limit; i++)
		if (val == *ip++)
			return (i);
	return (-1);
}

/*
 * Converts a numeric power level to a printable string
 */
static char *
power_val_to_string(pm_component_t *cp, int val)
{
	int index;

	if (val == PM_LEVEL_UPONLY)
		return ("<UPONLY>");

	if (val == PM_LEVEL_UNKNOWN ||
	    (index = power_val_to_index(cp, val)) == -1)
		return ("<LEVEL_UNKNOWN>");

	return (cp->pmc_comp.pmc_lnames[index]);
}

/*
 * Return true if this node has been claimed by a ppm.
 */
static int
pm_ppm_claimed(dev_info_t *dip)
{
	return (PPM(dip) != NULL);
}

/*
 * A node which was voluntarily power managed has just used up its "free cycle"
 * and need is volpmd field cleared, and the same done to all its descendents
 */
static void
pm_clear_volpm_dip(dev_info_t *dip)
{
	PMD_FUNC(pmf, "clear_volpm_dip")

	if (dip == NULL)
		return;
	PMD(PMD_NOINVOL, ("%s: clear volpm from %s@%s(%s#%d)\n", pmf,
	    PM_DEVICE(dip)))
	DEVI(dip)->devi_pm_volpmd = 0;
	for (dip = ddi_get_child(dip); dip; dip = ddi_get_next_sibling(dip)) {
		pm_clear_volpm_dip(dip);
	}
}

/*
 * A node which was voluntarily power managed has used up the "free cycles"
 * for the subtree that it is the root of.  Scan through the list of detached
 * nodes and adjust the counts of any that are descendents of the node.
 */
static void
pm_clear_volpm_list(dev_info_t *dip)
{
	PMD_FUNC(pmf, "clear_volpm_list")
	char	*pathbuf;
	size_t	len;
	pm_noinvol_t *ip;

	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	len = strlen(pathbuf);
	PMD(PMD_NOINVOL, ("%s: clear volpm list %s\n", pmf, pathbuf))
	rw_enter(&pm_noinvol_rwlock, RW_WRITER);
	for (ip = pm_noinvol_head; ip; ip = ip->ni_next) {
		PMD(PMD_NOINVOL, ("%s: clear volpm: ni_path %s\n", pmf,
		    ip->ni_path))
		if (strncmp(pathbuf, ip->ni_path, len) == 0 &&
		    ip->ni_path[len] == '/') {
			PMD(PMD_NOINVOL, ("%s: clear volpm: %s\n", pmf,
			    ip->ni_path))
			ip->ni_volpmd = 0;
			ip->ni_wasvolpmd = 0;
		}
	}
	kmem_free(pathbuf, MAXPATHLEN);
	rw_exit(&pm_noinvol_rwlock);
}

/*
 * Powers a device, suspending or resuming the driver if it is a backward
 * compatible device, calling into ppm to change power level.
 * Called with the component's power lock held.
 */
static int
power_dev(dev_info_t *dip, int comp, int level, int old_level,
    pm_canblock_t canblock, pm_ppm_devlist_t **devlist)
{
	PMD_FUNC(pmf, "power_dev")
	power_req_t power_req;
	int		power_op_ret;	/* DDI_SUCCESS or DDI_FAILURE */
	int		resume_needed = 0;
	int		suspended = 0;
	int		result;
#ifdef PMDDEBUG
	struct pm_component *cp = PM_CP(dip, comp);
#endif
	int		bc = PM_ISBC(dip);
	int pm_all_components_off(dev_info_t *);
	int		clearvolpmd = 0;
	char		pathbuf[MAXNAMELEN];
#ifdef PMDDEBUG
	char *ppmname, *ppmaddr;
#endif
	/*
	 * If this is comp 0 of a backwards compat device and we are
	 * going to take the power away, we need to detach it with
	 * DDI_PM_SUSPEND command.
	 */
	if (bc && comp == 0 && POWERING_OFF(old_level, level)) {
		if (devi_detach(dip, DDI_PM_SUSPEND) != DDI_SUCCESS) {
			/* We could not suspend before turning cmpt zero off */
			PMD(PMD_ERROR, ("%s: could not suspend %s@%s(%s#%d)\n",
			    pmf, PM_DEVICE(dip)))
			return (DDI_FAILURE);
		} else {
			DEVI(dip)->devi_pm_flags |= PMC_SUSPENDED;
			suspended++;
		}
	}
	power_req.request_type = PMR_PPM_SET_POWER;
	power_req.req.ppm_set_power_req.who = dip;
	power_req.req.ppm_set_power_req.cmpt = comp;
	power_req.req.ppm_set_power_req.old_level = old_level;
	power_req.req.ppm_set_power_req.new_level = level;
	power_req.req.ppm_set_power_req.canblock = canblock;
	power_req.req.ppm_set_power_req.cookie = NULL;
#ifdef PMDDEBUG
	if (pm_ppm_claimed(dip)) {
		ppmname = PM_NAME(PPM(dip));
		ppmaddr = PM_ADDR(PPM(dip));

	} else {
		ppmname = "noppm";
		ppmaddr = "0";
	}
	PMD(PMD_PPM, ("%s: %s@%s(%s#%d):%s[%d] %s (%d) -> %s (%d) via %s@%s\n",
	    pmf, PM_DEVICE(dip), cp->pmc_comp.pmc_name, comp,
	    power_val_to_string(cp, old_level), old_level,
	    power_val_to_string(cp, level), level, ppmname, ppmaddr))
#endif
	/*
	 * If non-bc noinvolpm device is turning first comp on, or noinvolpm
	 * bc device comp 0 is powering on, then we count it as a power cycle
	 * against its voluntary count.
	 */
	if (DEVI(dip)->devi_pm_volpmd &&
	    (!bc && pm_all_components_off(dip) && level != 0) ||
	    (bc && comp == 0 && POWERING_ON(old_level, level)))
		clearvolpmd = 1;
	if ((power_op_ret = pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER,
	    &power_req, &result)) == DDI_SUCCESS) {
		/*
		 * Now do involuntary pm accounting;  If we've just cycled power
		 * on a voluntarily pm'd node, and by inference on its entire
		 * subtree, we need to set the subtree (including those nodes
		 * already detached) volpmd counts to 0, and subtract out the
		 * value of the current node's volpmd count from the ancestors
		 */
		if (clearvolpmd) {
			int volpmd = DEVI(dip)->devi_pm_volpmd;
			pm_clear_volpm_dip(dip);
			pm_clear_volpm_list(dip);
			if (volpmd) {
				(void) ddi_pathname(dip, pathbuf);
				(void) pm_noinvol_update(PM_BP_NOINVOL_POWER,
				    volpmd, 0, pathbuf, dip);
			}
		}
	} else {
		PMD(PMD_FAIL, ("%s: can't set comp %d (%s) of %s@%s(%s#%d) "
		    "to level %d (%s)\n", pmf, comp, cp->pmc_comp.pmc_name,
		    PM_DEVICE(dip), level, power_val_to_string(cp, level)))
	}
	/*
	 * If some other devices were also powered up (e.g. other cpus in
	 * the same domain) return a pointer to that list
	 */
	if (devlist) {
		*devlist = (pm_ppm_devlist_t *)
		    power_req.req.ppm_set_power_req.cookie;
	}
	/*
	 * We will have to resume the device if the device is backwards compat
	 * device and either of the following is true:
	 * -This is comp 0 and we have successfully powered it up
	 * -This is comp 0 and we have failed to power it down. Resume is
	 *  needed because we have suspended it above
	 */

	if (bc && comp == 0) {
		ASSERT(PM_ISDIRECT(dip) || DEVI_IS_DETACHING(dip));
		if (power_op_ret == DDI_SUCCESS) {
			if (POWERING_ON(old_level, level)) {
				/*
				 * It must be either suspended or resumed
				 * via pm_power_has_changed path
				 */
				ASSERT((DEVI(dip)->devi_pm_flags &
				    PMC_SUSPENDED) ||
				    (PM_CP(dip, comp)->pmc_flags &
				    PM_PHC_WHILE_SET_POWER));

					resume_needed = suspended;
			}
		} else {
			if (POWERING_OFF(old_level, level)) {
				/*
				 * It must be either suspended or resumed
				 * via pm_power_has_changed path
				 */
				ASSERT((DEVI(dip)->devi_pm_flags &
				    PMC_SUSPENDED) ||
				    (PM_CP(dip, comp)->pmc_flags &
				    PM_PHC_WHILE_SET_POWER));

					resume_needed = suspended;
			}
		}
	}
	if (resume_needed) {
		ASSERT(DEVI(dip)->devi_pm_flags & PMC_SUSPENDED);
		/* ppm is not interested in DDI_PM_RESUME */
		if ((power_op_ret = devi_attach(dip, DDI_PM_RESUME)) ==
		    DDI_SUCCESS) {
			DEVI(dip)->devi_pm_flags &= ~PMC_SUSPENDED;
		} else
			cmn_err(CE_WARN, "!pm: Can't resume %s@%s(%s#%d)",
			    PM_DEVICE(dip));
	}
	return (power_op_ret);
}

/*
 * Return true if we are the owner or a borrower of the devi lock.  See
 * pm_lock_power_single() about borrowing the lock.
 */
static int
pm_devi_lock_held(dev_info_t *dip)
{
	lock_loan_t *cur;

	if (DEVI_BUSY_OWNED(dip))
		return (1);

	/* return false if no locks borrowed */
	if (lock_loan_head.pmlk_next == NULL)
		return (0);

	mutex_enter(&pm_loan_lock);
	/* see if our thread is registered as a lock borrower. */
	for (cur = lock_loan_head.pmlk_next; cur; cur = cur->pmlk_next)
		if (cur->pmlk_borrower == curthread)
			break;
	mutex_exit(&pm_loan_lock);

	return (cur != NULL && cur->pmlk_lender == DEVI(dip)->devi_busy_thread);
}

/*
 * pm_set_power: adjusts power level of device.	 Assumes device is power
 * manageable & component exists.
 *
 * Cases which require us to bring up devices we keep up ("wekeepups") for
 * backwards compatible devices:
 *	component 0 is off and we're bringing it up from 0
 *		bring up wekeepup first
 *	and recursively when component 0 is off and we bring some other
 *	component up from 0
 * For devices which are not backward compatible, our dependency notion is much
 * simpler.  Unless all components are off, then wekeeps must be on.
 * We don't treat component 0 differently.
 * Canblock tells how to deal with a direct pm'd device.
 * Scan arg tells us if we were called from scan, in which case we don't need
 * to go back to the root node and walk down to change power.
 */
int
pm_set_power(dev_info_t *dip, int comp, int level, int direction,
    pm_canblock_t canblock, int scan, int *retp)
{
	PMD_FUNC(pmf, "set_power")
	char		*pathbuf;
	pm_bp_child_pwrchg_t bpc;
	pm_sp_misc_t	pspm;
	int		ret = DDI_SUCCESS;
	int		unused = DDI_SUCCESS;
	dev_info_t	*pdip = ddi_get_parent(dip);

#ifdef DEBUG
	int		diverted = 0;

	/*
	 * This prevents operations on the console from calling prom_printf and
	 * either deadlocking or bringing up the console because of debug
	 * output
	 */
	if (dip == cfb_dip) {
		diverted++;
		mutex_enter(&pm_debug_lock);
		pm_divertdebug++;
		mutex_exit(&pm_debug_lock);
	}
#endif
	ASSERT(direction == PM_LEVEL_UPONLY || direction == PM_LEVEL_DOWNONLY ||
	    direction == PM_LEVEL_EXACT);
	PMD(PMD_SET, ("%s: %s@%s(%s#%d), comp=%d, dir=%s, new=%d\n",
	    pmf, PM_DEVICE(dip), comp, pm_decode_direction(direction), level))
	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	bpc.bpc_dip = dip;
	bpc.bpc_path = pathbuf;
	bpc.bpc_comp = comp;
	bpc.bpc_olevel = PM_CURPOWER(dip, comp);
	bpc.bpc_nlevel = level;
	pspm.pspm_direction = direction;
	pspm.pspm_errnop = retp;
	pspm.pspm_canblock = canblock;
	pspm.pspm_scan = scan;
	bpc.bpc_private = &pspm;

	/*
	 * If a config operation is being done (we've locked the parent) or
	 * we already hold the power lock (we've locked the node)
	 * then we can operate directly on the node because we have already
	 * brought up all the ancestors, otherwise, we have to go back to the
	 * top of the tree.
	 */
	if (pm_devi_lock_held(pdip) || pm_devi_lock_held(dip))
		ret = pm_busop_set_power(dip, NULL, BUS_POWER_CHILD_PWRCHG,
		    (void *)&bpc, (void *)&unused);
	else
		ret = pm_busop_bus_power(ddi_root_node(), NULL,
		    BUS_POWER_CHILD_PWRCHG, (void *)&bpc, (void *)&unused);
#ifdef DEBUG
	if (ret != DDI_SUCCESS || *retp != DDI_SUCCESS) {
		PMD(PMD_ERROR, ("%s: %s@%s(%s#%d) can't change power, ret=%d, "
		    "errno=%d\n", pmf, PM_DEVICE(dip), ret, *retp))
	}
	if (diverted) {
		mutex_enter(&pm_debug_lock);
		pm_divertdebug--;
		mutex_exit(&pm_debug_lock);
	}
#endif
	kmem_free(pathbuf, MAXPATHLEN);
	return (ret);
}

/*
 * If holddip is set, then if a dip is found we return with the node held.
 *
 * This code uses the same locking scheme as e_ddi_hold_devi_by_path
 * (resolve_pathname), but it does not drive attach.
 */
dev_info_t *
pm_name_to_dip(char *pathname, int holddip)
{
	struct pathname pn;
	char		*component;
	dev_info_t	*parent, *child;
	int		circ;

	if ((pathname == NULL) || (*pathname != '/'))
		return (NULL);

	/* setup pathname and allocate component */
	if (pn_get(pathname, UIO_SYSSPACE, &pn))
		return (NULL);
	component = kmem_alloc(MAXNAMELEN, KM_SLEEP);

	/* start at top, process '/' component */
	parent = child = ddi_root_node();
	ndi_hold_devi(parent);
	pn_skipslash(&pn);
	ASSERT(i_ddi_devi_attached(parent));

	/* process components of pathname */
	while (pn_pathleft(&pn)) {
		(void) pn_getcomponent(&pn, component);

		/* enter parent and search for component child */
		ndi_devi_enter(parent, &circ);
		child = ndi_devi_findchild(parent, component);
		if ((child == NULL) || !i_ddi_devi_attached(child)) {
			child = NULL;
			ndi_devi_exit(parent, circ);
			ndi_rele_devi(parent);
			goto out;
		}

		/* attached child found, hold child and release parent */
		ndi_hold_devi(child);
		ndi_devi_exit(parent, circ);
		ndi_rele_devi(parent);

		/* child becomes parent, and process next component */
		parent = child;
		pn_skipslash(&pn);

		/* loop with active ndi_devi_hold of child->parent */
	}

out:
	pn_free(&pn);
	kmem_free(component, MAXNAMELEN);

	/* if we are not asked to return with hold, drop current hold */
	if (child && !holddip)
		ndi_rele_devi(child);
	return (child);
}

/*
 * Search for a dependency and mark it unsatisfied
 */
static void
pm_unsatisfy(char *keeper, char *kept)
{
	PMD_FUNC(pmf, "unsatisfy")
	pm_pdr_t *dp;

	PMD(PMD_KEEPS, ("%s: keeper=%s, kept=%s\n", pmf, keeper, kept))
	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (!dp->pdr_isprop) {
			if (strcmp(dp->pdr_keeper, keeper) == 0 &&
			    (dp->pdr_kept_count > 0) &&
			    strcmp(dp->pdr_kept_paths[0], kept) == 0) {
				if (dp->pdr_satisfied) {
					dp->pdr_satisfied = 0;
					pm_unresolved_deps++;
					PMD(PMD_KEEPS, ("%s: clear satisfied, "
					    "pm_unresolved_deps now %d\n", pmf,
					    pm_unresolved_deps))
				}
			}
		}
	}
}

/*
 * Device dip is being un power managed, it keeps up count other devices.
 * We need to release any hold we have on the kept devices, and also
 * mark the dependency no longer satisfied.
 */
static void
pm_unkeeps(int count, char *keeper, char **keptpaths, int pwr)
{
	PMD_FUNC(pmf, "unkeeps")
	int i, j;
	dev_info_t *kept;
	dev_info_t *dip;
	struct pm_component *cp;
	int keeper_on = 0, circ;

	PMD(PMD_KEEPS, ("%s: count=%d, keeper=%s, keptpaths=%p\n", pmf, count,
	    keeper, (void *)keptpaths))
	/*
	 * Try to grab keeper. Keeper may have gone away by now,
	 * in this case, used the passed in value pwr
	 */
	dip = pm_name_to_dip(keeper, 1);
	for (i = 0; i < count; i++) {
		/* Release power hold */
		kept = pm_name_to_dip(keptpaths[i], 1);
		if (kept) {
			PMD(PMD_KEEPS, ("%s: %s@%s(%s#%d)[%d]\n", pmf,
			    PM_DEVICE(kept), i))
			/*
			 * We need to check if we skipped a bringup here
			 * because we could have failed the bringup
			 * (ie DIRECT PM device) and have
			 * not increment the count.
			 */
			if ((dip != NULL) && (PM_GET_PM_INFO(dip) != NULL)) {
				keeper_on = 0;
				PM_LOCK_POWER(dip, &circ);
				for (j = 0; j < PM_NUMCMPTS(dip); j++) {
					cp = &DEVI(dip)->devi_pm_components[j];
					if (cur_power(cp)) {
						keeper_on++;
						break;
					}
				}
				if (keeper_on && (PM_SKBU(kept) == 0)) {
					pm_rele_power(kept);
					DEVI(kept)->devi_pm_flags
					    &= ~PMC_SKIP_BRINGUP;
				}
				PM_UNLOCK_POWER(dip, circ);
			} else if (pwr) {
				if (PM_SKBU(kept) == 0) {
					pm_rele_power(kept);
					DEVI(kept)->devi_pm_flags
					    &= ~PMC_SKIP_BRINGUP;
				}
			}
			ddi_release_devi(kept);
		}
		/*
		 * mark this dependency not satisfied
		 */
		pm_unsatisfy(keeper, keptpaths[i]);
	}
	if (dip)
		ddi_release_devi(dip);
}

/*
 * Device kept is being un power managed, it is kept up by keeper.
 * We need to mark the dependency no longer satisfied.
 */
static void
pm_unkepts(char *kept, char *keeper)
{
	PMD_FUNC(pmf, "unkepts")
	PMD(PMD_KEEPS, ("%s: kept=%s, keeper=%s\n", pmf, kept, keeper))
	ASSERT(keeper != NULL);
	/*
	 * mark this dependency not satisfied
	 */
	pm_unsatisfy(keeper, kept);
}

/*
 * Removes dependency information and hold on the kepts, if the path is a
 * path of a keeper.
 */
static void
pm_free_keeper(char *path, int pwr)
{
	pm_pdr_t *dp;
	int i;
	size_t length;

	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (strcmp(dp->pdr_keeper, path) != 0)
			continue;
		/*
		 * Remove all our kept holds and the dependency records,
		 * then free up the kept lists.
		 */
		pm_unkeeps(dp->pdr_kept_count, path, dp->pdr_kept_paths, pwr);
		if (dp->pdr_kept_count)  {
			for (i = 0; i < dp->pdr_kept_count; i++) {
				length = strlen(dp->pdr_kept_paths[i]);
				kmem_free(dp->pdr_kept_paths[i], length + 1);
			}
			kmem_free(dp->pdr_kept_paths,
			    dp->pdr_kept_count * sizeof (char **));
			dp->pdr_kept_paths = NULL;
			dp->pdr_kept_count = 0;
		}
	}
}

/*
 * Removes the device represented by path from the list of kepts, if the
 * path is a path of a kept
 */
static void
pm_free_kept(char *path)
{
	pm_pdr_t *dp;
	int i;
	int j, count;
	size_t length;
	char **paths;

	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (dp->pdr_kept_count == 0)
			continue;
		count = dp->pdr_kept_count;
		/* Remove this device from the kept path lists */
		for (i = 0; i < count; i++) {
			if (strcmp(dp->pdr_kept_paths[i], path) == 0) {
				pm_unkepts(path, dp->pdr_keeper);
				length = strlen(dp->pdr_kept_paths[i]) + 1;
				kmem_free(dp->pdr_kept_paths[i], length);
				dp->pdr_kept_paths[i] = NULL;
				dp->pdr_kept_count--;
			}
		}
		/* Compact the kept paths array */
		if (dp->pdr_kept_count) {
			length = dp->pdr_kept_count * sizeof (char **);
			paths = kmem_zalloc(length, KM_SLEEP);
			j = 0;
			for (i = 0; i < count; i++) {
				if (dp->pdr_kept_paths[i] != NULL) {
					paths[j] = dp->pdr_kept_paths[i];
					j++;
				}
			}
			ASSERT(j == dp->pdr_kept_count);
		}
		/* Now free the old array and point to the new one */
		kmem_free(dp->pdr_kept_paths, count * sizeof (char **));
		if (dp->pdr_kept_count)
			dp->pdr_kept_paths = paths;
		else
			dp->pdr_kept_paths = NULL;
	}
}

/*
 * Free the dependency information for a device.
 */
void
pm_free_keeps(char *path, int pwr)
{
	PMD_FUNC(pmf, "free_keeps")

#ifdef DEBUG
	int doprdeps = 0;
	void prdeps(char *);

	PMD(PMD_KEEPS, ("%s: %s\n", pmf, path))
	if (pm_debug & PMD_KEEPS) {
		doprdeps = 1;
		prdeps("pm_free_keeps before");
	}
#endif
	/*
	 * First assume we are a keeper and remove all our kepts.
	 */
	pm_free_keeper(path, pwr);
	/*
	 * Now assume we a kept device, and remove all our records.
	 */
	pm_free_kept(path);
#ifdef	DEBUG
	if (doprdeps) {
		prdeps("pm_free_keeps after");
	}
#endif
}

static int
pm_is_kept(char *path)
{
	pm_pdr_t *dp;
	int i;

	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (dp->pdr_kept_count == 0)
			continue;
		for (i = 0; i < dp->pdr_kept_count; i++) {
			if (strcmp(dp->pdr_kept_paths[i], path) == 0)
				return (1);
		}
	}
	return (0);
}

static void
e_pm_hold_rele_power(dev_info_t *dip, int cnt)
{
	PMD_FUNC(pmf, "hold_rele_power")
	int circ;

	if ((dip == NULL) ||
	    (PM_GET_PM_INFO(dip) == NULL) || PM_ISBC(dip))
		return;

	PM_LOCK_POWER(dip, &circ);
	ASSERT(cnt >= 0 && PM_KUC(dip) >= 0 || cnt < 0 && PM_KUC(dip) > 0);
	PMD(PMD_KIDSUP, ("%s: kidsupcnt for %s@%s(%s#%d) %d->%d\n", pmf,
	    PM_DEVICE(dip), PM_KUC(dip), (PM_KUC(dip) + cnt)))

	PM_KUC(dip) += cnt;

	ASSERT(PM_KUC(dip) >= 0);
	PM_UNLOCK_POWER(dip, circ);

	if (cnt < 0 && PM_KUC(dip) == 0)
		pm_rescan(dip);
}

#define	MAX_PPM_HANDLERS	4

kmutex_t ppm_lock;	/* in case we ever do multi-threaded startup */

struct	ppm_callbacks {
	int (*ppmc_func)(dev_info_t *);
	dev_info_t	*ppmc_dip;
} ppm_callbacks[MAX_PPM_HANDLERS + 1];


/*
 * This routine calls into all the registered ppms to notify them
 * that either all components of power-managed devices are at their
 * lowest levels or no longer all are at their lowest levels.
 */
static void
pm_ppm_notify_all_lowest(dev_info_t *dip, int mode)
{
	struct ppm_callbacks *ppmcp;
	power_req_t power_req;
	int result = 0;

	power_req.request_type = PMR_PPM_ALL_LOWEST;
	power_req.req.ppm_all_lowest_req.mode = mode;
	mutex_enter(&ppm_lock);
	for (ppmcp = ppm_callbacks; ppmcp->ppmc_func; ppmcp++)
		(void) pm_ctlops((dev_info_t *)ppmcp->ppmc_dip, dip,
		    DDI_CTLOPS_POWER, &power_req, &result);
	mutex_exit(&ppm_lock);
	if (mode == PM_ALL_LOWEST) {
		if (autoS3_enabled) {
			PMD(PMD_SX, ("pm_ppm_notify_all_lowest triggering "
			    "autos3\n"))
			mutex_enter(&srn_clone_lock);
			if (srn_signal) {
				srn_inuse++;
				PMD(PMD_SX, ("(*srn_signal)(AUTOSX, 3)\n"))
				(*srn_signal)(SRN_TYPE_AUTOSX, 3);
				srn_inuse--;
			} else {
				PMD(PMD_SX, ("srn_signal NULL\n"))
			}
			mutex_exit(&srn_clone_lock);
		} else {
			PMD(PMD_SX, ("pm_ppm_notify_all_lowest autos3 "
			    "disabled\n"));
		}
	}
}

static void
pm_set_pm_info(dev_info_t *dip, void *value)
{
	DEVI(dip)->devi_pm_info = value;
}

pm_rsvp_t *pm_blocked_list;

/*
 * Look up an entry in the blocked list by dip and component
 */
static pm_rsvp_t *
pm_rsvp_lookup(dev_info_t *dip, int comp)
{
	pm_rsvp_t *p;
	ASSERT(MUTEX_HELD(&pm_rsvp_lock));
	for (p = pm_blocked_list; p; p = p->pr_next)
		if (p->pr_dip == dip && p->pr_comp == comp) {
			return (p);
		}
	return (NULL);
}

/*
 * Called when a device which is direct power managed (or the parent or
 * dependent of such a device) changes power, or when a pm clone is closed
 * that was direct power managing a device.  This call results in pm_blocked()
 * (below) returning.
 */
void
pm_proceed(dev_info_t *dip, int cmd, int comp, int newlevel)
{
	PMD_FUNC(pmf, "proceed")
	pm_rsvp_t *found = NULL;
	pm_rsvp_t *p;

	mutex_enter(&pm_rsvp_lock);
	switch (cmd) {
	/*
	 * we're giving up control, let any pending op continue
	 */
	case PMP_RELEASE:
		for (p = pm_blocked_list; p; p = p->pr_next) {
			if (dip == p->pr_dip) {
				p->pr_retval = PMP_RELEASE;
				PMD(PMD_DPM, ("%s: RELEASE %s@%s(%s#%d)\n",
				    pmf, PM_DEVICE(dip)))
				cv_signal(&p->pr_cv);
			}
		}
		break;

	/*
	 * process has done PM_SET_CURRENT_POWER; let a matching request
	 * succeed and a non-matching request for the same device fail
	 */
	case PMP_SETPOWER:
		found = pm_rsvp_lookup(dip, comp);
		if (!found)	/* if driver not waiting */
			break;
		/*
		 * This cannot be pm_lower_power, since that can only happen
		 * during detach or probe
		 */
		if (found->pr_newlevel <= newlevel) {
			found->pr_retval = PMP_SUCCEED;
			PMD(PMD_DPM, ("%s: SUCCEED %s@%s(%s#%d)\n", pmf,
			    PM_DEVICE(dip)))
		} else {
			found->pr_retval = PMP_FAIL;
			PMD(PMD_DPM, ("%s: FAIL %s@%s(%s#%d)\n", pmf,
			    PM_DEVICE(dip)))
		}
		cv_signal(&found->pr_cv);
		break;

	default:
		panic("pm_proceed unknown cmd %d", cmd);
	}
	mutex_exit(&pm_rsvp_lock);
}

/*
 * This routine dispatches new work to the dependency thread. Caller must
 * be prepared to block for memory if necessary.
 */
void
pm_dispatch_to_dep_thread(int cmd, char *keeper, char *kept, int wait,
    int *res, int cached_pwr)
{
	pm_dep_wk_t	*new_work;

	new_work = kmem_zalloc(sizeof (pm_dep_wk_t), KM_SLEEP);
	new_work->pdw_type = cmd;
	new_work->pdw_wait = wait;
	new_work->pdw_done = 0;
	new_work->pdw_ret = 0;
	new_work->pdw_pwr = cached_pwr;
	cv_init(&new_work->pdw_cv, NULL, CV_DEFAULT, NULL);
	if (keeper != NULL) {
		new_work->pdw_keeper = kmem_zalloc(strlen(keeper) + 1,
		    KM_SLEEP);
		(void) strcpy(new_work->pdw_keeper, keeper);
	}
	if (kept != NULL) {
		new_work->pdw_kept = kmem_zalloc(strlen(kept) + 1, KM_SLEEP);
		(void) strcpy(new_work->pdw_kept, kept);
	}
	mutex_enter(&pm_dep_thread_lock);
	if (pm_dep_thread_workq == NULL) {
		pm_dep_thread_workq = new_work;
		pm_dep_thread_tail = new_work;
		new_work->pdw_next = NULL;
	} else {
		pm_dep_thread_tail->pdw_next = new_work;
		pm_dep_thread_tail = new_work;
		new_work->pdw_next = NULL;
	}
	cv_signal(&pm_dep_thread_cv);
	/* If caller asked for it, wait till it is done. */
	if (wait)  {
		while (!new_work->pdw_done)
			cv_wait(&new_work->pdw_cv, &pm_dep_thread_lock);
		/*
		 * Pass return status, if any, back.
		 */
		if (res != NULL)
			*res = new_work->pdw_ret;
		/*
		 * If we asked to wait, it is our job to free the request
		 * structure.
		 */
		if (new_work->pdw_keeper)
			kmem_free(new_work->pdw_keeper,
			    strlen(new_work->pdw_keeper) + 1);
		if (new_work->pdw_kept)
			kmem_free(new_work->pdw_kept,
			    strlen(new_work->pdw_kept) + 1);
		kmem_free(new_work, sizeof (pm_dep_wk_t));
	}
	mutex_exit(&pm_dep_thread_lock);
}

/*
 * Release the pm resource for this device.
 */
void
pm_rem_info(dev_info_t *dip)
{
	PMD_FUNC(pmf, "rem_info")
	int		i, count = 0;
	pm_info_t	*info = PM_GET_PM_INFO(dip);
	dev_info_t	*pdip = ddi_get_parent(dip);
	char		*pathbuf;
	int		work_type = PM_DEP_WK_DETACH;

	ASSERT(info);

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	if (PM_ISDIRECT(dip)) {
		info->pmi_dev_pm_state &= ~PM_DIRECT;
		ASSERT(info->pmi_clone);
		info->pmi_clone = 0;
		pm_proceed(dip, PMP_RELEASE, -1, -1);
	}
	ASSERT(!PM_GET_PM_SCAN(dip));

	/*
	 * Now adjust parent's kidsupcnt.  BC nodes we check only comp 0,
	 * Others we check all components.  BC node that has already
	 * called pm_destroy_components() has zero component count.
	 * Parents that get notification are not adjusted because their
	 * kidsupcnt is always 0 (or 1 during configuration).
	 */
	PMD(PMD_KEEPS, ("%s: %s@%s(%s#%d) has %d components\n", pmf,
	    PM_DEVICE(dip), PM_NUMCMPTS(dip)))

	/* node is detached, so we can examine power without locking */
	if (PM_ISBC(dip)) {
		count = (PM_CURPOWER(dip, 0) != 0);
	} else {
		for (i = 0; i < PM_NUMCMPTS(dip); i++)
			count += (PM_CURPOWER(dip, i) != 0);
	}

	if (PM_NUMCMPTS(dip) && pdip && !PM_WANTS_NOTIFICATION(pdip))
		e_pm_hold_rele_power(pdip, -count);

	/* Schedule a request to clean up dependency records */
	pathbuf = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	pm_dispatch_to_dep_thread(work_type, pathbuf, pathbuf,
	    PM_DEP_NOWAIT, NULL, (count > 0));
	kmem_free(pathbuf, MAXPATHLEN);

	/*
	 * Adjust the pm_comps_notlowest count since this device is
	 * not being power-managed anymore.
	 */
	for (i = 0; i < PM_NUMCMPTS(dip); i++) {
		if (PM_CURPOWER(dip, i) != 0)
			PM_DECR_NOTLOWEST(dip);
	}
	/*
	 * Once we clear the info pointer, it looks like it is not power
	 * managed to everybody else.
	 */
	pm_set_pm_info(dip, NULL);
	kmem_free(info, sizeof (pm_info_t));
}

int
pm_get_norm_pwrs(dev_info_t *dip, int **valuep, size_t *length)
{
	int components = PM_NUMCMPTS(dip);
	int *bufp;
	size_t size;
	int i;

	if (components <= 0) {
		cmn_err(CE_NOTE, "!pm: %s@%s(%s#%d) has no components, "
		    "can't get normal power values\n", PM_DEVICE(dip));
		return (DDI_FAILURE);
	} else {
		size = components * sizeof (int);
		bufp = kmem_alloc(size, KM_SLEEP);
		for (i = 0; i < components; i++) {
			bufp[i] = pm_get_normal_power(dip, i);
		}
	}
	*length = size;
	*valuep = bufp;
	return (DDI_SUCCESS);
}

static int
pm_reset_timestamps(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))

	int components;
	int	i;

	if (!PM_GET_PM_INFO(dip))
		return (DDI_WALK_CONTINUE);
	components = PM_NUMCMPTS(dip);
	ASSERT(components > 0);
	PM_LOCK_BUSY(dip);
	for (i = 0; i < components; i++) {
		struct pm_component *cp;
		/*
		 * If the component was not marked as busy,
		 * reset its timestamp to now.
		 */
		cp = PM_CP(dip, i);
		if (cp->pmc_timestamp)
			cp->pmc_timestamp = gethrestime_sec();
	}
	PM_UNLOCK_BUSY(dip);
	return (DDI_WALK_CONTINUE);
}

/*
 * Convert a power level to an index into the levels array (or
 * just PM_LEVEL_UNKNOWN in that special case).
 */
static int
pm_level_to_index(dev_info_t *dip, pm_component_t *cp, int level)
{
	PMD_FUNC(pmf, "level_to_index")
	int i;
	int limit = cp->pmc_comp.pmc_numlevels;
	int *ip = cp->pmc_comp.pmc_lvals;

	if (level == PM_LEVEL_UNKNOWN)
		return (level);

	for (i = 0; i < limit; i++) {
		if (level == *ip++) {
			PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d)[%d] to %x\n",
			    pmf, PM_DEVICE(dip),
			    (int)(cp - DEVI(dip)->devi_pm_components), level))
			return (i);
		}
	}
	panic("pm_level_to_index: level %d not found for device "
	    "%s@%s(%s#%d)", level, PM_DEVICE(dip));
	/*NOTREACHED*/
}

/*
 * Internal function to set current power level
 */
static void
e_pm_set_cur_pwr(dev_info_t *dip, pm_component_t *cp, int level)
{
	PMD_FUNC(pmf, "set_cur_pwr")
	int curpwr = (cp->pmc_flags & PM_PHC_WHILE_SET_POWER ?
	    cp->pmc_phc_pwr : cp->pmc_cur_pwr);

	/*
	 * Nothing to adjust if current & new levels are the same.
	 */
	if (curpwr != PM_LEVEL_UNKNOWN &&
	    level == cp->pmc_comp.pmc_lvals[curpwr])
		return;

	/*
	 * Keep the count for comps doing transition to/from lowest
	 * level.
	 */
	if (curpwr == 0) {
		PM_INCR_NOTLOWEST(dip);
	} else if (level == cp->pmc_comp.pmc_lvals[0]) {
		PM_DECR_NOTLOWEST(dip);
	}
	cp->pmc_phc_pwr = PM_LEVEL_UNKNOWN;
	cp->pmc_cur_pwr = pm_level_to_index(dip, cp, level);
}

/*
 * This is the default method of setting the power of a device if no ppm
 * driver has claimed it.
 */
int
pm_power(dev_info_t *dip, int comp, int level)
{
	PMD_FUNC(pmf, "power")
	struct dev_ops	*ops;
	int		(*fn)(dev_info_t *, int, int);
	struct pm_component *cp = PM_CP(dip, comp);
	int retval;
	pm_info_t *info = PM_GET_PM_INFO(dip);
	static int pm_phc_impl(dev_info_t *, int, int, int);

	PMD(PMD_KIDSUP, ("%s: %s@%s(%s#%d), comp=%d, level=%d\n", pmf,
	    PM_DEVICE(dip), comp, level))
	if (!(ops = ddi_get_driver(dip))) {
		PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) has no ops\n", pmf,
		    PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}
	if ((ops->devo_rev < 2) || !(fn = ops->devo_power)) {
		PMD(PMD_FAIL, ("%s: %s%s\n", pmf,
		    (ops->devo_rev < 2 ? " wrong devo_rev" : ""),
		    (!fn ? " devo_power NULL" : "")))
		return (DDI_FAILURE);
	}
	cp->pmc_flags |= PM_POWER_OP;
	retval = (*fn)(dip, comp, level);
	cp->pmc_flags &= ~PM_POWER_OP;
	if (retval == DDI_SUCCESS) {
		e_pm_set_cur_pwr(dip, PM_CP(dip, comp), level);
		return (DDI_SUCCESS);
	}

	/*
	 * If pm_power_has_changed() detected a deadlock with pm_power() it
	 * updated only the power level of the component.  If our attempt to
	 * set the device new to a power level above has failed we sync the
	 * total power state via phc code now.
	 */
	if (cp->pmc_flags & PM_PHC_WHILE_SET_POWER) {
		int phc_lvl =
		    cp->pmc_comp.pmc_lvals[cp->pmc_cur_pwr];

		ASSERT(info);
		(void) pm_phc_impl(dip, comp, phc_lvl, 0);
		PMD(PMD_PHC, ("%s: phc %s@%s(%s#%d) comp=%d level=%d\n",
		    pmf, PM_DEVICE(dip), comp, phc_lvl))
	}

	PMD(PMD_FAIL, ("%s: can't set comp=%d (%s) of %s@%s(%s#%d) to "
	    "level=%d (%s)\n", pmf, comp, cp->pmc_comp.pmc_name, PM_DEVICE(dip),
	    level, power_val_to_string(cp, level)));
	return (DDI_FAILURE);
}

int
pm_unmanage(dev_info_t *dip)
{
	PMD_FUNC(pmf, "unmanage")
	power_req_t power_req;
	int result, retval = 0;

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	PMD(PMD_REMDEV | PMD_KIDSUP, ("%s: %s@%s(%s#%d)\n", pmf,
	    PM_DEVICE(dip)))
	power_req.request_type = PMR_PPM_UNMANAGE;
	power_req.req.ppm_config_req.who = dip;
	if (pm_ppm_claimed(dip))
		retval = pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER,
		    &power_req, &result);
#ifdef DEBUG
	else
		retval = pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER,
		    &power_req, &result);
#endif
	ASSERT(retval == DDI_SUCCESS);
	pm_rem_info(dip);
	return (retval);
}

int
pm_raise_power(dev_info_t *dip, int comp, int level)
{
	if (level < 0)
		return (DDI_FAILURE);
	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, NULL) ||
	    !e_pm_valid_power(dip, comp, level))
		return (DDI_FAILURE);

	return (dev_is_needed(dip, comp, level, PM_LEVEL_UPONLY));
}

int
pm_lower_power(dev_info_t *dip, int comp, int level)
{
	PMD_FUNC(pmf, "pm_lower_power")

	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, NULL) ||
	    !e_pm_valid_power(dip, comp, level)) {
		PMD(PMD_FAIL, ("%s: validation checks failed for %s@%s(%s#%d) "
		    "comp=%d level=%d\n", pmf, PM_DEVICE(dip), comp, level))
		return (DDI_FAILURE);
	}

	if (!DEVI_IS_DETACHING(dip)) {
		PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) not detaching\n",
		    pmf, PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}

	/*
	 * If we don't care about saving power, or we're treating this node
	 * specially, then this is a no-op
	 */
	if (!PM_SCANABLE(dip) || pm_noinvol(dip)) {
		PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) %s%s%s%s\n",
		    pmf, PM_DEVICE(dip),
		    !autopm_enabled ? "!autopm_enabled " : "",
		    !PM_CPUPM_ENABLED ? "!cpupm_enabled " : "",
		    PM_CPUPM_DISABLED ? "cpupm_disabled " : "",
		    pm_noinvol(dip) ? "pm_noinvol()" : ""))
		return (DDI_SUCCESS);
	}

	if (dev_is_needed(dip, comp, level, PM_LEVEL_DOWNONLY) != DDI_SUCCESS) {
		PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) dev_is_needed failed\n", pmf,
		    PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}
	return (DDI_SUCCESS);
}

/*
 * Find the entries struct for a given dip in the blocked list, return it locked
 */
static psce_t *
pm_psc_dip_to_direct(dev_info_t *dip, pscc_t **psccp)
{
	pscc_t *p;
	psce_t *psce;

	rw_enter(&pm_pscc_direct_rwlock, RW_READER);
	for (p = pm_pscc_direct; p; p = p->pscc_next) {
		if (p->pscc_dip == dip) {
			*psccp = p;
			psce = p->pscc_entries;
			mutex_enter(&psce->psce_lock);
			ASSERT(psce);
			rw_exit(&pm_pscc_direct_rwlock);
			return (psce);
		}
	}
	rw_exit(&pm_pscc_direct_rwlock);
	panic("sunpm: no entry for dip %p in direct list", (void *)dip);
	/*NOTREACHED*/
}

/*
 * Write an entry indicating a power level change (to be passed to a process
 * later) in the given psce.
 * If we were called in the path that brings up the console fb in the
 * case of entering the prom, we don't want to sleep.  If the alloc fails, then
 * we create a record that has a size of -1, a physaddr of NULL, and that
 * has the overflow flag set.
 */
static int
psc_entry(ushort_t event, psce_t *psce, dev_info_t *dip, int comp, int new,
    int old, int which, pm_canblock_t canblock)
{
	char	buf[MAXNAMELEN];
	pm_state_change_t *p;
	size_t	size;
	caddr_t physpath = NULL;
	int	overrun = 0;

	ASSERT(MUTEX_HELD(&psce->psce_lock));
	(void) ddi_pathname(dip, buf);
	size = strlen(buf) + 1;
	p = psce->psce_in;
	if (canblock == PM_CANBLOCK_BYPASS) {
		physpath = kmem_alloc(size, KM_NOSLEEP);
		if (physpath == NULL) {
			/*
			 * mark current entry as overrun
			 */
			p->flags |= PSC_EVENT_LOST;
			size = (size_t)-1;
		}
	} else
		physpath = kmem_alloc(size, KM_SLEEP);
	if (p->size) {	/* overflow; mark the next entry */
		if (p->size != (size_t)-1)
			kmem_free(p->physpath, p->size);
		ASSERT(psce->psce_out == p);
		if (p == psce->psce_last) {
			psce->psce_first->flags |= PSC_EVENT_LOST;
			psce->psce_out = psce->psce_first;
		} else {
			(p + 1)->flags |= PSC_EVENT_LOST;
			psce->psce_out = (p + 1);
		}
		overrun++;
	} else if (physpath == NULL) {	/* alloc failed, mark this entry */
		p->flags |= PSC_EVENT_LOST;
		p->size = 0;
		p->physpath = NULL;
	}
	if (which == PSC_INTEREST) {
		mutex_enter(&pm_compcnt_lock);
		if (pm_comps_notlowest == 0)
			p->flags |= PSC_ALL_LOWEST;
		else
			p->flags &= ~PSC_ALL_LOWEST;
		mutex_exit(&pm_compcnt_lock);
	}
	p->event = event;
	p->timestamp = gethrestime_sec();
	p->component = comp;
	p->old_level = old;
	p->new_level = new;
	p->physpath = physpath;
	p->size = size;
	if (physpath != NULL)
		(void) strcpy(p->physpath, buf);
	if (p == psce->psce_last)
		psce->psce_in = psce->psce_first;
	else
		psce->psce_in = ++p;
	mutex_exit(&psce->psce_lock);
	return (overrun);
}

/*
 * Find the next entry on the interest list.  We keep a pointer to the item we
 * last returned in the user's cooke.  Returns a locked entries struct.
 */
static psce_t *
psc_interest(void **cookie, pscc_t **psccp)
{
	pscc_t *pscc;
	pscc_t **cookiep = (pscc_t **)cookie;

	if (*cookiep == NULL)
		pscc = pm_pscc_interest;
	else
		pscc = (*cookiep)->pscc_next;
	if (pscc) {
		*cookiep = pscc;
		*psccp = pscc;
		mutex_enter(&pscc->pscc_entries->psce_lock);
		return (pscc->pscc_entries);
	} else {
		return (NULL);
	}
}

/*
 * Create an entry for a process to pick up indicating a power level change.
 */
static void
pm_enqueue_notify(ushort_t cmd, dev_info_t *dip, int comp,
    int newlevel, int oldlevel, pm_canblock_t canblock)
{
	PMD_FUNC(pmf, "enqueue_notify")
	pscc_t	*pscc;
	psce_t	*psce;
	void		*cookie = NULL;
	int	overrun;

	ASSERT(MUTEX_HELD(&pm_rsvp_lock));
	switch (cmd) {
	case PSC_PENDING_CHANGE:	/* only for controlling process */
		PMD(PMD_DPM, ("%s: PENDING %s@%s(%s#%d), comp %d, %d -> %d\n",
		    pmf, PM_DEVICE(dip), comp, oldlevel, newlevel))
		psce = pm_psc_dip_to_direct(dip, &pscc);
		ASSERT(psce);
		PMD(PMD_IOCTL, ("%s: PENDING: %s@%s(%s#%d) pm_poll_cnt[%d] "
		    "%d\n", pmf, PM_DEVICE(dip), pscc->pscc_clone,
		    pm_poll_cnt[pscc->pscc_clone]))
		overrun = psc_entry(cmd, psce, dip, comp, newlevel, oldlevel,
		    PSC_DIRECT, canblock);
		PMD(PMD_DPM, ("%s: sig %d\n", pmf, pscc->pscc_clone))
		mutex_enter(&pm_clone_lock);
		if (!overrun)
			pm_poll_cnt[pscc->pscc_clone]++;
		cv_signal(&pm_clones_cv[pscc->pscc_clone]);
		pollwakeup(&pm_pollhead, (POLLRDNORM | POLLIN));
		mutex_exit(&pm_clone_lock);
		break;
	case PSC_HAS_CHANGED:
		PMD(PMD_DPM, ("%s: HAS %s@%s(%s#%d), comp %d, %d -> %d\n",
		    pmf, PM_DEVICE(dip), comp, oldlevel, newlevel))
		if (PM_ISDIRECT(dip) && canblock != PM_CANBLOCK_BYPASS) {
			psce = pm_psc_dip_to_direct(dip, &pscc);
			PMD(PMD_IOCTL, ("%s: HAS: %s@%s(%s#%d) pm_poll_cnt[%d] "
			    "%d\n", pmf, PM_DEVICE(dip), pscc->pscc_clone,
			    pm_poll_cnt[pscc->pscc_clone]))
			overrun = psc_entry(cmd, psce, dip, comp, newlevel,
			    oldlevel, PSC_DIRECT, canblock);
			PMD(PMD_DPM, ("%s: sig %d\n", pmf, pscc->pscc_clone))
			mutex_enter(&pm_clone_lock);
			if (!overrun)
				pm_poll_cnt[pscc->pscc_clone]++;
			cv_signal(&pm_clones_cv[pscc->pscc_clone]);
			pollwakeup(&pm_pollhead, (POLLRDNORM | POLLIN));
			mutex_exit(&pm_clone_lock);
		}
		mutex_enter(&pm_clone_lock);
		rw_enter(&pm_pscc_interest_rwlock, RW_READER);
		while ((psce = psc_interest(&cookie, &pscc)) != NULL) {
			(void) psc_entry(cmd, psce, dip, comp, newlevel,
			    oldlevel, PSC_INTEREST, canblock);
			cv_signal(&pm_clones_cv[pscc->pscc_clone]);
		}
		rw_exit(&pm_pscc_interest_rwlock);
		mutex_exit(&pm_clone_lock);
		break;
#ifdef DEBUG
	default:
		ASSERT(0);
#endif
	}
}

static void
pm_enqueue_notify_others(pm_ppm_devlist_t **listp, pm_canblock_t canblock)
{
	if (listp) {
		pm_ppm_devlist_t *p, *next = NULL;

		for (p = *listp; p; p = next) {
			next = p->ppd_next;
			pm_enqueue_notify(PSC_HAS_CHANGED, p->ppd_who,
			    p->ppd_cmpt, p->ppd_new_level, p->ppd_old_level,
			    canblock);
			kmem_free(p, sizeof (pm_ppm_devlist_t));
		}
		*listp = NULL;
	}
}

/*
 * Try to get the power locks of the parent node and target (child)
 * node.  Return true if successful (with both locks held) or false
 * (with no locks held).
 */
static int
pm_try_parent_child_locks(dev_info_t *pdip,
    dev_info_t *dip, int *pcircp, int *circp)
{
	if (ndi_devi_tryenter(pdip, pcircp))
		if (PM_TRY_LOCK_POWER(dip, circp)) {
			return (1);
		} else {
			ndi_devi_exit(pdip, *pcircp);
		}
	return (0);
}

/*
 * Determine if the power lock owner is blocked by current thread.
 * returns :
 * 	1 - If the thread owning the effective power lock (the first lock on
 *          which a thread blocks when it does PM_LOCK_POWER) is blocked by
 *          a mutex held by the current thread.
 *
 *	0 - otherwise
 *
 * Note : This function is called by pm_power_has_changed to determine whether
 * it is executing in parallel with pm_set_power.
 */
static int
pm_blocked_by_us(dev_info_t *dip)
{
	power_req_t power_req;
	kthread_t *owner;
	int result;
	kmutex_t *mp;
	dev_info_t *ppm = (dev_info_t *)DEVI(dip)->devi_pm_ppm;

	power_req.request_type = PMR_PPM_POWER_LOCK_OWNER;
	power_req.req.ppm_power_lock_owner_req.who = dip;
	if (pm_ctlops(ppm, dip, DDI_CTLOPS_POWER, &power_req, &result) !=
	    DDI_SUCCESS) {
		/*
		 * It is assumed that if the device is claimed by ppm, ppm
		 * will always implement this request type and it'll always
		 * return success. We panic here, if it fails.
		 */
		panic("pm: Can't determine power lock owner of %s@%s(%s#%d)\n",
		    PM_DEVICE(dip));
		/*NOTREACHED*/
	}

	if ((owner = power_req.req.ppm_power_lock_owner_req.owner) != NULL &&
	    owner->t_state == TS_SLEEP &&
	    owner->t_sobj_ops &&
	    SOBJ_TYPE(owner->t_sobj_ops) == SOBJ_MUTEX &&
	    (mp = (kmutex_t *)owner->t_wchan) &&
	    mutex_owner(mp) == curthread)
		return (1);

	return (0);
}

/*
 * Notify parent which wants to hear about a child's power changes.
 */
static void
pm_notify_parent(dev_info_t *dip,
    dev_info_t *pdip, int comp, int old_level, int level)
{
	pm_bp_has_changed_t bphc;
	pm_sp_misc_t pspm;
	char *pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	int result = DDI_SUCCESS;

	bphc.bphc_dip = dip;
	bphc.bphc_path = ddi_pathname(dip, pathbuf);
	bphc.bphc_comp = comp;
	bphc.bphc_olevel = old_level;
	bphc.bphc_nlevel = level;
	pspm.pspm_canblock = PM_CANBLOCK_BLOCK;
	pspm.pspm_scan = 0;
	bphc.bphc_private = &pspm;
	(void) (*PM_BUS_POWER_FUNC(pdip))(pdip, NULL,
	    BUS_POWER_HAS_CHANGED, (void *)&bphc, (void *)&result);
	kmem_free(pathbuf, MAXPATHLEN);
}

/*
 * Check if we need to resume a BC device, and make the attach call as required.
 */
static int
pm_check_and_resume(dev_info_t *dip, int comp, int old_level, int level)
{
	int ret = DDI_SUCCESS;

	if (PM_ISBC(dip) && comp == 0 && old_level == 0 && level != 0) {
		ASSERT(DEVI(dip)->devi_pm_flags & PMC_SUSPENDED);
		/* ppm is not interested in DDI_PM_RESUME */
		if ((ret = devi_attach(dip, DDI_PM_RESUME)) != DDI_SUCCESS)
			/* XXX Should we mark it resumed, */
			/* even though it failed? */
			cmn_err(CE_WARN, "!pm: Can't resume %s@%s",
			    PM_NAME(dip), PM_ADDR(dip));
		DEVI(dip)->devi_pm_flags &= ~PMC_SUSPENDED;
	}

	return (ret);
}

/*
 * Tests outside the lock to see if we should bother to enqueue an entry
 * for any watching process.  If yes, then caller will take the lock and
 * do the full protocol
 */
static int
pm_watchers()
{
	if (pm_processes_stopped)
		return (0);
	return (pm_pscc_direct || pm_pscc_interest);
}

/*
 * A driver is reporting that the power of one of its device's components
 * has changed.  Update the power state accordingly.
 */
int
pm_power_has_changed(dev_info_t *dip, int comp, int level)
{
	PMD_FUNC(pmf, "pm_power_has_changed")
	int ret;
	dev_info_t *pdip = ddi_get_parent(dip);
	struct pm_component *cp;
	int blocked, circ, pcirc, old_level;
	static int pm_phc_impl(dev_info_t *, int, int, int);

	if (level < 0) {
		PMD(PMD_FAIL, ("%s: %s@%s(%s#%d): bad level=%d\n", pmf,
		    PM_DEVICE(dip), level))
		return (DDI_FAILURE);
	}

	PMD(PMD_KIDSUP | PMD_DEP, ("%s: %s@%s(%s#%d), comp=%d, level=%d\n", pmf,
	    PM_DEVICE(dip), comp, level))

	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, &cp) ||
	    !e_pm_valid_power(dip, comp, level))
		return (DDI_FAILURE);

	/*
	 * A driver thread calling pm_power_has_changed and another thread
	 * calling pm_set_power can deadlock.  The problem is not resolvable
	 * by changing lock order, so we use pm_blocked_by_us() to detect
	 * this specific deadlock.  If we can't get the lock immediately
	 * and we are deadlocked, just update the component's level, do
	 * notifications, and return.  We intend to update the total power
	 * state later (if the other thread fails to set power to the
	 * desired level).  If we were called because of a power change on a
	 * component that isn't involved in a set_power op, update all state
	 * immediately.
	 */
	cp = PM_CP(dip, comp);
	while (!pm_try_parent_child_locks(pdip, dip, &pcirc, &circ)) {
		if (((blocked = pm_blocked_by_us(dip)) != 0) &&
		    (cp->pmc_flags & PM_POWER_OP)) {
			if (pm_watchers()) {
				mutex_enter(&pm_rsvp_lock);
				pm_enqueue_notify(PSC_HAS_CHANGED, dip, comp,
				    level, cur_power(cp), PM_CANBLOCK_BLOCK);
				mutex_exit(&pm_rsvp_lock);
			}
			if (pdip && PM_WANTS_NOTIFICATION(pdip))
				pm_notify_parent(dip,
				    pdip, comp, cur_power(cp), level);
			(void) pm_check_and_resume(dip,
			    comp, cur_power(cp), level);

			/*
			 * Stash the old power index, update curpwr, and flag
			 * that the total power state needs to be synched.
			 */
			cp->pmc_flags |= PM_PHC_WHILE_SET_POWER;
			/*
			 * Several pm_power_has_changed calls could arrive
			 * while the set power path remains blocked.  Keep the
			 * oldest old power and the newest new power of any
			 * sequence of phc calls which arrive during deadlock.
			 */
			if (cp->pmc_phc_pwr == PM_LEVEL_UNKNOWN)
				cp->pmc_phc_pwr = cp->pmc_cur_pwr;
			cp->pmc_cur_pwr =
			    pm_level_to_index(dip, cp, level);
			PMD(PMD_PHC, ("%s: deadlock for %s@%s(%s#%d), comp=%d, "
			    "level=%d\n", pmf, PM_DEVICE(dip), comp, level))
			return (DDI_SUCCESS);
		} else
			if (blocked) {	/* blocked, but different cmpt? */
				if (!ndi_devi_tryenter(pdip, &pcirc)) {
					cmn_err(CE_NOTE,
					    "!pm: parent kuc not updated due "
					    "to possible deadlock.\n");
					return (pm_phc_impl(dip,
					    comp, level, 1));
				}
				old_level = cur_power(cp);
				if (pdip && !PM_WANTS_NOTIFICATION(pdip) &&
				    (!PM_ISBC(dip) || comp == 0) &&
				    POWERING_ON(old_level, level))
					pm_hold_power(pdip);
				ret = pm_phc_impl(dip, comp, level, 1);
				if (pdip && !PM_WANTS_NOTIFICATION(pdip)) {
					if ((!PM_ISBC(dip) ||
					    comp == 0) && level == 0 &&
					    old_level != PM_LEVEL_UNKNOWN)
						pm_rele_power(pdip);
				}
				ndi_devi_exit(pdip, pcirc);
				/* child lock not held: deadlock */
				return (ret);
			}
		delay(1);
		PMD(PMD_PHC, ("%s: try lock again\n", pmf))
	}

	/* non-deadlock case */
	old_level = cur_power(cp);
	if (pdip && !PM_WANTS_NOTIFICATION(pdip) &&
	    (!PM_ISBC(dip) || comp == 0) && POWERING_ON(old_level, level))
		pm_hold_power(pdip);
	ret = pm_phc_impl(dip, comp, level, 1);
	if (pdip && !PM_WANTS_NOTIFICATION(pdip)) {
		if ((!PM_ISBC(dip) || comp == 0) && level == 0 &&
		    old_level != PM_LEVEL_UNKNOWN)
			pm_rele_power(pdip);
	}
	PM_UNLOCK_POWER(dip, circ);
	ndi_devi_exit(pdip, pcirc);
	return (ret);
}

/*
 * Account for power changes to a component of the the console frame buffer.
 * If lowering power from full (or "unkown", which is treatd as full)
 * we will increment the "components off" count of the fb device.
 * Subsequent lowering of the same component doesn't affect the count.  If
 * raising a component back to full power, we will decrement the count.
 *
 * Return: the increment value for pm_cfb_comps_off (-1, 0, or 1)
 */
static int
calc_cfb_comps_incr(dev_info_t *dip, int cmpt, int old, int new)
{
	struct pm_component *cp = PM_CP(dip, cmpt);
	int on = (old == PM_LEVEL_UNKNOWN || old == cp->pmc_norm_pwr);
	int want_normal = (new == cp->pmc_norm_pwr);
	int incr = 0;

	if (on && !want_normal)
		incr = 1;
	else if (!on && want_normal)
		incr = -1;
	return (incr);
}

/*
 * Adjust the count of console frame buffer components < full power.
 */
static void
update_comps_off(int incr, dev_info_t *dip)
{
		mutex_enter(&pm_cfb_lock);
		pm_cfb_comps_off += incr;
		ASSERT(pm_cfb_comps_off <= PM_NUMCMPTS(dip));
		mutex_exit(&pm_cfb_lock);
}

/*
 * Update the power state in the framework (via the ppm).  The 'notify'
 * argument tells whether to notify watchers.  Power lock is already held.
 */
static int
pm_phc_impl(dev_info_t *dip, int comp, int level, int notify)
{
	PMD_FUNC(pmf, "phc_impl")
	power_req_t power_req;
	int i, dodeps = 0;
	dev_info_t *pdip = ddi_get_parent(dip);
	int result;
	int old_level;
	struct pm_component *cp;
	int incr = 0;
	dev_info_t *ppm = (dev_info_t *)DEVI(dip)->devi_pm_ppm;
	int work_type = 0;
	char *pathbuf;

	/* Must use "official" power level for this test. */
	cp = PM_CP(dip, comp);
	old_level = (cp->pmc_flags & PM_PHC_WHILE_SET_POWER ?
	    cp->pmc_phc_pwr : cp->pmc_cur_pwr);
	if (old_level != PM_LEVEL_UNKNOWN)
		old_level = cp->pmc_comp.pmc_lvals[old_level];

	if (level == old_level) {
		PMD(PMD_SET, ("%s: %s@%s(%s#%d), comp=%d is already at "
		    "level=%d\n", pmf, PM_DEVICE(dip), comp, level))
		return (DDI_SUCCESS);
	}

	/*
	 * Tell ppm about this.
	 */
	power_req.request_type = PMR_PPM_POWER_CHANGE_NOTIFY;
	power_req.req.ppm_notify_level_req.who = dip;
	power_req.req.ppm_notify_level_req.cmpt = comp;
	power_req.req.ppm_notify_level_req.new_level = level;
	power_req.req.ppm_notify_level_req.old_level = old_level;
	if (pm_ctlops(ppm, dip, DDI_CTLOPS_POWER, &power_req,
	    &result) == DDI_FAILURE) {
		PMD(PMD_FAIL, ("%s: pm_ctlops %s@%s(%s#%d) to %d failed\n",
		    pmf, PM_DEVICE(dip), level))
		return (DDI_FAILURE);
	}

	if (PM_IS_CFB(dip)) {
		incr = calc_cfb_comps_incr(dip, comp, old_level, level);

		if (incr) {
			update_comps_off(incr, dip);
			PMD(PMD_CFB, ("%s: %s@%s(%s#%d) comp=%d %d->%d "
			    "cfb_comps_off->%d\n", pmf, PM_DEVICE(dip),
			    comp, old_level, level, pm_cfb_comps_off))
		}
	}
	e_pm_set_cur_pwr(dip, PM_CP(dip, comp), level);
	result = DDI_SUCCESS;

	if (notify) {
		if (pdip && PM_WANTS_NOTIFICATION(pdip))
			pm_notify_parent(dip, pdip, comp, old_level, level);
		(void) pm_check_and_resume(dip, comp, old_level, level);
	}

	/*
	 * Decrement the dependency kidsup count if we turn a device
	 * off.
	 */
	if (POWERING_OFF(old_level, level)) {
		dodeps = 1;
		for (i = 0; i < PM_NUMCMPTS(dip); i++) {
			cp = PM_CP(dip, i);
			if (cur_power(cp)) {
				dodeps = 0;
				break;
			}
		}
		if (dodeps)
			work_type = PM_DEP_WK_POWER_OFF;
	}

	/*
	 * Increment if we turn it on. Check to see
	 * if other comps are already on, if so,
	 * dont increment.
	 */
	if (POWERING_ON(old_level, level)) {
		dodeps = 1;
		for (i = 0; i < PM_NUMCMPTS(dip); i++) {
			cp = PM_CP(dip, i);
			if (comp == i)
				continue;
			/* -1 also treated as 0 in this case */
			if (cur_power(cp) > 0) {
				dodeps = 0;
				break;
			}
		}
		if (dodeps)
			work_type = PM_DEP_WK_POWER_ON;
	}

	if (dodeps) {
		pathbuf = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
		(void) ddi_pathname(dip, pathbuf);
		pm_dispatch_to_dep_thread(work_type, pathbuf, NULL,
		    PM_DEP_NOWAIT, NULL, 0);
		kmem_free(pathbuf, MAXPATHLEN);
	}

	if (notify && (level != old_level) && pm_watchers()) {
		mutex_enter(&pm_rsvp_lock);
		pm_enqueue_notify(PSC_HAS_CHANGED, dip, comp, level, old_level,
		    PM_CANBLOCK_BLOCK);
		mutex_exit(&pm_rsvp_lock);
	}

	PMD(PMD_RESCAN, ("%s: %s@%s(%s#%d): pm_rescan\n", pmf, PM_DEVICE(dip)))
	pm_rescan(dip);
	return (DDI_SUCCESS);
}

/*
 * This function is called at startup time to notify pm of the existence
 * of any platform power managers for this platform.  As a result of
 * this registration, each function provided will be called each time
 * a device node is attached, until one returns true, and it must claim the
 * device node (by returning non-zero) if it wants to be involved in the
 * node's power management.  If it does claim the node, then it will
 * subsequently be notified of attach and detach events.
 *
 */

int
pm_register_ppm(int (*func)(dev_info_t *), dev_info_t *dip)
{
	PMD_FUNC(pmf, "register_ppm")
	struct ppm_callbacks *ppmcp;
	pm_component_t *cp;
	int i, pwr, result, circ;
	power_req_t power_req;
	struct ppm_notify_level_req *p = &power_req.req.ppm_notify_level_req;
	void pm_ppm_claim(dev_info_t *);

	mutex_enter(&ppm_lock);
	ppmcp = ppm_callbacks;
	for (i = 0; i < MAX_PPM_HANDLERS; i++, ppmcp++) {
		if (ppmcp->ppmc_func == NULL) {
			ppmcp->ppmc_func = func;
			ppmcp->ppmc_dip = dip;
			break;
		}
	}
	mutex_exit(&ppm_lock);

	if (i >= MAX_PPM_HANDLERS)
		return (DDI_FAILURE);
	while ((dip = ddi_get_parent(dip)) != NULL) {
		if (dip != ddi_root_node() && PM_GET_PM_INFO(dip) == NULL)
			continue;
		pm_ppm_claim(dip);
		/* don't bother with the not power-manageable nodes */
		if (pm_ppm_claimed(dip) && PM_GET_PM_INFO(dip)) {
			/*
			 * Tell ppm about this.
			 */
			power_req.request_type = PMR_PPM_POWER_CHANGE_NOTIFY;
			p->old_level = PM_LEVEL_UNKNOWN;
			p->who = dip;
			PM_LOCK_POWER(dip, &circ);
			for (i = 0; i < PM_NUMCMPTS(dip); i++) {
				cp = PM_CP(dip, i);
				pwr = cp->pmc_cur_pwr;
				if (pwr != PM_LEVEL_UNKNOWN) {
					p->cmpt = i;
					p->new_level = cur_power(cp);
					p->old_level = PM_LEVEL_UNKNOWN;
					if (pm_ctlops(PPM(dip), dip,
					    DDI_CTLOPS_POWER, &power_req,
					    &result) == DDI_FAILURE) {
						PMD(PMD_FAIL, ("%s: pc "
						    "%s@%s(%s#%d) to %d "
						    "fails\n", pmf,
						    PM_DEVICE(dip), pwr))
					}
				}
			}
			PM_UNLOCK_POWER(dip, circ);
		}
	}
	return (DDI_SUCCESS);
}

/*
 * Call the ppm's that have registered and adjust the devinfo struct as
 * appropriate.  First one to claim it gets it.  The sets of devices claimed
 * by each ppm are assumed to be disjoint.
 */
void
pm_ppm_claim(dev_info_t *dip)
{
	struct ppm_callbacks *ppmcp;

	if (PPM(dip)) {
		return;
	}
	mutex_enter(&ppm_lock);
	for (ppmcp = ppm_callbacks; ppmcp->ppmc_func; ppmcp++) {
		if ((*ppmcp->ppmc_func)(dip)) {
			DEVI(dip)->devi_pm_ppm =
			    (struct dev_info *)ppmcp->ppmc_dip;
			mutex_exit(&ppm_lock);
			return;
		}
	}
	mutex_exit(&ppm_lock);
}

/*
 * Node is being detached so stop autopm until we see if it succeeds, in which
 * case pm_stop will be called.  For backwards compatible devices we bring the
 * device up to full power on the assumption the detach will succeed.
 */
void
pm_detaching(dev_info_t *dip)
{
	PMD_FUNC(pmf, "detaching")
	pm_info_t *info = PM_GET_PM_INFO(dip);
	int iscons;

	PMD(PMD_REMDEV, ("%s: %s@%s(%s#%d), %d comps\n", pmf, PM_DEVICE(dip),
	    PM_NUMCMPTS(dip)))
	if (info == NULL)
		return;
	ASSERT(DEVI_IS_DETACHING(dip));
	PM_LOCK_DIP(dip);
	info->pmi_dev_pm_state |= PM_DETACHING;
	PM_UNLOCK_DIP(dip);
	if (!PM_ISBC(dip))
		pm_scan_stop(dip);

	/*
	 * console and old-style devices get brought up when detaching.
	 */
	iscons = PM_IS_CFB(dip);
	if (iscons || PM_ISBC(dip)) {
		(void) pm_all_to_normal(dip, PM_CANBLOCK_BYPASS);
		if (iscons) {
			mutex_enter(&pm_cfb_lock);
			while (cfb_inuse) {
				mutex_exit(&pm_cfb_lock);
				PMD(PMD_CFB, ("%s: delay; cfb_inuse\n", pmf))
				delay(1);
				mutex_enter(&pm_cfb_lock);
			}
			ASSERT(cfb_dip_detaching == NULL);
			ASSERT(cfb_dip);
			cfb_dip_detaching = cfb_dip;	/* case detach fails */
			cfb_dip = NULL;
			mutex_exit(&pm_cfb_lock);
		}
	}
}

/*
 * Node failed to detach.  If it used to be autopm'd, make it so again.
 */
void
pm_detach_failed(dev_info_t *dip)
{
	PMD_FUNC(pmf, "detach_failed")
	pm_info_t *info = PM_GET_PM_INFO(dip);
	int pm_all_at_normal(dev_info_t *);

	if (info == NULL)
		return;
	ASSERT(DEVI_IS_DETACHING(dip));
	if (info->pmi_dev_pm_state & PM_DETACHING) {
		info->pmi_dev_pm_state &= ~PM_DETACHING;
		if (info->pmi_dev_pm_state & PM_ALLNORM_DEFERRED) {
			/* Make sure the operation is still needed */
			if (!pm_all_at_normal(dip)) {
				if (pm_all_to_normal(dip,
				    PM_CANBLOCK_FAIL) != DDI_SUCCESS) {
					PMD(PMD_ERROR, ("%s: could not bring "
					    "%s@%s(%s#%d) to normal\n", pmf,
					    PM_DEVICE(dip)))
				}
			}
			info->pmi_dev_pm_state &= ~PM_ALLNORM_DEFERRED;
		}
	}
	if (!PM_ISBC(dip)) {
		mutex_enter(&pm_scan_lock);
		if (PM_SCANABLE(dip))
			pm_scan_init(dip);
		mutex_exit(&pm_scan_lock);
		pm_rescan(dip);
	}
}

/* generic Backwards Compatible component */
static char *bc_names[] = {"off", "on"};

static pm_comp_t bc_comp = {"unknown", 2, NULL, NULL, &bc_names[0]};

static void
e_pm_default_levels(dev_info_t *dip, pm_component_t *cp, int norm)
{
	pm_comp_t *pmc;
	pmc = &cp->pmc_comp;
	pmc->pmc_numlevels = 2;
	pmc->pmc_lvals[0] = 0;
	pmc->pmc_lvals[1] = norm;
	e_pm_set_cur_pwr(dip, cp, norm);
}

static void
e_pm_default_components(dev_info_t *dip, int cmpts)
{
	int i;
	pm_component_t *p = DEVI(dip)->devi_pm_components;

	p = DEVI(dip)->devi_pm_components;
	for (i = 0; i < cmpts; i++, p++) {
		p->pmc_comp = bc_comp;	/* struct assignment */
		p->pmc_comp.pmc_lvals = kmem_zalloc(2 * sizeof (int),
		    KM_SLEEP);
		p->pmc_comp.pmc_thresh = kmem_alloc(2 * sizeof (int),
		    KM_SLEEP);
		p->pmc_comp.pmc_numlevels = 2;
		p->pmc_comp.pmc_thresh[0] = INT_MAX;
		p->pmc_comp.pmc_thresh[1] = INT_MAX;
	}
}

/*
 * Called from functions that require components to exist already to allow
 * for their creation by parsing the pm-components property.
 * Device will not be power managed as a result of this call
 * No locking needed because we're single threaded by the ndi_devi_enter
 * done while attaching, and the device isn't visible until after it has
 * attached
 */
int
pm_premanage(dev_info_t *dip, int style)
{
	PMD_FUNC(pmf, "premanage")
	pm_comp_t	*pcp, *compp;
	int		cmpts, i, norm, error;
	pm_component_t *p = DEVI(dip)->devi_pm_components;
	pm_comp_t *pm_autoconfig(dev_info_t *, int *);

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	/*
	 * If this dip has already been processed, don't mess with it
	 */
	if (DEVI(dip)->devi_pm_flags & PMC_COMPONENTS_DONE)
		return (DDI_SUCCESS);
	if (DEVI(dip)->devi_pm_flags & PMC_COMPONENTS_FAILED) {
		return (DDI_FAILURE);
	}
	/*
	 * Look up pm-components property and create components accordingly
	 * If that fails, fall back to backwards compatibility
	 */
	if ((compp = pm_autoconfig(dip, &error)) == NULL) {
		/*
		 * If error is set, the property existed but was not well formed
		 */
		if (error || (style == PM_STYLE_NEW)) {
			DEVI(dip)->devi_pm_flags |= PMC_COMPONENTS_FAILED;
			return (DDI_FAILURE);
		}
		/*
		 * If they don't have the pm-components property, then we
		 * want the old "no pm until PM_SET_DEVICE_THRESHOLDS ioctl"
		 * behavior driver must have called pm_create_components, and
		 * we need to flesh out dummy components
		 */
		if ((cmpts = PM_NUMCMPTS(dip)) == 0) {
			/*
			 * Not really failure, but we don't want the
			 * caller to treat it as success
			 */
			return (DDI_FAILURE);
		}
		DEVI(dip)->devi_pm_flags |= PMC_BC;
		e_pm_default_components(dip, cmpts);
		for (i = 0; i < cmpts; i++) {
			/*
			 * if normal power not set yet, we don't really know
			 * what *ANY* of the power values are.  If normal
			 * power is set, then we assume for this backwards
			 * compatible case that the values are 0, normal power.
			 */
			norm = pm_get_normal_power(dip, i);
			if (norm == (uint_t)-1) {
				PMD(PMD_ERROR, ("%s: %s@%s(%s#%d)[%d]\n", pmf,
				    PM_DEVICE(dip), i))
				return (DDI_FAILURE);
			}
			/*
			 * Components of BC devices start at their normal power,
			 * so count them to be not at their lowest power.
			 */
			PM_INCR_NOTLOWEST(dip);
			e_pm_default_levels(dip, PM_CP(dip, i), norm);
		}
	} else {
		/*
		 * e_pm_create_components was called from pm_autoconfig(), it
		 * creates components with no descriptions (or known levels)
		 */
		cmpts = PM_NUMCMPTS(dip);
		ASSERT(cmpts != 0);
		pcp = compp;
		p = DEVI(dip)->devi_pm_components;
		for (i = 0; i < cmpts; i++, p++) {
			p->pmc_comp = *pcp++;   /* struct assignment */
			ASSERT(PM_CP(dip, i)->pmc_cur_pwr == 0);
			e_pm_set_cur_pwr(dip, PM_CP(dip, i), PM_LEVEL_UNKNOWN);
		}
		if (DEVI(dip)->devi_pm_flags & PMC_CPU_THRESH)
			pm_set_device_threshold(dip, pm_cpu_idle_threshold,
			    PMC_CPU_THRESH);
		else
			pm_set_device_threshold(dip, pm_system_idle_threshold,
			    PMC_DEF_THRESH);
		kmem_free(compp, cmpts * sizeof (pm_comp_t));
	}
	return (DDI_SUCCESS);
}

/*
 * Called from during or after the device's attach to let us know it is ready
 * to play autopm.   Look up the pm model and manage the device accordingly.
 * Returns system call errno value.
 * If DDI_ATTACH and DDI_DETACH were in same namespace, this would be
 * a little cleaner
 *
 * Called with dip lock held, return with dip lock unheld.
 */

int
e_pm_manage(dev_info_t *dip, int style)
{
	PMD_FUNC(pmf, "e_manage")
	pm_info_t	*info;
	dev_info_t	*pdip = ddi_get_parent(dip);
	int	pm_thresh_specd(dev_info_t *);
	int	count;
	char	*pathbuf;

	if (pm_premanage(dip, style) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}
	PMD(PMD_KIDSUP, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	ASSERT(PM_GET_PM_INFO(dip) == NULL);
	info = kmem_zalloc(sizeof (pm_info_t), KM_SLEEP);

	/*
	 * Now set up parent's kidsupcnt.  BC nodes are assumed to start
	 * out at their normal power, so they are "up", others start out
	 * unknown, which is effectively "up".  Parent which want notification
	 * get kidsupcnt of 0 always.
	 */
	count = (PM_ISBC(dip)) ? 1 : PM_NUMCMPTS(dip);
	if (count && pdip && !PM_WANTS_NOTIFICATION(pdip))
		e_pm_hold_rele_power(pdip, count);

	pm_set_pm_info(dip, info);
	/*
	 * Apply any recorded thresholds
	 */
	(void) pm_thresh_specd(dip);

	/*
	 * Do dependency processing.
	 */
	pathbuf = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	pm_dispatch_to_dep_thread(PM_DEP_WK_ATTACH, pathbuf, pathbuf,
	    PM_DEP_NOWAIT, NULL, 0);
	kmem_free(pathbuf, MAXPATHLEN);

	if (!PM_ISBC(dip)) {
		mutex_enter(&pm_scan_lock);
		if (PM_SCANABLE(dip)) {
			pm_scan_init(dip);
			mutex_exit(&pm_scan_lock);
			pm_rescan(dip);
		} else {
			mutex_exit(&pm_scan_lock);
		}
	}
	return (0);
}

/*
 * This is the obsolete exported interface for a driver to find out its
 * "normal" (max) power.
 * We only get components destroyed while no power management is
 * going on (and the device is detached), so we don't need a mutex here
 */
int
pm_get_normal_power(dev_info_t *dip, int comp)
{

	if (comp >= 0 && comp < PM_NUMCMPTS(dip)) {
		return (PM_CP(dip, comp)->pmc_norm_pwr);
	}
	return (DDI_FAILURE);
}

/*
 * Fetches the current power level.  Return DDI_SUCCESS or DDI_FAILURE.
 */
int
pm_get_current_power(dev_info_t *dip, int comp, int *levelp)
{
	if (comp >= 0 && comp < PM_NUMCMPTS(dip)) {
		*levelp = PM_CURPOWER(dip, comp);
		return (DDI_SUCCESS);
	}
	return (DDI_FAILURE);
}

/*
 * Returns current threshold of indicated component
 */
static int
cur_threshold(dev_info_t *dip, int comp)
{
	pm_component_t *cp = PM_CP(dip, comp);
	int pwr;

	if (PM_ISBC(dip)) {
		/*
		 * backwards compatible nodes only have one threshold
		 */
		return (cp->pmc_comp.pmc_thresh[1]);
	}
	pwr = cp->pmc_cur_pwr;
	if (pwr == PM_LEVEL_UNKNOWN) {
		int thresh;
		if (DEVI(dip)->devi_pm_flags & PMC_NEXDEF_THRESH)
			thresh = pm_default_nexus_threshold;
		else if (DEVI(dip)->devi_pm_flags & PMC_CPU_THRESH)
			thresh = pm_cpu_idle_threshold;
		else
			thresh = pm_system_idle_threshold;
		return (thresh);
	}
	ASSERT(cp->pmc_comp.pmc_thresh);
	return (cp->pmc_comp.pmc_thresh[pwr]);
}

/*
 * Compute next lower component power level given power index.
 */
static int
pm_next_lower_power(pm_component_t *cp, int pwrndx)
{
	int nxt_pwr;

	if (pwrndx == PM_LEVEL_UNKNOWN) {
		nxt_pwr = cp->pmc_comp.pmc_lvals[0];
	} else {
		pwrndx--;
		ASSERT(pwrndx >= 0);
		nxt_pwr = cp->pmc_comp.pmc_lvals[pwrndx];
	}
	return (nxt_pwr);
}

/*
 * Update the maxpower (normal) power of a component. Note that the
 * component's power level is only changed if it's current power level
 * is higher than the new max power.
 */
int
pm_update_maxpower(dev_info_t *dip, int comp, int level)
{
	PMD_FUNC(pmf, "update_maxpower")
	int old;
	int result;

	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, comp, NULL) ||
	    !e_pm_valid_power(dip, comp, level)) {
		PMD(PMD_FAIL, ("%s: validation checks failed for %s@%s(%s#%d) "
		    "comp=%d level=%d\n", pmf, PM_DEVICE(dip), comp, level))
		return (DDI_FAILURE);
	}
	old = e_pm_get_max_power(dip, comp);
	e_pm_set_max_power(dip, comp, level);

	if (pm_set_power(dip, comp, level, PM_LEVEL_DOWNONLY,
	    PM_CANBLOCK_BLOCK, 0, &result) != DDI_SUCCESS) {
		e_pm_set_max_power(dip, comp, old);
		PMD(PMD_FAIL, ("%s: %s@%s(%s#%d) pm_set_power failed\n", pmf,
		    PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}
	return (DDI_SUCCESS);
}

/*
 * Bring all components of device to normal power
 */
int
pm_all_to_normal(dev_info_t *dip, pm_canblock_t canblock)
{
	PMD_FUNC(pmf, "all_to_normal")
	int		*normal;
	int		i, ncomps, result;
	size_t		size;
	int		changefailed = 0;

	PMD(PMD_ALLNORM, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	ASSERT(PM_GET_PM_INFO(dip));
	if (pm_get_norm_pwrs(dip, &normal, &size) != DDI_SUCCESS) {
		PMD(PMD_ALLNORM, ("%s: can't get norm pwrs for "
		    "%s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}
	ncomps = PM_NUMCMPTS(dip);
	for (i = 0; i < ncomps; i++) {
		if (pm_set_power(dip, i, normal[i],
		    PM_LEVEL_UPONLY, canblock, 0, &result) != DDI_SUCCESS) {
			changefailed++;
			PMD(PMD_ALLNORM | PMD_FAIL, ("%s: failed to set "
			    "%s@%s(%s#%d)[%d] to %d, errno %d\n", pmf,
			    PM_DEVICE(dip), i, normal[i], result))
		}
	}
	kmem_free(normal, size);
	if (changefailed) {
		PMD(PMD_FAIL, ("%s: failed to set %d comps %s@%s(%s#%d) "
		    "to full power\n", pmf, changefailed, PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}
	return (DDI_SUCCESS);
}

/*
 * Returns true if all components of device are at normal power
 */
int
pm_all_at_normal(dev_info_t *dip)
{
	PMD_FUNC(pmf, "all_at_normal")
	int		*normal;
	int		i;
	size_t		size;

	PMD(PMD_ALLNORM, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	if (pm_get_norm_pwrs(dip, &normal, &size) != DDI_SUCCESS) {
		PMD(PMD_ALLNORM, ("%s: can't get normal power\n", pmf))
		return (DDI_FAILURE);
	}
	for (i = 0; i < PM_NUMCMPTS(dip); i++) {
		int current = PM_CURPOWER(dip, i);
		if (normal[i] > current) {
			PMD(PMD_ALLNORM, ("%s: %s@%s(%s#%d) comp=%d, "
			    "norm=%d, cur=%d\n", pmf, PM_DEVICE(dip), i,
			    normal[i], current))
			break;
		}
	}
	kmem_free(normal, size);
	if (i != PM_NUMCMPTS(dip)) {
		return (0);
	}
	return (1);
}

static void
bring_wekeeps_up(char *keeper)
{
	PMD_FUNC(pmf, "bring_wekeeps_up")
	int i;
	pm_pdr_t *dp;
	pm_info_t *wku_info;
	char *kept_path;
	dev_info_t *kept;
	static void bring_pmdep_up(dev_info_t *, int);

	if (panicstr) {
		return;
	}
	/*
	 * We process the request even if the keeper detaches because
	 * detach processing expects this to increment kidsupcnt of kept.
	 */
	PMD(PMD_BRING, ("%s: keeper= %s\n", pmf, keeper))
	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (strcmp(dp->pdr_keeper, keeper) != 0)
			continue;
		for (i = 0; i < dp->pdr_kept_count; i++) {
			kept_path = dp->pdr_kept_paths[i];
			if (kept_path == NULL)
				continue;
			ASSERT(kept_path[0] != '\0');
			if ((kept = pm_name_to_dip(kept_path, 1)) == NULL)
				continue;
			wku_info = PM_GET_PM_INFO(kept);
			if (wku_info == NULL) {
				if (kept)
					ddi_release_devi(kept);
				continue;
			}
			/*
			 * Don't mess with it if it is being detached, it isn't
			 * safe to call its power entry point
			 */
			if (wku_info->pmi_dev_pm_state & PM_DETACHING) {
				if (kept)
					ddi_release_devi(kept);
				continue;
			}
			bring_pmdep_up(kept, 1);
			ddi_release_devi(kept);
		}
	}
}

/*
 * Bring up the 'kept' device passed as argument
 */
static void
bring_pmdep_up(dev_info_t *kept_dip, int hold)
{
	PMD_FUNC(pmf, "bring_pmdep_up")
	int is_all_at_normal = 0;

	/*
	 * If the kept device has been unmanaged, do nothing.
	 */
	if (!PM_GET_PM_INFO(kept_dip))
		return;

	/* Just ignore DIRECT PM device till they are released. */
	if (!pm_processes_stopped && PM_ISDIRECT(kept_dip) &&
	    !(is_all_at_normal = pm_all_at_normal(kept_dip))) {
		PMD(PMD_BRING, ("%s: can't bring up PM_DIRECT %s@%s(%s#%d) "
		    "controlling process did something else\n", pmf,
		    PM_DEVICE(kept_dip)))
		DEVI(kept_dip)->devi_pm_flags |= PMC_SKIP_BRINGUP;
		return;
	}
	/* if we got here the keeper had a transition from OFF->ON */
	if (hold)
		pm_hold_power(kept_dip);

	if (!is_all_at_normal)
		(void) pm_all_to_normal(kept_dip, PM_CANBLOCK_FAIL);
}

/*
 * A bunch of stuff that belongs only to the next routine (or two)
 */

static const char namestr[] = "NAME=";
static const int nameln = sizeof (namestr) - 1;
static const char pmcompstr[] = "pm-components";

struct pm_comp_pkg {
	pm_comp_t		*comp;
	struct pm_comp_pkg	*next;
};

#define	isdigit(ch)	((ch) >= '0' && (ch) <= '9')

#define	isxdigit(ch)	(isdigit(ch) || ((ch) >= 'a' && (ch) <= 'f') || \
			((ch) >= 'A' && (ch) <= 'F'))

/*
 * Rather than duplicate this code ...
 * (this code excerpted from the function that follows it)
 */
#define	FINISH_COMP { \
	ASSERT(compp); \
	compp->pmc_lnames_sz = size; \
	tp = compp->pmc_lname_buf = kmem_alloc(size, KM_SLEEP); \
	compp->pmc_numlevels = level; \
	compp->pmc_lnames = kmem_alloc(level * sizeof (char *), KM_SLEEP); \
	compp->pmc_lvals = kmem_alloc(level * sizeof (int), KM_SLEEP); \
	compp->pmc_thresh = kmem_alloc(level * sizeof (int), KM_SLEEP); \
	/* copy string out of prop array into buffer */ \
	for (j = 0; j < level; j++) { \
		compp->pmc_thresh[j] = INT_MAX;		/* only [0] sticks */ \
		compp->pmc_lvals[j] = lvals[j]; \
		(void) strcpy(tp, lnames[j]); \
		compp->pmc_lnames[j] = tp; \
		tp += lszs[j]; \
	} \
	ASSERT(tp > compp->pmc_lname_buf && tp <= \
	    compp->pmc_lname_buf + compp->pmc_lnames_sz); \
	}

/*
 * Create (empty) component data structures.
 */
static void
e_pm_create_components(dev_info_t *dip, int num_components)
{
	struct pm_component *compp, *ocompp;
	int i, size = 0;

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	ASSERT(!DEVI(dip)->devi_pm_components);
	ASSERT(!(DEVI(dip)->devi_pm_flags & PMC_COMPONENTS_DONE));
	size = sizeof (struct pm_component) * num_components;

	compp = kmem_zalloc(size, KM_SLEEP);
	ocompp = compp;
	DEVI(dip)->devi_pm_comp_size = size;
	DEVI(dip)->devi_pm_num_components = num_components;
	PM_LOCK_BUSY(dip);
	for (i = 0; i < num_components;  i++) {
		compp->pmc_timestamp = gethrestime_sec();
		compp->pmc_norm_pwr = (uint_t)-1;
		compp++;
	}
	PM_UNLOCK_BUSY(dip);
	DEVI(dip)->devi_pm_components = ocompp;
	DEVI(dip)->devi_pm_flags |= PMC_COMPONENTS_DONE;
}

/*
 * Parse hex or decimal value from char string
 */
static char *
pm_parsenum(char *cp, int *valp)
{
	int ch, offset;
	char numbuf[256];
	char *np = numbuf;
	int value = 0;

	ch = *cp++;
	if (isdigit(ch)) {
		if (ch == '0') {
			if ((ch = *cp++) == 'x' || ch == 'X') {
				ch = *cp++;
				while (isxdigit(ch)) {
					*np++ = (char)ch;
					ch = *cp++;
				}
				*np = 0;
				cp--;
				goto hexval;
			} else {
				goto digit;
			}
		} else {
digit:
			while (isdigit(ch)) {
				*np++ = (char)ch;
				ch = *cp++;
			}
			*np = 0;
			cp--;
			goto decval;
		}
	} else
		return (NULL);

hexval:
	for (np = numbuf; *np; np++) {
		if (*np >= 'a' && *np <= 'f')
			offset = 'a' - 10;
		else if (*np >= 'A' && *np <= 'F')
			offset = 'A' - 10;
		else if (*np >= '0' && *np <= '9')
			offset = '0';
		value *= 16;
		value += *np - offset;
	}
	*valp = value;
	return (cp);

decval:
	offset = '0';
	for (np = numbuf; *np; np++) {
		value *= 10;
		value += *np - offset;
	}
	*valp = value;
	return (cp);
}

/*
 * Set max (previously documented as "normal") power.
 */
static void
e_pm_set_max_power(dev_info_t *dip, int component_number, int level)
{
	PM_CP(dip, component_number)->pmc_norm_pwr = level;
}

/*
 * Get max (previously documented as "normal") power.
 */
static int
e_pm_get_max_power(dev_info_t *dip, int component_number)
{
	return (PM_CP(dip, component_number)->pmc_norm_pwr);
}

/*
 * Internal routine for destroying components
 * It is called even when there might not be any, so it must be forgiving.
 */
static void
e_pm_destroy_components(dev_info_t *dip)
{
	int i;
	struct pm_component *cp;

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	if (PM_NUMCMPTS(dip) == 0)
		return;
	cp = DEVI(dip)->devi_pm_components;
	ASSERT(cp);
	for (i = 0; i < PM_NUMCMPTS(dip); i++, cp++) {
		int nlevels = cp->pmc_comp.pmc_numlevels;
		kmem_free(cp->pmc_comp.pmc_lvals, nlevels * sizeof (int));
		kmem_free(cp->pmc_comp.pmc_thresh, nlevels * sizeof (int));
		/*
		 * For BC nodes, the rest is static in bc_comp, so skip it
		 */
		if (PM_ISBC(dip))
			continue;
		kmem_free(cp->pmc_comp.pmc_name, cp->pmc_comp.pmc_name_sz);
		kmem_free(cp->pmc_comp.pmc_lnames, nlevels * sizeof (char *));
		kmem_free(cp->pmc_comp.pmc_lname_buf,
		    cp->pmc_comp.pmc_lnames_sz);
	}
	kmem_free(DEVI(dip)->devi_pm_components, DEVI(dip)->devi_pm_comp_size);
	DEVI(dip)->devi_pm_components = NULL;
	DEVI(dip)->devi_pm_num_components = 0;
	DEVI(dip)->devi_pm_flags &=
	    ~(PMC_COMPONENTS_DONE | PMC_COMPONENTS_FAILED);
}

/*
 * Read the pm-components property (if there is one) and use it to set up
 * components.  Returns a pointer to an array of component structures if
 * pm-components found and successfully parsed, else returns NULL.
 * Sets error return *errp to true to indicate a failure (as opposed to no
 * property being present).
 */
pm_comp_t *
pm_autoconfig(dev_info_t *dip, int *errp)
{
	PMD_FUNC(pmf, "autoconfig")
	uint_t nelems;
	char **pp;
	pm_comp_t *compp = NULL;
	int i, j, level, components = 0;
	size_t size = 0;
	struct pm_comp_pkg *p, *ptail;
	struct pm_comp_pkg *phead = NULL;
	int *lvals = NULL;
	int *lszs = NULL;
	int *np = NULL;
	int npi = 0;
	char **lnames = NULL;
	char *cp, *tp;
	pm_comp_t *ret = NULL;

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	*errp = 0;	/* assume success */
	if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    (char *)pmcompstr, &pp, &nelems) != DDI_PROP_SUCCESS) {
		return (NULL);
	}

	if (nelems < 3) {	/* need at least one name and two levels */
		goto errout;
	}

	/*
	 * pm_create_components is no longer allowed
	 */
	if (PM_NUMCMPTS(dip) != 0) {
		PMD(PMD_ERROR, ("%s: %s@%s(%s#%d) has %d comps\n",
		    pmf, PM_DEVICE(dip), PM_NUMCMPTS(dip)))
		goto errout;
	}

	lvals = kmem_alloc(nelems * sizeof (int), KM_SLEEP);
	lszs = kmem_alloc(nelems * sizeof (int), KM_SLEEP);
	lnames = kmem_alloc(nelems * sizeof (char *), KM_SLEEP);
	np = kmem_alloc(nelems * sizeof (int), KM_SLEEP);

	level = 0;
	phead = NULL;
	for (i = 0; i < nelems; i++) {
		cp = pp[i];
		if (!isdigit(*cp)) {	/*  must be name */
			if (strncmp(cp, namestr, nameln) != 0) {
				goto errout;
			}
			if (i != 0) {
				if (level == 0) {	/* no level spec'd */
					PMD(PMD_ERROR, ("%s: no level spec'd\n",
					    pmf))
					goto errout;
				}
				np[npi++] = lvals[level - 1];
				/* finish up previous component levels */
				FINISH_COMP;
			}
			cp += nameln;
			if (!*cp) {
				PMD(PMD_ERROR, ("%s: nsa\n", pmf))
				goto errout;
			}
			p = kmem_zalloc(sizeof (*phead), KM_SLEEP);
			if (phead == NULL) {
				phead = ptail = p;
			} else {
				ptail->next = p;
				ptail = p;
			}
			compp = p->comp = kmem_zalloc(sizeof (pm_comp_t),
			    KM_SLEEP);
			compp->pmc_name_sz = strlen(cp) + 1;
			compp->pmc_name = kmem_zalloc(compp->pmc_name_sz,
			    KM_SLEEP);
			(void) strncpy(compp->pmc_name, cp, compp->pmc_name_sz);
			components++;
			level = 0;
		} else {	/* better be power level <num>=<name> */
#ifdef DEBUG
			tp = cp;
#endif
			if (i == 0 ||
			    (cp = pm_parsenum(cp, &lvals[level])) == NULL) {
				PMD(PMD_ERROR, ("%s: parsenum(%s)\n", pmf, tp))
				goto errout;
			}
#ifdef DEBUG
			tp = cp;
#endif
			if (*cp++ != '=' || !*cp) {
				PMD(PMD_ERROR, ("%s: ex =, got %s\n", pmf, tp))
				goto errout;
			}

			lszs[level] = strlen(cp) + 1;
			size += lszs[level];
			lnames[level] = cp;	/* points into prop string */
			level++;
		}
	}
	np[npi++] = lvals[level - 1];
	if (level == 0) {	/* ended with a name */
		PMD(PMD_ERROR, ("%s: ewn\n", pmf))
		goto errout;
	}
	FINISH_COMP;


	/*
	 * Now we have a list of components--we have to return instead an
	 * array of them, but we can just copy the top level and leave
	 * the rest as is
	 */
	(void) e_pm_create_components(dip, components);
	for (i = 0; i < components; i++)
		e_pm_set_max_power(dip, i, np[i]);

	ret = kmem_zalloc(components * sizeof (pm_comp_t), KM_SLEEP);
	for (i = 0, p = phead; i < components; i++) {
		ASSERT(p);
		/*
		 * Now sanity-check values:  levels must be monotonically
		 * increasing
		 */
		if (p->comp->pmc_numlevels < 2) {
			PMD(PMD_ERROR, ("%s: comp %s of %s@%s(%s#%d) only %d "
			    "levels\n", pmf,
			    p->comp->pmc_name, PM_DEVICE(dip),
			    p->comp->pmc_numlevels))
			goto errout;
		}
		for (j = 0; j < p->comp->pmc_numlevels; j++) {
			if ((p->comp->pmc_lvals[j] < 0) || ((j > 0) &&
			    (p->comp->pmc_lvals[j] <=
			    p->comp->pmc_lvals[j - 1]))) {
				PMD(PMD_ERROR, ("%s: comp %s of %s@%s(%s#%d) "
				    "not mono. incr, %d follows %d\n", pmf,
				    p->comp->pmc_name, PM_DEVICE(dip),
				    p->comp->pmc_lvals[j],
				    p->comp->pmc_lvals[j - 1]))
				goto errout;
			}
		}
		ret[i] = *p->comp;	/* struct assignment */
		for (j = 0; j < i; j++) {
			/*
			 * Test for unique component names
			 */
			if (strcmp(ret[j].pmc_name, ret[i].pmc_name) == 0) {
				PMD(PMD_ERROR, ("%s: %s of %s@%s(%s#%d) not "
				    "unique\n", pmf, ret[j].pmc_name,
				    PM_DEVICE(dip)))
				goto errout;
			}
		}
		ptail = p;
		p = p->next;
		phead = p;	/* errout depends on phead making sense */
		kmem_free(ptail->comp, sizeof (*ptail->comp));
		kmem_free(ptail, sizeof (*ptail));
	}
out:
	ddi_prop_free(pp);
	if (lvals)
		kmem_free(lvals, nelems * sizeof (int));
	if (lszs)
		kmem_free(lszs, nelems * sizeof (int));
	if (lnames)
		kmem_free(lnames, nelems * sizeof (char *));
	if (np)
		kmem_free(np, nelems * sizeof (int));
	return (ret);

errout:
	e_pm_destroy_components(dip);
	*errp = 1;	/* signal failure */
	cmn_err(CE_CONT, "!pm: %s property ", pmcompstr);
	for (i = 0; i < nelems - 1; i++)
		cmn_err(CE_CONT, "!'%s', ", pp[i]);
	if (nelems != 0)
		cmn_err(CE_CONT, "!'%s'", pp[nelems - 1]);
	cmn_err(CE_CONT, "! for %s@%s(%s#%d) is ill-formed.\n", PM_DEVICE(dip));
	for (p = phead; p; ) {
		pm_comp_t *pp;
		int n;

		ptail = p;
		/*
		 * Free component data structures
		 */
		pp = p->comp;
		n = pp->pmc_numlevels;
		if (pp->pmc_name_sz) {
			kmem_free(pp->pmc_name, pp->pmc_name_sz);
		}
		if (pp->pmc_lnames_sz) {
			kmem_free(pp->pmc_lname_buf, pp->pmc_lnames_sz);
		}
		if (pp->pmc_lnames) {
			kmem_free(pp->pmc_lnames, n * (sizeof (char *)));
		}
		if (pp->pmc_thresh) {
			kmem_free(pp->pmc_thresh, n * (sizeof (int)));
		}
		if (pp->pmc_lvals) {
			kmem_free(pp->pmc_lvals, n * (sizeof (int)));
		}
		p = ptail->next;
		kmem_free(ptail, sizeof (*ptail));
	}
	if (ret != NULL)
		kmem_free(ret, components * sizeof (pm_comp_t));
	ret = NULL;
	goto out;
}

/*
 * Set threshold values for a devices components by dividing the target
 * threshold (base) by the number of transitions and assign each transition
 * that threshold.  This will get the entire device down in the target time if
 * all components are idle and even if there are dependencies among components.
 *
 * Devices may well get powered all the way down before the target time, but
 * at least the EPA will be happy.
 */
void
pm_set_device_threshold(dev_info_t *dip, int base, int flag)
{
	PMD_FUNC(pmf, "set_device_threshold")
	int target_threshold = (base * 95) / 100;
	int level, comp;		/* loop counters */
	int transitions = 0;
	int ncomp = PM_NUMCMPTS(dip);
	int thresh;
	int remainder;
	pm_comp_t *pmc;
	int i, circ;

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	PM_LOCK_DIP(dip);
	/*
	 * First we handle the easy one.  If we're setting the default
	 * threshold for a node with children, then we set it to the
	 * default nexus threshold (currently 0) and mark it as default
	 * nexus threshold instead
	 */
	if (PM_IS_NEXUS(dip)) {
		if (flag == PMC_DEF_THRESH) {
			PMD(PMD_THRESH, ("%s: [%s@%s(%s#%d) NEXDEF]\n", pmf,
			    PM_DEVICE(dip)))
			thresh = pm_default_nexus_threshold;
			for (comp = 0; comp < ncomp; comp++) {
				pmc = &PM_CP(dip, comp)->pmc_comp;
				for (level = 1; level < pmc->pmc_numlevels;
				    level++) {
					pmc->pmc_thresh[level] = thresh;
				}
			}
			DEVI(dip)->devi_pm_dev_thresh =
			    pm_default_nexus_threshold;
			/*
			 * If the nexus node is being reconfigured back to
			 * the default threshold, adjust the notlowest count.
			 */
			if (DEVI(dip)->devi_pm_flags &
			    (PMC_DEV_THRESH|PMC_COMP_THRESH)) {
				PM_LOCK_POWER(dip, &circ);
				for (i = 0; i < PM_NUMCMPTS(dip); i++) {
					if (PM_CURPOWER(dip, i) == 0)
						continue;
					mutex_enter(&pm_compcnt_lock);
					ASSERT(pm_comps_notlowest);
					pm_comps_notlowest--;
					PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d) decr "
					    "notlowest to %d\n", pmf,
					    PM_DEVICE(dip), pm_comps_notlowest))
					if (pm_comps_notlowest == 0)
						pm_ppm_notify_all_lowest(dip,
						    PM_ALL_LOWEST);
					mutex_exit(&pm_compcnt_lock);
				}
				PM_UNLOCK_POWER(dip, circ);
			}
			DEVI(dip)->devi_pm_flags &= PMC_THRESH_NONE;
			DEVI(dip)->devi_pm_flags |= PMC_NEXDEF_THRESH;
			PM_UNLOCK_DIP(dip);
			return;
		} else if (DEVI(dip)->devi_pm_flags & PMC_NEXDEF_THRESH) {
			/*
			 * If the nexus node is being configured for a
			 * non-default threshold, include that node in
			 * the notlowest accounting.
			 */
			PM_LOCK_POWER(dip, &circ);
			for (i = 0; i < PM_NUMCMPTS(dip); i++) {
				if (PM_CURPOWER(dip, i) == 0)
					continue;
				mutex_enter(&pm_compcnt_lock);
				if (pm_comps_notlowest == 0)
					pm_ppm_notify_all_lowest(dip,
					    PM_NOT_ALL_LOWEST);
				pm_comps_notlowest++;
				PMD(PMD_LEVEL, ("%s: %s@%s(%s#%d) incr "
				    "notlowest to %d\n", pmf,
				    PM_DEVICE(dip), pm_comps_notlowest))
				mutex_exit(&pm_compcnt_lock);
			}
			PM_UNLOCK_POWER(dip, circ);
		}
	}
	/*
	 * Compute the total number of transitions for all components
	 * of the device.  Distribute the threshold evenly over them
	 */
	for (comp = 0; comp < ncomp; comp++) {
		pmc = &PM_CP(dip, comp)->pmc_comp;
		ASSERT(pmc->pmc_numlevels > 1);
		transitions += pmc->pmc_numlevels - 1;
	}
	ASSERT(transitions);
	thresh = target_threshold / transitions;

	for (comp = 0; comp < ncomp; comp++) {
		pmc = &PM_CP(dip, comp)->pmc_comp;
		for (level = 1; level < pmc->pmc_numlevels; level++) {
			pmc->pmc_thresh[level] = thresh;
		}
	}

#ifdef DEBUG
	for (comp = 0; comp < ncomp; comp++) {
		pmc = &PM_CP(dip, comp)->pmc_comp;
		for (level = 1; level < pmc->pmc_numlevels; level++) {
			PMD(PMD_THRESH, ("%s: thresh before %s@%s(%s#%d) "
			    "comp=%d, level=%d, %d\n", pmf, PM_DEVICE(dip),
			    comp, level, pmc->pmc_thresh[level]))
		}
	}
#endif
	/*
	 * Distribute any remainder till they are all gone
	 */
	remainder = target_threshold - thresh * transitions;
	level = 1;
#ifdef DEBUG
	PMD(PMD_THRESH, ("%s: remainder=%d target_threshold=%d thresh=%d "
	    "trans=%d\n", pmf, remainder, target_threshold, thresh,
	    transitions))
#endif
	while (remainder > 0) {
		comp = 0;
		while (remainder && (comp < ncomp)) {
			pmc = &PM_CP(dip, comp)->pmc_comp;
			if (level < pmc->pmc_numlevels) {
				pmc->pmc_thresh[level] += 1;
				remainder--;
			}
			comp++;
		}
		level++;
	}
#ifdef DEBUG
	for (comp = 0; comp < ncomp; comp++) {
		pmc = &PM_CP(dip, comp)->pmc_comp;
		for (level = 1; level < pmc->pmc_numlevels; level++) {
			PMD(PMD_THRESH, ("%s: thresh after %s@%s(%s#%d) "
			    "comp=%d level=%d, %d\n", pmf, PM_DEVICE(dip),
			    comp, level, pmc->pmc_thresh[level]))
		}
	}
#endif
	ASSERT(PM_IAM_LOCKING_DIP(dip));
	DEVI(dip)->devi_pm_dev_thresh = base;
	DEVI(dip)->devi_pm_flags &= PMC_THRESH_NONE;
	DEVI(dip)->devi_pm_flags |= flag;
	PM_UNLOCK_DIP(dip);
}

/*
 * Called when there is no old-style platform power management driver
 */
static int
ddi_no_platform_power(power_req_t *req)
{
	_NOTE(ARGUNUSED(req))
	return (DDI_FAILURE);
}

/*
 * This function calls the entry point supplied by the platform-specific
 * pm driver to bring the device component 'pm_cmpt' to power level 'pm_level'.
 * The use of global for getting the  function name from platform-specific
 * pm driver is not ideal, but it is simple and efficient.
 * The previous property lookup was being done in the idle loop on swift
 * systems without pmc chips and hurt deskbench performance as well as
 * violating scheduler locking rules
 */
int	(*pm_platform_power)(power_req_t *) = ddi_no_platform_power;

/*
 * Old obsolete interface for a device to request a power change (but only
 * an increase in power)
 */
int
ddi_dev_is_needed(dev_info_t *dip, int cmpt, int level)
{
	return (pm_raise_power(dip, cmpt, level));
}

/*
 * The old obsolete interface to platform power management.  Only used by
 * Gypsy platform and APM on X86.
 */
int
ddi_power(dev_info_t *dip, int pm_cmpt, int pm_level)
{
	power_req_t	request;

	request.request_type = PMR_SET_POWER;
	request.req.set_power_req.who = dip;
	request.req.set_power_req.cmpt = pm_cmpt;
	request.req.set_power_req.level = pm_level;
	return (ddi_ctlops(dip, dip, DDI_CTLOPS_POWER, &request, NULL));
}

/*
 * A driver can invoke this from its detach routine when DDI_SUSPEND is
 * passed.  Returns true if subsequent processing could result in power being
 * removed from the device.  The arg is not currently used because it is
 * implicit in the operation of cpr/DR.
 */
int
ddi_removing_power(dev_info_t *dip)
{
	_NOTE(ARGUNUSED(dip))
	return (pm_powering_down);
}

/*
 * Returns true if a device indicates that its parent handles suspend/resume
 * processing for it.
 */
int
e_ddi_parental_suspend_resume(dev_info_t *dip)
{
	return (DEVI(dip)->devi_pm_flags & PMC_PARENTAL_SR);
}

/*
 * Called for devices which indicate that their parent does suspend/resume
 * handling for them
 */
int
e_ddi_suspend(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	power_req_t	request;
	request.request_type = PMR_SUSPEND;
	request.req.suspend_req.who = dip;
	request.req.suspend_req.cmd = cmd;
	return (ddi_ctlops(dip, dip, DDI_CTLOPS_POWER, &request, NULL));
}

/*
 * Called for devices which indicate that their parent does suspend/resume
 * handling for them
 */
int
e_ddi_resume(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	power_req_t	request;
	request.request_type = PMR_RESUME;
	request.req.resume_req.who = dip;
	request.req.resume_req.cmd = cmd;
	return (ddi_ctlops(dip, dip, DDI_CTLOPS_POWER, &request, NULL));
}

/*
 * Old obsolete exported interface for drivers to create components.
 * This is now handled by exporting the pm-components property.
 */
int
pm_create_components(dev_info_t *dip, int num_components)
{
	PMD_FUNC(pmf, "pm_create_components")

	if (num_components < 1)
		return (DDI_FAILURE);

	if (!DEVI_IS_ATTACHING(dip)) {
		return (DDI_FAILURE);
	}

	/* don't need to lock dip because attach is single threaded */
	if (DEVI(dip)->devi_pm_components) {
		PMD(PMD_ERROR, ("%s: %s@%s(%s#%d) already has %d\n", pmf,
		    PM_DEVICE(dip), PM_NUMCMPTS(dip)))
		return (DDI_FAILURE);
	}
	e_pm_create_components(dip, num_components);
	DEVI(dip)->devi_pm_flags |= PMC_BC;
	e_pm_default_components(dip, num_components);
	return (DDI_SUCCESS);
}

/*
 * Obsolete interface previously called by drivers to destroy their components
 * at detach time.  This is now done automatically.  However, we need to keep
 * this for the old drivers.
 */
void
pm_destroy_components(dev_info_t *dip)
{
	PMD_FUNC(pmf, "pm_destroy_components")
	dev_info_t *pdip = ddi_get_parent(dip);

	PMD(PMD_REMDEV | PMD_KIDSUP, ("%s: %s@%s(%s#%d)\n", pmf,
	    PM_DEVICE(dip)))
	ASSERT(DEVI_IS_DETACHING(dip));
#ifdef DEBUG
	if (!PM_ISBC(dip))
		cmn_err(CE_WARN, "!driver exporting pm-components property "
		    "(%s@%s) calls pm_destroy_components", PM_NAME(dip),
		    PM_ADDR(dip));
#endif
	/*
	 * We ignore this unless this is an old-style driver, except for
	 * printing the message above
	 */
	if (PM_NUMCMPTS(dip) == 0 || !PM_ISBC(dip)) {
		PMD(PMD_REMDEV, ("%s: ignore %s@%s(%s#%d)\n", pmf,
		    PM_DEVICE(dip)))
		return;
	}
	ASSERT(PM_GET_PM_INFO(dip));

	/*
	 * pm_unmanage will clear info pointer later, after dealing with
	 * dependencies
	 */
	ASSERT(!PM_GET_PM_SCAN(dip));	/* better be gone already */
	/*
	 * Now adjust parent's kidsupcnt.  We check only comp 0.
	 * Parents that get notification are not adjusted because their
	 * kidsupcnt is always 0 (or 1 during probe and attach).
	 */
	if ((PM_CURPOWER(dip, 0) != 0) && pdip && !PM_WANTS_NOTIFICATION(pdip))
		pm_rele_power(pdip);
#ifdef DEBUG
	else {
		PMD(PMD_KIDSUP, ("%s: kuc stays %s@%s(%s#%d) comps gone\n",
		    pmf, PM_DEVICE(dip)))
	}
#endif
	e_pm_destroy_components(dip);
	/*
	 * Forget we ever knew anything about the components of this  device
	 */
	DEVI(dip)->devi_pm_flags &=
	    ~(PMC_BC | PMC_COMPONENTS_DONE | PMC_COMPONENTS_FAILED);
}

/*
 * Exported interface for a driver to set a component busy.
 */
int
pm_busy_component(dev_info_t *dip, int cmpt)
{
	struct pm_component *cp;

	ASSERT(dip != NULL);
	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, cmpt, &cp))
		return (DDI_FAILURE);
	PM_LOCK_BUSY(dip);
	cp->pmc_busycount++;
	cp->pmc_timestamp = 0;
	PM_UNLOCK_BUSY(dip);
	return (DDI_SUCCESS);
}

/*
 * Exported interface for a driver to set a component idle.
 */
int
pm_idle_component(dev_info_t *dip, int cmpt)
{
	PMD_FUNC(pmf, "pm_idle_component")
	struct pm_component *cp;
	pm_scan_t	*scanp = PM_GET_PM_SCAN(dip);

	if (!e_pm_valid_info(dip, NULL) || !e_pm_valid_comp(dip, cmpt, &cp))
		return (DDI_FAILURE);

	PM_LOCK_BUSY(dip);
	if (cp->pmc_busycount) {
		if (--(cp->pmc_busycount) == 0)
			cp->pmc_timestamp = gethrestime_sec();
	} else {
		cp->pmc_timestamp = gethrestime_sec();
	}

	PM_UNLOCK_BUSY(dip);

	/*
	 * if device becomes idle during idle down period, try scan it down
	 */
	if (scanp && PM_IS_PID(dip)) {
		PMD(PMD_IDLEDOWN, ("%s: %s@%s(%s#%d) idle.\n", pmf,
		    PM_DEVICE(dip)))
		pm_rescan(dip);
		return (DDI_SUCCESS);
	}

	/*
	 * handle scan not running with nexus threshold == 0
	 */

	if (PM_IS_NEXUS(dip) && (cp->pmc_busycount == 0)) {
		pm_rescan(dip);
	}

	return (DDI_SUCCESS);
}

/*
 * This is the old  obsolete interface called by drivers to set their normal
 * power.  Thus we can't fix its behavior or return a value.
 * This functionality is replaced by the pm-component property.
 * We'll only get components destroyed while no power management is
 * going on (and the device is detached), so we don't need a mutex here
 */
void
pm_set_normal_power(dev_info_t *dip, int comp, int level)
{
	PMD_FUNC(pmf, "set_normal_power")
#ifdef DEBUG
	if (!PM_ISBC(dip))
		cmn_err(CE_WARN, "!call to pm_set_normal_power() by %s@%s "
		    "(driver exporting pm-components property) ignored",
		    PM_NAME(dip), PM_ADDR(dip));
#endif
	if (PM_ISBC(dip)) {
		PMD(PMD_NORM, ("%s: %s@%s(%s#%d) set normal power comp=%d, "
		    "level=%d\n", pmf, PM_DEVICE(dip), comp, level))
		e_pm_set_max_power(dip, comp, level);
		e_pm_default_levels(dip, PM_CP(dip, comp), level);
	}
}

/*
 * Called on a successfully detached driver to free pm resources
 */
static void
pm_stop(dev_info_t *dip)
{
	PMD_FUNC(pmf, "stop")
	dev_info_t *pdip = ddi_get_parent(dip);

	ASSERT(!PM_IAM_LOCKING_DIP(dip));
	/* stopping scan, destroy scan data structure */
	if (!PM_ISBC(dip)) {
		pm_scan_stop(dip);
		pm_scan_fini(dip);
	}

	if (PM_GET_PM_INFO(dip) != NULL) {
		if (pm_unmanage(dip) == DDI_SUCCESS) {
			/*
			 * Old style driver may have called
			 * pm_destroy_components already, but just in case ...
			 */
			e_pm_destroy_components(dip);
		} else {
			PMD(PMD_FAIL, ("%s: can't pm_unmanage %s@%s(%s#%d)\n",
			    pmf, PM_DEVICE(dip)))
		}
	} else {
		if (PM_NUMCMPTS(dip))
			e_pm_destroy_components(dip);
		else {
			if (DEVI(dip)->devi_pm_flags & PMC_NOPMKID) {
				DEVI(dip)->devi_pm_flags &= ~PMC_NOPMKID;
				if (pdip && !PM_WANTS_NOTIFICATION(pdip)) {
					pm_rele_power(pdip);
				} else if (pdip &&
				    MDI_VHCI(pdip) && MDI_CLIENT(dip)) {
					(void) mdi_power(pdip,
					    MDI_PM_RELE_POWER,
					    (void *)dip, NULL, 0);
				}
			}
		}
	}
}

/*
 * The node is the subject of a reparse pm props ioctl. Throw away the old
 * info and start over.
 */
int
e_new_pm_props(dev_info_t *dip)
{
	if (PM_GET_PM_INFO(dip) != NULL) {
		pm_stop(dip);

		if (e_pm_manage(dip, PM_STYLE_NEW) != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}
	}
	e_pm_props(dip);
	return (DDI_SUCCESS);
}

/*
 * Device has been attached, so process its pm properties
 */
void
e_pm_props(dev_info_t *dip)
{
	char *pp;
	int len;
	int flags = 0;
	int propflag = DDI_PROP_DONTPASS|DDI_PROP_CANSLEEP;

	/*
	 * It doesn't matter if we do this more than once, we should always
	 * get the same answers, and if not, then the last one in is the
	 * best one.
	 */
	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, propflag, "pm-hardware-state",
	    (caddr_t)&pp, &len) == DDI_PROP_SUCCESS) {
		if (strcmp(pp, "needs-suspend-resume") == 0) {
			flags = PMC_NEEDS_SR;
		} else if (strcmp(pp, "no-suspend-resume") == 0) {
			flags = PMC_NO_SR;
		} else if (strcmp(pp, "parental-suspend-resume") == 0) {
			flags = PMC_PARENTAL_SR;
		} else {
			cmn_err(CE_NOTE, "!device %s@%s has unrecognized "
			    "%s property value '%s'", PM_NAME(dip),
			    PM_ADDR(dip), "pm-hardware-state", pp);
		}
		kmem_free(pp, len);
	}
	/*
	 * This next segment (PMC_WANTS_NOTIFY) is in
	 * support of nexus drivers which will want to be involved in
	 * (or at least notified of) their child node's power level transitions.
	 * "pm-want-child-notification?" is defined by the parent.
	 */
	if (ddi_prop_exists(DDI_DEV_T_ANY, dip, propflag,
	    "pm-want-child-notification?") && PM_HAS_BUS_POWER(dip))
		flags |= PMC_WANTS_NOTIFY;
	ASSERT(PM_HAS_BUS_POWER(dip) || !ddi_prop_exists(DDI_DEV_T_ANY,
	    dip, propflag, "pm-want-child-notification?"));
	if (ddi_prop_exists(DDI_DEV_T_ANY, dip, propflag,
	    "no-involuntary-power-cycles"))
		flags |= PMC_NO_INVOL;
	/*
	 * Is the device a CPU device?
	 */
	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, propflag, "pm-class",
	    (caddr_t)&pp, &len) == DDI_PROP_SUCCESS) {
		if (strcmp(pp, "CPU") == 0) {
			flags |= PMC_CPU_DEVICE;
		} else {
			cmn_err(CE_NOTE, "!device %s@%s has unrecognized "
			    "%s property value '%s'", PM_NAME(dip),
			    PM_ADDR(dip), "pm-class", pp);
		}
		kmem_free(pp, len);
	}
	/* devfs single threads us */
	DEVI(dip)->devi_pm_flags |= flags;
}

/*
 * This is the DDI_CTLOPS_POWER handler that is used when there is no ppm
 * driver which has claimed a node.
 * Sets old_power in arg struct.
 */
static int
pm_default_ctlops(dev_info_t *dip, dev_info_t *rdip,
    ddi_ctl_enum_t ctlop, void *arg, void *result)
{
	_NOTE(ARGUNUSED(dip))
	PMD_FUNC(pmf, "ctlops")
	power_req_t *reqp = (power_req_t *)arg;
	int retval;
	dev_info_t *target_dip;
	int new_level, old_level, cmpt;
#ifdef PMDDEBUG
	char *format;
#endif

	/*
	 * The interface for doing the actual power level changes is now
	 * through the DDI_CTLOPS_POWER bus_ctl, so that we can plug in
	 * different platform-specific power control drivers.
	 *
	 * This driver implements the "default" version of this interface.
	 * If no ppm driver has been installed then this interface is called
	 * instead.
	 */
	ASSERT(dip == NULL);
	switch (ctlop) {
	case DDI_CTLOPS_POWER:
		switch (reqp->request_type) {
		case PMR_PPM_SET_POWER:
		{
			target_dip = reqp->req.ppm_set_power_req.who;
			ASSERT(target_dip == rdip);
			new_level = reqp->req.ppm_set_power_req.new_level;
			cmpt = reqp->req.ppm_set_power_req.cmpt;
			/* pass back old power for the PM_LEVEL_UNKNOWN case */
			old_level = PM_CURPOWER(target_dip, cmpt);
			reqp->req.ppm_set_power_req.old_level = old_level;
			retval = pm_power(target_dip, cmpt, new_level);
			PMD(PMD_PPM, ("%s: PPM_SET_POWER %s@%s(%s#%d)[%d] %d->"
			    "%d %s\n", pmf, PM_DEVICE(target_dip), cmpt,
			    old_level, new_level, (retval == DDI_SUCCESS ?
			    "chd" : "no chg")))
			return (retval);
		}

		case PMR_PPM_PRE_DETACH:
		case PMR_PPM_POST_DETACH:
		case PMR_PPM_PRE_ATTACH:
		case PMR_PPM_POST_ATTACH:
		case PMR_PPM_PRE_PROBE:
		case PMR_PPM_POST_PROBE:
		case PMR_PPM_PRE_RESUME:
		case PMR_PPM_INIT_CHILD:
		case PMR_PPM_UNINIT_CHILD:
#ifdef PMDDEBUG
			switch (reqp->request_type) {
				case PMR_PPM_PRE_DETACH:
					format = "%s: PMR_PPM_PRE_DETACH "
					    "%s@%s(%s#%d)\n";
					break;
				case PMR_PPM_POST_DETACH:
					format = "%s: PMR_PPM_POST_DETACH "
					    "%s@%s(%s#%d) rets %d\n";
					break;
				case PMR_PPM_PRE_ATTACH:
					format = "%s: PMR_PPM_PRE_ATTACH "
					    "%s@%s(%s#%d)\n";
					break;
				case PMR_PPM_POST_ATTACH:
					format = "%s: PMR_PPM_POST_ATTACH "
					    "%s@%s(%s#%d) rets %d\n";
					break;
				case PMR_PPM_PRE_PROBE:
					format = "%s: PMR_PPM_PRE_PROBE "
					    "%s@%s(%s#%d)\n";
					break;
				case PMR_PPM_POST_PROBE:
					format = "%s: PMR_PPM_POST_PROBE "
					    "%s@%s(%s#%d) rets %d\n";
					break;
				case PMR_PPM_PRE_RESUME:
					format = "%s: PMR_PPM_PRE_RESUME "
					    "%s@%s(%s#%d) rets %d\n";
					break;
				case PMR_PPM_INIT_CHILD:
					format = "%s: PMR_PPM_INIT_CHILD "
					    "%s@%s(%s#%d)\n";
					break;
				case PMR_PPM_UNINIT_CHILD:
					format = "%s: PMR_PPM_UNINIT_CHILD "
					    "%s@%s(%s#%d)\n";
					break;
				default:
					break;
			}
			PMD(PMD_PPM, (format, pmf, PM_DEVICE(rdip),
			    reqp->req.ppm_config_req.result))
#endif
			return (DDI_SUCCESS);

		case PMR_PPM_POWER_CHANGE_NOTIFY:
			/*
			 * Nothing for us to do
			 */
			ASSERT(reqp->req.ppm_notify_level_req.who == rdip);
			PMD(PMD_PPM, ("%s: PMR_PPM_POWER_CHANGE_NOTIFY "
			    "%s@%s(%s#%d)[%d] %d->%d\n", pmf,
			    PM_DEVICE(reqp->req.ppm_notify_level_req.who),
			    reqp->req.ppm_notify_level_req.cmpt,
			    PM_CURPOWER(reqp->req.ppm_notify_level_req.who,
			    reqp->req.ppm_notify_level_req.cmpt),
			    reqp->req.ppm_notify_level_req.new_level))
			return (DDI_SUCCESS);

		case PMR_PPM_UNMANAGE:
			PMD(PMD_PPM, ("%s: PMR_PPM_UNMANAGE %s@%s(%s#%d)\n",
			    pmf, PM_DEVICE(rdip)))
			return (DDI_SUCCESS);

		case PMR_PPM_LOCK_POWER:
			pm_lock_power_single(reqp->req.ppm_lock_power_req.who,
			    reqp->req.ppm_lock_power_req.circp);
			return (DDI_SUCCESS);

		case PMR_PPM_UNLOCK_POWER:
			pm_unlock_power_single(
			    reqp->req.ppm_unlock_power_req.who,
			    reqp->req.ppm_unlock_power_req.circ);
			return (DDI_SUCCESS);

		case PMR_PPM_TRY_LOCK_POWER:
			*(int *)result = pm_try_locking_power_single(
			    reqp->req.ppm_lock_power_req.who,
			    reqp->req.ppm_lock_power_req.circp);
			return (DDI_SUCCESS);

		case PMR_PPM_POWER_LOCK_OWNER:
			target_dip = reqp->req.ppm_power_lock_owner_req.who;
			ASSERT(target_dip == rdip);
			reqp->req.ppm_power_lock_owner_req.owner =
			    DEVI(rdip)->devi_busy_thread;
			return (DDI_SUCCESS);
		default:
			PMD(PMD_ERROR, ("%s: default!\n", pmf))
			return (DDI_FAILURE);
		}

	default:
		PMD(PMD_ERROR, ("%s: unknown\n", pmf))
		return (DDI_FAILURE);
	}
}

/*
 * We overload the bus_ctl ops here--perhaps we ought to have a distinct
 * power_ops struct for this functionality instead?
 * However, we only ever do this on a ppm driver.
 */
int
pm_ctlops(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t op, void *a, void *v)
{
	int (*fp)();

	/* if no ppm handler, call the default routine */
	if (d == NULL) {
		return (pm_default_ctlops(d, r, op, a, v));
	}
	if (!d || !r)
		return (DDI_FAILURE);
	ASSERT(DEVI(d)->devi_ops && DEVI(d)->devi_ops->devo_bus_ops &&
	    DEVI(d)->devi_ops->devo_bus_ops->bus_ctl);

	fp = DEVI(d)->devi_ops->devo_bus_ops->bus_ctl;
	return ((*fp)(d, r, op, a, v));
}

/*
 * Called on a node when attach completes or the driver makes its first pm
 * call (whichever comes first).
 * In the attach case, device may not be power manageable at all.
 * Don't need to lock the dip because we're single threaded by the devfs code
 */
static int
pm_start(dev_info_t *dip)
{
	PMD_FUNC(pmf, "start")
	int ret;
	dev_info_t *pdip = ddi_get_parent(dip);
	int e_pm_manage(dev_info_t *, int);
	void pm_noinvol_specd(dev_info_t *dip);

	e_pm_props(dip);
	pm_noinvol_specd(dip);
	/*
	 * If this dip has already been processed, don't mess with it
	 * (but decrement the speculative count we did above, as whatever
	 * code put it under pm already will have dealt with it)
	 */
	if (PM_GET_PM_INFO(dip)) {
		PMD(PMD_KIDSUP, ("%s: pm already done for %s@%s(%s#%d)\n",
		    pmf, PM_DEVICE(dip)))
		return (0);
	}
	ret = e_pm_manage(dip, PM_STYLE_UNKNOWN);

	if (PM_GET_PM_INFO(dip) == NULL) {
		/*
		 * keep the kidsupcount increment as is
		 */
		DEVI(dip)->devi_pm_flags |= PMC_NOPMKID;
		if (pdip && !PM_WANTS_NOTIFICATION(pdip)) {
			pm_hold_power(pdip);
		} else if (pdip && MDI_VHCI(pdip) && MDI_CLIENT(dip)) {
			(void) mdi_power(pdip, MDI_PM_HOLD_POWER,
			    (void *)dip, NULL, 0);
		}

		PMD(PMD_KIDSUP, ("%s: pm of %s@%s(%s#%d) failed, parent "
		    "left up\n", pmf, PM_DEVICE(dip)))
	}

	return (ret);
}

/*
 * Keep a list of recorded thresholds.  For now we just keep a list and
 * search it linearly.  We don't expect too many entries.  Can always hash it
 * later if we need to.
 */
void
pm_record_thresh(pm_thresh_rec_t *rp)
{
	pm_thresh_rec_t *pptr, *ptr;

	ASSERT(*rp->ptr_physpath);
	rw_enter(&pm_thresh_rwlock, RW_WRITER);
	for (pptr = NULL, ptr = pm_thresh_head;
	    ptr; pptr = ptr,  ptr = ptr->ptr_next) {
		if (strcmp(rp->ptr_physpath, ptr->ptr_physpath) == 0) {
			/* replace this one */
			rp->ptr_next = ptr->ptr_next;
			if (pptr) {
				pptr->ptr_next = rp;
			} else {
				pm_thresh_head = rp;
			}
			rw_exit(&pm_thresh_rwlock);
			kmem_free(ptr, ptr->ptr_size);
			return;
		}
		continue;
	}
	/*
	 * There was not a match in the list, insert this one in front
	 */
	if (pm_thresh_head) {
		rp->ptr_next = pm_thresh_head;
		pm_thresh_head = rp;
	} else {
		rp->ptr_next = NULL;
		pm_thresh_head = rp;
	}
	rw_exit(&pm_thresh_rwlock);
}

/*
 * Create a new dependency record and hang a new dependency entry off of it
 */
pm_pdr_t *
newpdr(char *kept, char *keeps, int isprop)
{
	size_t size = strlen(kept) + strlen(keeps) + 2 + sizeof (pm_pdr_t);
	pm_pdr_t *p = kmem_zalloc(size, KM_SLEEP);
	p->pdr_size = size;
	p->pdr_isprop = isprop;
	p->pdr_kept_paths = NULL;
	p->pdr_kept_count = 0;
	p->pdr_kept = (char *)((intptr_t)p + sizeof (pm_pdr_t));
	(void) strcpy(p->pdr_kept, kept);
	p->pdr_keeper = (char *)((intptr_t)p->pdr_kept + strlen(kept) + 1);
	(void) strcpy(p->pdr_keeper, keeps);
	ASSERT((intptr_t)p->pdr_keeper + strlen(p->pdr_keeper) + 1 <=
	    (intptr_t)p + size);
	ASSERT((intptr_t)p->pdr_kept + strlen(p->pdr_kept) + 1 <=
	    (intptr_t)p + size);
	return (p);
}

/*
 * Keep a list of recorded dependencies.  We only keep the
 * keeper -> kept list for simplification. At this point We do not
 * care about whether the devices are attached or not yet,
 * this would be done in pm_keeper() and pm_kept().
 * If a PM_RESET_PM happens, then we tear down and forget the dependencies,
 * and it is up to the user to issue the ioctl again if they want it
 * (e.g. pmconfig)
 * Returns true if dependency already exists in the list.
 */
int
pm_record_keeper(char *kept, char *keeper, int isprop)
{
	PMD_FUNC(pmf, "record_keeper")
	pm_pdr_t *npdr, *ppdr, *pdr;

	PMD(PMD_KEEPS, ("%s: %s, %s\n", pmf, kept, keeper))
	ASSERT(kept && keeper);
#ifdef DEBUG
	if (pm_debug & PMD_KEEPS)
		prdeps("pm_record_keeper entry");
#endif
	for (ppdr = NULL, pdr = pm_dep_head; pdr;
	    ppdr = pdr, pdr = pdr->pdr_next) {
		PMD(PMD_KEEPS, ("%s: check %s, %s\n", pmf, pdr->pdr_kept,
		    pdr->pdr_keeper))
		if (strcmp(kept, pdr->pdr_kept) == 0 &&
		    strcmp(keeper, pdr->pdr_keeper) == 0) {
			PMD(PMD_KEEPS, ("%s: match\n", pmf))
			return (1);
		}
	}
	/*
	 * We did not find any match, so we have to make an entry
	 */
	npdr = newpdr(kept, keeper, isprop);
	if (ppdr) {
		ASSERT(ppdr->pdr_next == NULL);
		ppdr->pdr_next = npdr;
	} else {
		ASSERT(pm_dep_head == NULL);
		pm_dep_head = npdr;
	}
#ifdef DEBUG
	if (pm_debug & PMD_KEEPS)
		prdeps("pm_record_keeper after new record");
#endif
	if (!isprop)
		pm_unresolved_deps++;
	else
		pm_prop_deps++;
	return (0);
}

/*
 * Look up this device in the set of devices we've seen ioctls for
 * to see if we are holding a threshold spec for it.  If so, make it so.
 * At ioctl time, we were given the physical path of the device.
 */
int
pm_thresh_specd(dev_info_t *dip)
{
	void pm_apply_recorded_thresh(dev_info_t *, pm_thresh_rec_t *);
	char *path = 0;
	char pathbuf[MAXNAMELEN];
	pm_thresh_rec_t *rp;

	path = ddi_pathname(dip, pathbuf);

	rw_enter(&pm_thresh_rwlock, RW_READER);
	for (rp = pm_thresh_head; rp; rp = rp->ptr_next) {
		if (strcmp(rp->ptr_physpath, path) != 0)
			continue;
		pm_apply_recorded_thresh(dip, rp);
		rw_exit(&pm_thresh_rwlock);
		return (1);
	}
	rw_exit(&pm_thresh_rwlock);
	return (0);
}

static int
pm_set_keeping(dev_info_t *keeper, dev_info_t *kept)
{
	PMD_FUNC(pmf, "set_keeping")
	pm_info_t *kept_info;
	int j, up = 0, circ;
	void prdeps(char *);

	PMD(PMD_KEEPS, ("%s: keeper=%s@%s(%s#%d), kept=%s@%s(%s#%d)\n", pmf,
	    PM_DEVICE(keeper), PM_DEVICE(kept)))
#ifdef DEBUG
	if (pm_debug & PMD_KEEPS)
		prdeps("Before PAD\n");
#endif
	ASSERT(keeper != kept);
	if (PM_GET_PM_INFO(keeper) == NULL) {
		cmn_err(CE_CONT, "!device %s@%s(%s#%d) keeps up device "
		    "%s@%s(%s#%d), but the latter is not power managed",
		    PM_DEVICE(keeper), PM_DEVICE(kept));
		PMD((PMD_FAIL | PMD_KEEPS), ("%s: keeper %s@%s(%s#%d) is not"
		    "power managed\n", pmf, PM_DEVICE(keeper)))
		return (0);
	}
	kept_info = PM_GET_PM_INFO(kept);
	ASSERT(kept_info);
	PM_LOCK_POWER(keeper, &circ);
	for (j = 0; j < PM_NUMCMPTS(keeper); j++) {
		if (PM_CURPOWER(keeper, j)) {
			up++;
			break;
		}
	}
	if (up) {
		/* Bringup and maintain a hold on the kept */
		PMD(PMD_KEEPS, ("%s: place a hold on kept %s@%s(%s#%d)\n", pmf,
		    PM_DEVICE(kept)))
		bring_pmdep_up(kept, 1);
	}
	PM_UNLOCK_POWER(keeper, circ);
#ifdef DEBUG
	if (pm_debug & PMD_KEEPS)
		prdeps("After PAD\n");
#endif
	return (1);
}

/*
 * Should this device keep up another device?
 * Look up this device in the set of devices we've seen ioctls for
 * to see if we are holding a dependency spec for it.  If so, make it so.
 * Because we require the kept device to be attached already in order to
 * make the list entry (and hold it), we only need to look for keepers.
 * At ioctl time, we were given the physical path of the device.
 */
int
pm_keeper(char *keeper)
{
	PMD_FUNC(pmf, "keeper")
	int pm_apply_recorded_dep(dev_info_t *, pm_pdr_t *);
	dev_info_t *dip;
	pm_pdr_t *dp;
	dev_info_t *kept = NULL;
	int ret = 0;
	int i;

	if (!pm_unresolved_deps && !pm_prop_deps)
		return (0);
	ASSERT(keeper != NULL);
	dip = pm_name_to_dip(keeper, 1);
	if (dip == NULL)
		return (0);
	PMD(PMD_KEEPS, ("%s: keeper=%s\n", pmf, keeper))
	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (!dp->pdr_isprop) {
			if (!pm_unresolved_deps)
				continue;
			PMD(PMD_KEEPS, ("%s: keeper %s\n", pmf, dp->pdr_keeper))
			if (dp->pdr_satisfied) {
				PMD(PMD_KEEPS, ("%s: satisfied\n", pmf))
				continue;
			}
			if (strcmp(dp->pdr_keeper, keeper) == 0) {
				ret += pm_apply_recorded_dep(dip, dp);
			}
		} else {
			if (strcmp(dp->pdr_keeper, keeper) != 0)
				continue;
			for (i = 0; i < dp->pdr_kept_count; i++) {
				if (dp->pdr_kept_paths[i] == NULL)
					continue;
				kept = pm_name_to_dip(dp->pdr_kept_paths[i], 1);
				if (kept == NULL)
					continue;
				ASSERT(ddi_prop_exists(DDI_DEV_T_ANY, kept,
				    DDI_PROP_DONTPASS, dp->pdr_kept));
				PMD(PMD_KEEPS, ("%s: keeper=%s@%s(%s#%d), "
				    "kept=%s@%s(%s#%d) keptcnt=%d\n",
				    pmf, PM_DEVICE(dip), PM_DEVICE(kept),
				    dp->pdr_kept_count))
				if (kept != dip) {
					ret += pm_set_keeping(dip, kept);
				}
				ddi_release_devi(kept);
			}

		}
	}
	ddi_release_devi(dip);
	return (ret);
}

/*
 * Should this device be kept up by another device?
 * Look up all dependency recorded from PM_ADD_DEPENDENT and
 * PM_ADD_DEPENDENT_PROPERTY ioctls. Record down on the keeper's
 * kept device lists.
 */
static int
pm_kept(char *keptp)
{
	PMD_FUNC(pmf, "kept")
	pm_pdr_t *dp;
	int found = 0;
	int ret = 0;
	dev_info_t *keeper;
	dev_info_t *kept;
	size_t length;
	int i;
	char **paths;
	char *path;

	ASSERT(keptp != NULL);
	kept = pm_name_to_dip(keptp, 1);
	if (kept == NULL)
		return (0);
	PMD(PMD_KEEPS, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(kept)))
	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (dp->pdr_isprop) {
			PMD(PMD_KEEPS, ("%s: property %s\n", pmf, dp->pdr_kept))
			if (ddi_prop_exists(DDI_DEV_T_ANY, kept,
			    DDI_PROP_DONTPASS, dp->pdr_kept)) {
				/*
				 * Dont allow self dependency.
				 */
				if (strcmp(dp->pdr_keeper, keptp) == 0)
					continue;
				keeper = pm_name_to_dip(dp->pdr_keeper, 1);
				if (keeper == NULL)
					continue;
				PMD(PMD_KEEPS, ("%s: adding to kepts path list "
				    "%p\n", pmf, (void *)kept))
#ifdef DEBUG
				if (pm_debug & PMD_DEP)
					prdeps("Before Adding from pm_kept\n");
#endif
				/*
				 * Add ourselves to the dip list.
				 */
				if (dp->pdr_kept_count == 0) {
					length = strlen(keptp) + 1;
					path =
					    kmem_alloc(length, KM_SLEEP);
					paths = kmem_alloc(sizeof (char **),
					    KM_SLEEP);
					(void) strcpy(path, keptp);
					paths[0] = path;
					dp->pdr_kept_paths = paths;
					dp->pdr_kept_count++;
				} else {
					/* Check to see if already on list */
					for (i = 0; i < dp->pdr_kept_count;
					    i++) {
						if (strcmp(keptp,
						    dp->pdr_kept_paths[i])
						    == 0) {
							found++;
							break;
						}
					}
					if (found) {
						ddi_release_devi(keeper);
						continue;
					}
					length = dp->pdr_kept_count *
					    sizeof (char **);
					paths = kmem_alloc(
					    length + sizeof (char **),
					    KM_SLEEP);
					if (dp->pdr_kept_count) {
						bcopy(dp->pdr_kept_paths,
						    paths, length);
						kmem_free(dp->pdr_kept_paths,
						    length);
					}
					dp->pdr_kept_paths = paths;
					length = strlen(keptp) + 1;
					path =
					    kmem_alloc(length, KM_SLEEP);
					(void) strcpy(path, keptp);
					dp->pdr_kept_paths[i] = path;
					dp->pdr_kept_count++;
				}
#ifdef DEBUG
				if (pm_debug & PMD_DEP)
					prdeps("After from pm_kept\n");
#endif
				if (keeper) {
					ret += pm_set_keeping(keeper, kept);
					ddi_release_devi(keeper);
				}
			}
		} else {
			/*
			 * pm_keeper would be called later to do
			 * the actual pm_set_keeping.
			 */
			PMD(PMD_KEEPS, ("%s: adding to kepts path list %p\n",
			    pmf, (void *)kept))
#ifdef DEBUG
			if (pm_debug & PMD_DEP)
				prdeps("Before Adding from pm_kept\n");
#endif
			if (strcmp(keptp, dp->pdr_kept) == 0) {
				if (dp->pdr_kept_paths == NULL) {
					length = strlen(keptp) + 1;
					path =
					    kmem_alloc(length, KM_SLEEP);
					paths = kmem_alloc(sizeof (char **),
					    KM_SLEEP);
					(void) strcpy(path, keptp);
					paths[0] = path;
					dp->pdr_kept_paths = paths;
					dp->pdr_kept_count++;
				}
			}
#ifdef DEBUG
			if (pm_debug & PMD_DEP)
				prdeps("After from pm_kept\n");
#endif
		}
	}
	ddi_release_devi(kept);
	return (ret);
}

/*
 * Apply a recorded dependency.  dp specifies the dependency, and
 * keeper is already known to be the device that keeps up the other (kept) one.
 * We have to the whole tree for the "kept" device, then apply
 * the dependency (which may already be applied).
 */
int
pm_apply_recorded_dep(dev_info_t *keeper, pm_pdr_t *dp)
{
	PMD_FUNC(pmf, "apply_recorded_dep")
	dev_info_t *kept = NULL;
	int ret = 0;
	char *keptp = NULL;

	/*
	 * Device to Device dependency can only be 1 to 1.
	 */
	if (dp->pdr_kept_paths == NULL)
		return (0);
	keptp = dp->pdr_kept_paths[0];
	if (keptp == NULL)
		return (0);
	ASSERT(*keptp != '\0');
	kept = pm_name_to_dip(keptp, 1);
	if (kept == NULL)
		return (0);
	if (kept) {
		PMD(PMD_KEEPS, ("%s: keeper=%s, kept=%s\n", pmf,
		    dp->pdr_keeper, keptp))
		if (pm_set_keeping(keeper, kept)) {
			ASSERT(dp->pdr_satisfied == 0);
			dp->pdr_satisfied = 1;
			ASSERT(pm_unresolved_deps);
			pm_unresolved_deps--;
			ret++;
		}
	}
	ddi_release_devi(kept);

	return (ret);
}

/*
 * Called from common/io/pm.c
 */
int
pm_cur_power(pm_component_t *cp)
{
	return (cur_power(cp));
}

/*
 * External interface to sanity-check a power level.
 */
int
pm_valid_power(dev_info_t *dip, int comp, int level)
{
	PMD_FUNC(pmf, "valid_power")

	if (comp >= 0 && comp < PM_NUMCMPTS(dip) && level >= 0)
		return (e_pm_valid_power(dip, comp, level));
	else {
		PMD(PMD_FAIL, ("%s: comp=%d, ncomp=%d, level=%d\n",
		    pmf, comp, PM_NUMCMPTS(dip), level))
		return (0);
	}
}

/*
 * Called when a device that is direct power managed needs to change state.
 * This routine arranges to block the request until the process managing
 * the device makes the change (or some other incompatible change) or
 * the process closes /dev/pm.
 */
static int
pm_block(dev_info_t *dip, int comp, int newpower, int oldpower)
{
	pm_rsvp_t *new = kmem_zalloc(sizeof (*new), KM_SLEEP);
	int ret = 0;
	void pm_dequeue_blocked(pm_rsvp_t *);
	void pm_enqueue_blocked(pm_rsvp_t *);

	ASSERT(!pm_processes_stopped);
	ASSERT(PM_IAM_LOCKING_DIP(dip));
	new->pr_dip = dip;
	new->pr_comp = comp;
	new->pr_newlevel = newpower;
	new->pr_oldlevel = oldpower;
	cv_init(&new->pr_cv, NULL, CV_DEFAULT, NULL);
	mutex_enter(&pm_rsvp_lock);
	pm_enqueue_blocked(new);
	pm_enqueue_notify(PSC_PENDING_CHANGE, dip, comp, newpower, oldpower,
	    PM_CANBLOCK_BLOCK);
	PM_UNLOCK_DIP(dip);
	/*
	 * truss may make the cv_wait_sig return prematurely
	 */
	while (ret == 0) {
		/*
		 * Normally there will be no user context involved, but if
		 * there is (e.g. we are here via an ioctl call to a driver)
		 * then we should allow the process to abort the request,
		 * or we get an unkillable process if the same thread does
		 * PM_DIRECT_PM and pm_raise_power
		 */
		if (cv_wait_sig(&new->pr_cv, &pm_rsvp_lock) == 0) {
			ret = PMP_FAIL;
		} else {
			ret = new->pr_retval;
		}
	}
	pm_dequeue_blocked(new);
	mutex_exit(&pm_rsvp_lock);
	cv_destroy(&new->pr_cv);
	kmem_free(new, sizeof (*new));
	return (ret);
}

/*
 * Returns true if the process is interested in power level changes (has issued
 * PM_GET_STATE_CHANGE ioctl).
 */
int
pm_interest_registered(int clone)
{
	ASSERT(clone >= 0 && clone < PM_MAX_CLONE - 1);
	return (pm_interest[clone]);
}

/*
 * Process with clone has just done PM_DIRECT_PM on dip, or has asked to
 * watch all state transitions (dip == NULL).  Set up data
 * structs to communicate with process about state changes.
 */
void
pm_register_watcher(int clone, dev_info_t *dip)
{
	pscc_t	*p;
	psce_t	*psce;
	static void pm_enqueue_pscc(pscc_t *, pscc_t **);

	/*
	 * We definitely need a control struct, then we have to search to see
	 * there is already an entries struct (in the dip != NULL case).
	 */
	pscc_t	*pscc = kmem_zalloc(sizeof (*pscc), KM_SLEEP);
	pscc->pscc_clone = clone;
	pscc->pscc_dip = dip;

	if (dip) {
		int found = 0;
		rw_enter(&pm_pscc_direct_rwlock, RW_WRITER);
		for (p = pm_pscc_direct; p; p = p->pscc_next) {
			/*
			 * Already an entry for this clone, so just use it
			 * for the new one (for the case where a single
			 * process is watching multiple devices)
			 */
			if (p->pscc_clone == clone) {
				pscc->pscc_entries = p->pscc_entries;
				pscc->pscc_entries->psce_references++;
				found++;
				break;
			}
		}
		if (!found) {		/* create a new one */
			psce = kmem_zalloc(sizeof (psce_t), KM_SLEEP);
			mutex_init(&psce->psce_lock, NULL, MUTEX_DEFAULT, NULL);
			psce->psce_first =
			    kmem_zalloc(sizeof (pm_state_change_t) * PSCCOUNT,
			    KM_SLEEP);
			psce->psce_in = psce->psce_out = psce->psce_first;
			psce->psce_last = &psce->psce_first[PSCCOUNT - 1];
			psce->psce_references = 1;
			pscc->pscc_entries = psce;
		}
		pm_enqueue_pscc(pscc, &pm_pscc_direct);
		rw_exit(&pm_pscc_direct_rwlock);
	} else {
		ASSERT(!pm_interest_registered(clone));
		rw_enter(&pm_pscc_interest_rwlock, RW_WRITER);
#ifdef DEBUG
		for (p = pm_pscc_interest; p; p = p->pscc_next) {
			/*
			 * Should not be an entry for this clone!
			 */
			ASSERT(p->pscc_clone != clone);
		}
#endif
		psce = kmem_zalloc(sizeof (psce_t), KM_SLEEP);
		psce->psce_first = kmem_zalloc(sizeof (pm_state_change_t) *
		    PSCCOUNT, KM_SLEEP);
		psce->psce_in = psce->psce_out = psce->psce_first;
		psce->psce_last = &psce->psce_first[PSCCOUNT - 1];
		psce->psce_references = 1;
		pscc->pscc_entries = psce;
		pm_enqueue_pscc(pscc, &pm_pscc_interest);
		pm_interest[clone] = 1;
		rw_exit(&pm_pscc_interest_rwlock);
	}
}

/*
 * Remove the given entry from the blocked list
 */
void
pm_dequeue_blocked(pm_rsvp_t *p)
{
	ASSERT(MUTEX_HELD(&pm_rsvp_lock));
	if (pm_blocked_list == p) {
		ASSERT(p->pr_prev == NULL);
		if (p->pr_next != NULL)
			p->pr_next->pr_prev = NULL;
		pm_blocked_list = p->pr_next;
	} else {
		ASSERT(p->pr_prev != NULL);
		p->pr_prev->pr_next = p->pr_next;
		if (p->pr_next != NULL)
			p->pr_next->pr_prev = p->pr_prev;
	}
}

/*
 * Remove the given control struct from the given list
 */
static void
pm_dequeue_pscc(pscc_t *p, pscc_t **list)
{
	if (*list == p) {
		ASSERT(p->pscc_prev == NULL);
		if (p->pscc_next != NULL)
			p->pscc_next->pscc_prev = NULL;
		*list = p->pscc_next;
	} else {
		ASSERT(p->pscc_prev != NULL);
		p->pscc_prev->pscc_next = p->pscc_next;
		if (p->pscc_next != NULL)
			p->pscc_next->pscc_prev = p->pscc_prev;
	}
}

/*
 * Stick the control struct specified on the front of the list
 */
static void
pm_enqueue_pscc(pscc_t *p, pscc_t **list)
{
	pscc_t *h;	/* entry at head of list */
	if ((h = *list) == NULL) {
		*list = p;
		ASSERT(p->pscc_next == NULL);
		ASSERT(p->pscc_prev == NULL);
	} else {
		p->pscc_next = h;
		ASSERT(h->pscc_prev == NULL);
		h->pscc_prev = p;
		ASSERT(p->pscc_prev == NULL);
		*list = p;
	}
}

/*
 * If dip is NULL, process is closing "clone" clean up all its registrations.
 * Otherwise only clean up those for dip because process is just giving up
 * control of a direct device.
 */
void
pm_deregister_watcher(int clone, dev_info_t *dip)
{
	pscc_t	*p, *pn;
	psce_t	*psce;
	int found = 0;

	if (dip == NULL) {
		rw_enter(&pm_pscc_interest_rwlock, RW_WRITER);
		for (p = pm_pscc_interest; p; p = pn) {
			pn = p->pscc_next;
			if (p->pscc_clone == clone) {
				pm_dequeue_pscc(p, &pm_pscc_interest);
				psce = p->pscc_entries;
				ASSERT(psce->psce_references == 1);
				mutex_destroy(&psce->psce_lock);
				kmem_free(psce->psce_first,
				    sizeof (pm_state_change_t) * PSCCOUNT);
				kmem_free(psce, sizeof (*psce));
				kmem_free(p, sizeof (*p));
			}
		}
		pm_interest[clone] = 0;
		rw_exit(&pm_pscc_interest_rwlock);
	}
	found = 0;
	rw_enter(&pm_pscc_direct_rwlock, RW_WRITER);
	for (p = pm_pscc_direct; p; p = pn) {
		pn = p->pscc_next;
		if ((dip && p->pscc_dip == dip) ||
		    (dip == NULL && clone == p->pscc_clone)) {
			ASSERT(clone == p->pscc_clone);
			found++;
			/*
			 * Remove from control list
			 */
			pm_dequeue_pscc(p, &pm_pscc_direct);
			/*
			 * If we're the last reference, free the
			 * entries struct.
			 */
			psce = p->pscc_entries;
			ASSERT(psce);
			if (psce->psce_references == 1) {
				kmem_free(psce->psce_first,
				    PSCCOUNT * sizeof (pm_state_change_t));
				kmem_free(psce, sizeof (*psce));
			} else {
				psce->psce_references--;
			}
			kmem_free(p, sizeof (*p));
		}
	}
	ASSERT(dip == NULL || found);
	rw_exit(&pm_pscc_direct_rwlock);
}

/*
 * Search the indicated list for an entry that matches clone, and return a
 * pointer to it.  To be interesting, the entry must have something ready to
 * be passed up to the controlling process.
 * The returned entry will be locked upon return from this call.
 */
static psce_t *
pm_psc_find_clone(int clone, pscc_t **list, krwlock_t *lock)
{
	pscc_t	*p;
	psce_t	*psce;
	rw_enter(lock, RW_READER);
	for (p = *list; p; p = p->pscc_next) {
		if (clone == p->pscc_clone) {
			psce = p->pscc_entries;
			mutex_enter(&psce->psce_lock);
			if (psce->psce_out->size) {
				rw_exit(lock);
				return (psce);
			} else {
				mutex_exit(&psce->psce_lock);
			}
		}
	}
	rw_exit(lock);
	return (NULL);
}

/*
 * Find an entry for a particular clone in the direct list.
 */
psce_t *
pm_psc_clone_to_direct(int clone)
{
	static psce_t *pm_psc_find_clone(int, pscc_t **, krwlock_t *);
	return (pm_psc_find_clone(clone, &pm_pscc_direct,
	    &pm_pscc_direct_rwlock));
}

/*
 * Find an entry for a particular clone in the interest list.
 */
psce_t *
pm_psc_clone_to_interest(int clone)
{
	static psce_t *pm_psc_find_clone(int, pscc_t **, krwlock_t *);
	return (pm_psc_find_clone(clone, &pm_pscc_interest,
	    &pm_pscc_interest_rwlock));
}

/*
 * Put the given entry at the head of the blocked list
 */
void
pm_enqueue_blocked(pm_rsvp_t *p)
{
	ASSERT(MUTEX_HELD(&pm_rsvp_lock));
	ASSERT(p->pr_next == NULL);
	ASSERT(p->pr_prev == NULL);
	if (pm_blocked_list != NULL) {
		p->pr_next = pm_blocked_list;
		ASSERT(pm_blocked_list->pr_prev == NULL);
		pm_blocked_list->pr_prev = p;
		pm_blocked_list = p;
	} else {
		pm_blocked_list = p;
	}
}

/*
 * Sets every power managed device back to its default threshold
 */
void
pm_all_to_default_thresholds(void)
{
	ddi_walk_devs(ddi_root_node(), pm_set_dev_thr_walk,
	    (void *) &pm_system_idle_threshold);
}

static int
pm_set_dev_thr_walk(dev_info_t *dip, void *arg)
{
	int thr = (int)(*(int *)arg);

	if (!PM_GET_PM_INFO(dip))
		return (DDI_WALK_CONTINUE);
	pm_set_device_threshold(dip, thr, PMC_DEF_THRESH);
	return (DDI_WALK_CONTINUE);
}

/*
 * Returns the current threshold value (in seconds) for the indicated component
 */
int
pm_current_threshold(dev_info_t *dip, int comp, int *threshp)
{
	if (comp < 0 || comp >= PM_NUMCMPTS(dip)) {
		return (DDI_FAILURE);
	} else {
		*threshp = cur_threshold(dip, comp);
		return (DDI_SUCCESS);
	}
}

/*
 * To be called when changing the power level of a component of a device.
 * On some platforms, changing power on one device may require that power
 * be changed on other, related devices in the same transaction.  Thus, we
 * always pass this request to the platform power manager so that all the
 * affected devices will be locked.
 */
void
pm_lock_power(dev_info_t *dip, int *circp)
{
	power_req_t power_req;
	int result;

	power_req.request_type = PMR_PPM_LOCK_POWER;
	power_req.req.ppm_lock_power_req.who = dip;
	power_req.req.ppm_lock_power_req.circp = circp;
	(void) pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, &power_req, &result);
}

/*
 * Release the lock (or locks) acquired to change the power of a device.
 * See comments for pm_lock_power.
 */
void
pm_unlock_power(dev_info_t *dip, int circ)
{
	power_req_t power_req;
	int result;

	power_req.request_type = PMR_PPM_UNLOCK_POWER;
	power_req.req.ppm_unlock_power_req.who = dip;
	power_req.req.ppm_unlock_power_req.circ = circ;
	(void) pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, &power_req, &result);
}


/*
 * Attempt (without blocking) to acquire the lock(s) needed to change the
 * power of a component of a device.  See comments for pm_lock_power.
 *
 * Return: 1 if lock(s) acquired, 0 if not.
 */
int
pm_try_locking_power(dev_info_t *dip, int *circp)
{
	power_req_t power_req;
	int result;

	power_req.request_type = PMR_PPM_TRY_LOCK_POWER;
	power_req.req.ppm_lock_power_req.who = dip;
	power_req.req.ppm_lock_power_req.circp = circp;
	(void) pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, &power_req, &result);
	return (result);
}


/*
 * Lock power state of a device.
 *
 * The implementation handles a special case where another thread may have
 * acquired the lock and created/launched this thread to do the work.  If
 * the lock cannot be acquired immediately, we check to see if this thread
 * is registered as a borrower of the lock.  If so, we may proceed without
 * the lock.  This assumes that the lending thread blocks on the completion
 * of this thread.
 *
 * Note 1: for use by ppm only.
 *
 * Note 2: On failing to get the lock immediately, we search lock_loan list
 * for curthread (as borrower of the lock).  On a hit, we check that the
 * lending thread already owns the lock we want.  It is safe to compare
 * devi_busy_thread and thread id of the lender because in the == case (the
 * only one we care about) we know that the owner is blocked.  Similarly,
 * If we find that curthread isn't registered as a lock borrower, it is safe
 * to use the blocking call (ndi_devi_enter) because we know that if we
 * weren't already listed as a borrower (upstream on the call stack) we won't
 * become one.
 */
void
pm_lock_power_single(dev_info_t *dip, int *circp)
{
	lock_loan_t *cur;

	/* if the lock is available, we are done. */
	if (ndi_devi_tryenter(dip, circp))
		return;

	mutex_enter(&pm_loan_lock);
	/* see if our thread is registered as a lock borrower. */
	for (cur = lock_loan_head.pmlk_next; cur; cur = cur->pmlk_next)
		if (cur->pmlk_borrower == curthread)
			break;
	mutex_exit(&pm_loan_lock);

	/* if this thread not already registered, it is safe to block */
	if (cur == NULL)
		ndi_devi_enter(dip, circp);
	else {
		/* registered: does lender own the lock we want? */
		if (cur->pmlk_lender == DEVI(dip)->devi_busy_thread) {
			ASSERT(cur->pmlk_dip == NULL || cur->pmlk_dip == dip);
			cur->pmlk_dip = dip;
		} else /* no: just block for it */
			ndi_devi_enter(dip, circp);

	}
}

/*
 * Drop the lock on the device's power state.  See comment for
 * pm_lock_power_single() for special implementation considerations.
 *
 * Note: for use by ppm only.
 */
void
pm_unlock_power_single(dev_info_t *dip, int circ)
{
	lock_loan_t *cur;

	/* optimization: mutex not needed to check empty list */
	if (lock_loan_head.pmlk_next == NULL) {
		ndi_devi_exit(dip, circ);
		return;
	}

	mutex_enter(&pm_loan_lock);
	/* see if our thread is registered as a lock borrower. */
	for (cur = lock_loan_head.pmlk_next; cur; cur = cur->pmlk_next)
		if (cur->pmlk_borrower == curthread)
			break;
	mutex_exit(&pm_loan_lock);

	if (cur == NULL || cur->pmlk_dip != dip)
		/* we acquired the lock directly, so return it */
		ndi_devi_exit(dip, circ);
}

/*
 * Try to take the lock for changing the power level of a component.
 *
 * Note: for use by ppm only.
 */
int
pm_try_locking_power_single(dev_info_t *dip, int *circp)
{
	return (ndi_devi_tryenter(dip, circp));
}

#ifdef	DEBUG
/*
 * The following are used only to print out data structures for debugging
 */
void
prdeps(char *msg)
{

	pm_pdr_t *rp;
	int i;

	pm_log("pm_dep_head %s %p\n", msg, (void *)pm_dep_head);
	for (rp = pm_dep_head; rp; rp = rp->pdr_next) {
		pm_log("%p: %s keeper %s, kept %s, kept count %d, next %p\n",
		    (void *)rp, (rp->pdr_isprop ? "property" : "device"),
		    rp->pdr_keeper, rp->pdr_kept, rp->pdr_kept_count,
		    (void *)rp->pdr_next);
		if (rp->pdr_kept_count != 0) {
			pm_log("kept list = ");
			i = 0;
			while (i < rp->pdr_kept_count) {
				pm_log("%s ", rp->pdr_kept_paths[i]);
				i++;
			}
			pm_log("\n");
		}
	}
}

void
pr_noinvol(char *hdr)
{
	pm_noinvol_t *ip;

	pm_log("%s\n", hdr);
	rw_enter(&pm_noinvol_rwlock, RW_READER);
	for (ip = pm_noinvol_head; ip; ip = ip->ni_next)
		pm_log("\tmaj %d, flags %x, noinvolpm %d %s\n",
		    ip->ni_major, ip->ni_flags, ip->ni_noinvolpm, ip->ni_path);
	rw_exit(&pm_noinvol_rwlock);
}
#endif

/*
 * Attempt to apply the thresholds indicated by rp to the node specified by
 * dip.
 */
void
pm_apply_recorded_thresh(dev_info_t *dip, pm_thresh_rec_t *rp)
{
	PMD_FUNC(pmf, "apply_recorded_thresh")
	int i, j;
	int comps = PM_NUMCMPTS(dip);
	struct pm_component *cp;
	pm_pte_t *ep;
	int pm_valid_thresh(dev_info_t *, pm_thresh_rec_t *);

	PMD(PMD_THRESH, ("%s: part: %s@%s(%s#%d), rp %p, %s\n", pmf,
	    PM_DEVICE(dip), (void *)rp, rp->ptr_physpath))
	PM_LOCK_DIP(dip);
	if (!PM_GET_PM_INFO(dip) || PM_ISBC(dip) || !pm_valid_thresh(dip, rp)) {
		PMD(PMD_FAIL, ("%s: part: %s@%s(%s#%d) PM_GET_PM_INFO %p\n",
		    pmf, PM_DEVICE(dip), (void*)PM_GET_PM_INFO(dip)))
		PMD(PMD_FAIL, ("%s: part: %s@%s(%s#%d) PM_ISBC %d\n",
		    pmf, PM_DEVICE(dip), PM_ISBC(dip)))
		PMD(PMD_FAIL, ("%s: part: %s@%s(%s#%d) pm_valid_thresh %d\n",
		    pmf, PM_DEVICE(dip), pm_valid_thresh(dip, rp)))
		PM_UNLOCK_DIP(dip);
		return;
	}

	ep = rp->ptr_entries;
	/*
	 * Here we do the special case of a device threshold
	 */
	if (rp->ptr_numcomps == 0) {	/* PM_SET_DEVICE_THRESHOLD product */
		ASSERT(ep && ep->pte_numthresh == 1);
		PMD(PMD_THRESH, ("%s: set dev thr %s@%s(%s#%d) to 0x%x\n",
		    pmf, PM_DEVICE(dip), ep->pte_thresh[0]))
		PM_UNLOCK_DIP(dip);
		pm_set_device_threshold(dip, ep->pte_thresh[0], PMC_DEV_THRESH);
		if (PM_SCANABLE(dip))
			pm_rescan(dip);
		return;
	}
	for (i = 0; i < comps; i++) {
		cp = PM_CP(dip, i);
		for (j = 0; j < ep->pte_numthresh; j++) {
			PMD(PMD_THRESH, ("%s: set thr %d for %s@%s(%s#%d)[%d] "
			    "to %x\n", pmf, j, PM_DEVICE(dip),
			    i, ep->pte_thresh[j]))
			cp->pmc_comp.pmc_thresh[j + 1] = ep->pte_thresh[j];
		}
		ep++;
	}
	DEVI(dip)->devi_pm_flags &= PMC_THRESH_NONE;
	DEVI(dip)->devi_pm_flags |= PMC_COMP_THRESH;
	PM_UNLOCK_DIP(dip);

	if (PM_SCANABLE(dip))
		pm_rescan(dip);
}

/*
 * Returns true if the threshold specified by rp could be applied to dip
 * (that is, the number of components and transitions are the same)
 */
int
pm_valid_thresh(dev_info_t *dip, pm_thresh_rec_t *rp)
{
	PMD_FUNC(pmf, "valid_thresh")
	int comps, i;
	pm_component_t *cp;
	pm_pte_t *ep;

	if (!PM_GET_PM_INFO(dip) || PM_ISBC(dip)) {
		PMD(PMD_ERROR, ("%s: %s: no pm_info or BC\n", pmf,
		    rp->ptr_physpath))
		return (0);
	}
	/*
	 * Special case: we represent the PM_SET_DEVICE_THRESHOLD case by
	 * an entry with numcomps == 0, (since we don't know how many
	 * components there are in advance).  This is always a valid
	 * spec.
	 */
	if (rp->ptr_numcomps == 0) {
		ASSERT(rp->ptr_entries && rp->ptr_entries->pte_numthresh == 1);
		return (1);
	}
	if (rp->ptr_numcomps != (comps = PM_NUMCMPTS(dip))) {
		PMD(PMD_ERROR, ("%s: comp # mm (dip %d cmd %d) for %s\n",
		    pmf, PM_NUMCMPTS(dip), rp->ptr_numcomps, rp->ptr_physpath))
		return (0);
	}
	ep = rp->ptr_entries;
	for (i = 0; i < comps; i++) {
		cp = PM_CP(dip, i);
		if ((ep + i)->pte_numthresh !=
		    cp->pmc_comp.pmc_numlevels - 1) {
			PMD(PMD_ERROR, ("%s: %s[%d]: thresh=%d, record=%d\n",
			    pmf, rp->ptr_physpath, i,
			    cp->pmc_comp.pmc_numlevels - 1,
			    (ep + i)->pte_numthresh))
			return (0);
		}
	}
	return (1);
}

/*
 * Remove any recorded threshold for device physpath
 * We know there will be at most one.
 */
void
pm_unrecord_threshold(char *physpath)
{
	pm_thresh_rec_t *pptr, *ptr;

	rw_enter(&pm_thresh_rwlock, RW_WRITER);
	for (pptr = NULL, ptr = pm_thresh_head; ptr; ptr = ptr->ptr_next) {
		if (strcmp(physpath, ptr->ptr_physpath) == 0) {
			if (pptr) {
				pptr->ptr_next = ptr->ptr_next;
			} else {
				ASSERT(pm_thresh_head == ptr);
				pm_thresh_head = ptr->ptr_next;
			}
			kmem_free(ptr, ptr->ptr_size);
			break;
		}
		pptr = ptr;
	}
	rw_exit(&pm_thresh_rwlock);
}

/*
 * Discard all recorded thresholds.  We are returning to the default pm state.
 */
void
pm_discard_thresholds(void)
{
	pm_thresh_rec_t *rp;
	rw_enter(&pm_thresh_rwlock, RW_WRITER);
	while (pm_thresh_head) {
		rp = pm_thresh_head;
		pm_thresh_head = rp->ptr_next;
		kmem_free(rp, rp->ptr_size);
	}
	rw_exit(&pm_thresh_rwlock);
}

/*
 * Discard all recorded dependencies.  We are returning to the default pm state.
 */
void
pm_discard_dependencies(void)
{
	pm_pdr_t *rp;
	int i;
	size_t length;

#ifdef DEBUG
	if (pm_debug & PMD_DEP)
		prdeps("Before discard\n");
#endif
	ddi_walk_devs(ddi_root_node(), pm_discard_dep_walk, NULL);

#ifdef DEBUG
	if (pm_debug & PMD_DEP)
		prdeps("After discard\n");
#endif
	while (pm_dep_head) {
		rp = pm_dep_head;
		if (!rp->pdr_isprop) {
			ASSERT(rp->pdr_satisfied == 0);
			ASSERT(pm_unresolved_deps);
			pm_unresolved_deps--;
		} else {
			ASSERT(pm_prop_deps);
			pm_prop_deps--;
		}
		pm_dep_head = rp->pdr_next;
		if (rp->pdr_kept_count)  {
			for (i = 0; i < rp->pdr_kept_count; i++) {
				length = strlen(rp->pdr_kept_paths[i]) + 1;
				kmem_free(rp->pdr_kept_paths[i], length);
			}
			kmem_free(rp->pdr_kept_paths,
			    rp->pdr_kept_count * sizeof (char **));
		}
		kmem_free(rp, rp->pdr_size);
	}
}


static int
pm_discard_dep_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))
	char *pathbuf;

	if (PM_GET_PM_INFO(dip) == NULL)
		return (DDI_WALK_CONTINUE);
	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	pm_free_keeper(pathbuf, 0);
	kmem_free(pathbuf, MAXPATHLEN);
	return (DDI_WALK_CONTINUE);
}

static int
pm_kept_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))
	char *pathbuf;

	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	(void) pm_kept(pathbuf);
	kmem_free(pathbuf, MAXPATHLEN);

	return (DDI_WALK_CONTINUE);
}

static int
pm_keeper_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))
	char *pathbuf;

	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);
	(void) pm_keeper(pathbuf);
	kmem_free(pathbuf, MAXPATHLEN);

	return (DDI_WALK_CONTINUE);
}

static char *
pdw_type_decode(int type)
{
	switch (type) {
	case PM_DEP_WK_POWER_ON:
		return ("power on");
	case PM_DEP_WK_POWER_OFF:
		return ("power off");
	case PM_DEP_WK_DETACH:
		return ("detach");
	case PM_DEP_WK_REMOVE_DEP:
		return ("remove dep");
	case PM_DEP_WK_BRINGUP_SELF:
		return ("bringup self");
	case PM_DEP_WK_RECORD_KEEPER:
		return ("add dependent");
	case PM_DEP_WK_RECORD_KEEPER_PROP:
		return ("add dependent property");
	case PM_DEP_WK_KEPT:
		return ("kept");
	case PM_DEP_WK_KEEPER:
		return ("keeper");
	case PM_DEP_WK_ATTACH:
		return ("attach");
	case PM_DEP_WK_CHECK_KEPT:
		return ("check kept");
	case PM_DEP_WK_CPR_SUSPEND:
		return ("suspend");
	case PM_DEP_WK_CPR_RESUME:
		return ("resume");
	default:
		return ("unknown");
	}

}

static void
pm_rele_dep(char *keeper)
{
	PMD_FUNC(pmf, "rele_dep")
	pm_pdr_t *dp;
	char *kept_path = NULL;
	dev_info_t *kept = NULL;
	int count = 0;

	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (strcmp(dp->pdr_keeper, keeper) != 0)
			continue;
		for (count = 0; count < dp->pdr_kept_count; count++) {
			kept_path = dp->pdr_kept_paths[count];
			if (kept_path == NULL)
				continue;
			kept = pm_name_to_dip(kept_path, 1);
			if (kept) {
				PMD(PMD_KEEPS, ("%s: release kept=%s@%s(%s#%d) "
				    "of keeper=%s\n", pmf, PM_DEVICE(kept),
				    keeper))
				ASSERT(DEVI(kept)->devi_pm_kidsupcnt > 0);
				pm_rele_power(kept);
				ddi_release_devi(kept);
			}
		}
	}
}

/*
 * Called when we are just released from direct PM.  Bring ourself up
 * if our keeper is up since dependency is not honored while a kept
 * device is under direct PM.
 */
static void
pm_bring_self_up(char *keptpath)
{
	PMD_FUNC(pmf, "bring_self_up")
	dev_info_t *kept;
	dev_info_t *keeper;
	pm_pdr_t *dp;
	int i, j;
	int up = 0, circ;

	kept = pm_name_to_dip(keptpath, 1);
	if (kept == NULL)
		return;
	PMD(PMD_KEEPS, ("%s: kept=%s@%s(%s#%d)\n", pmf, PM_DEVICE(kept)))
	for (dp = pm_dep_head; dp; dp = dp->pdr_next) {
		if (dp->pdr_kept_count == 0)
			continue;
		for (i = 0; i < dp->pdr_kept_count; i++) {
			if (strcmp(dp->pdr_kept_paths[i], keptpath) != 0)
				continue;
			keeper = pm_name_to_dip(dp->pdr_keeper, 1);
			if (keeper) {
				PMD(PMD_KEEPS, ("%s: keeper=%s@%s(%s#%d)\n",
				    pmf, PM_DEVICE(keeper)))
				PM_LOCK_POWER(keeper, &circ);
				for (j = 0; j < PM_NUMCMPTS(keeper);
				    j++) {
					if (PM_CURPOWER(keeper, j)) {
						PMD(PMD_KEEPS, ("%s: comp="
						    "%d is up\n", pmf, j))
						up++;
					}
				}
				if (up) {
					if (PM_SKBU(kept))
						DEVI(kept)->devi_pm_flags &=
						    ~PMC_SKIP_BRINGUP;
					bring_pmdep_up(kept, 1);
				}
				PM_UNLOCK_POWER(keeper, circ);
				ddi_release_devi(keeper);
			}
		}
	}
	ddi_release_devi(kept);
}

static void
pm_process_dep_request(pm_dep_wk_t *work)
{
	PMD_FUNC(pmf, "dep_req")
	int ret;

	PMD(PMD_DEP, ("%s: work=%s\n", pmf,
	    pdw_type_decode(work->pdw_type)))
	PMD(PMD_DEP, ("%s: keeper=%s, kept=%s\n", pmf,
	    (work->pdw_keeper ? work->pdw_keeper : "NULL"),
	    (work->pdw_kept ? work->pdw_kept : "NULL")))

	switch (work->pdw_type) {
	case PM_DEP_WK_POWER_ON:
		/* Bring up the kept devices and put a hold on them */
		bring_wekeeps_up(work->pdw_keeper);
		break;
	case PM_DEP_WK_POWER_OFF:
		/* Release the kept devices */
		pm_rele_dep(work->pdw_keeper);
		break;
	case PM_DEP_WK_DETACH:
		pm_free_keeps(work->pdw_keeper, work->pdw_pwr);
		break;
	case PM_DEP_WK_REMOVE_DEP:
		pm_discard_dependencies();
		break;
	case PM_DEP_WK_BRINGUP_SELF:
		/*
		 * We deferred satisfying our dependency till now, so satisfy
		 * it again and bring ourselves up.
		 */
		pm_bring_self_up(work->pdw_kept);
		break;
	case PM_DEP_WK_RECORD_KEEPER:
		(void) pm_record_keeper(work->pdw_kept, work->pdw_keeper, 0);
		ddi_walk_devs(ddi_root_node(), pm_kept_walk, NULL);
		ddi_walk_devs(ddi_root_node(), pm_keeper_walk, NULL);
		break;
	case PM_DEP_WK_RECORD_KEEPER_PROP:
		(void) pm_record_keeper(work->pdw_kept, work->pdw_keeper, 1);
		ddi_walk_devs(ddi_root_node(), pm_keeper_walk, NULL);
		ddi_walk_devs(ddi_root_node(), pm_kept_walk, NULL);
		break;
	case PM_DEP_WK_KEPT:
		ret = pm_kept(work->pdw_kept);
		PMD(PMD_DEP, ("%s: PM_DEP_WK_KEPT: pm_kept returns %d\n", pmf,
		    ret))
		break;
	case PM_DEP_WK_KEEPER:
		ret = pm_keeper(work->pdw_keeper);
		PMD(PMD_DEP, ("%s: PM_DEP_WK_KEEPER: pm_keeper returns %d\n",
		    pmf, ret))
		break;
	case PM_DEP_WK_ATTACH:
		ret = pm_keeper(work->pdw_keeper);
		PMD(PMD_DEP, ("%s: PM_DEP_WK_ATTACH: pm_keeper returns %d\n",
		    pmf, ret))
		ret = pm_kept(work->pdw_kept);
		PMD(PMD_DEP, ("%s: PM_DEP_WK_ATTACH: pm_kept returns %d\n",
		    pmf, ret))
		break;
	case PM_DEP_WK_CHECK_KEPT:
		ret = pm_is_kept(work->pdw_kept);
		PMD(PMD_DEP, ("%s: PM_DEP_WK_CHECK_KEPT: kept=%s, ret=%d\n",
		    pmf, work->pdw_kept, ret))
		break;
	case PM_DEP_WK_CPR_SUSPEND:
		pm_discard_dependencies();
		break;
	case PM_DEP_WK_CPR_RESUME:
		ddi_walk_devs(ddi_root_node(), pm_kept_walk, NULL);
		ddi_walk_devs(ddi_root_node(), pm_keeper_walk, NULL);
		break;
	default:
		ASSERT(0);
		break;
	}
	/*
	 * Free the work structure if the requester is not waiting
	 * Otherwise it is the requester's responsiblity to free it.
	 */
	if (!work->pdw_wait) {
		if (work->pdw_keeper)
			kmem_free(work->pdw_keeper,
			    strlen(work->pdw_keeper) + 1);
		if (work->pdw_kept)
			kmem_free(work->pdw_kept, strlen(work->pdw_kept) + 1);
		kmem_free(work, sizeof (pm_dep_wk_t));
	} else {
		/*
		 * Notify requester if it is waiting for it.
		 */
		work->pdw_ret = ret;
		work->pdw_done = 1;
		cv_signal(&work->pdw_cv);
	}
}

/*
 * Process PM dependency requests.
 */
static void
pm_dep_thread(void)
{
	pm_dep_wk_t *work;
	callb_cpr_t cprinfo;

	CALLB_CPR_INIT(&cprinfo, &pm_dep_thread_lock, callb_generic_cpr,
	    "pm_dep_thread");
	for (;;) {
		mutex_enter(&pm_dep_thread_lock);
		if (pm_dep_thread_workq == NULL) {
			CALLB_CPR_SAFE_BEGIN(&cprinfo);
			cv_wait(&pm_dep_thread_cv, &pm_dep_thread_lock);
			CALLB_CPR_SAFE_END(&cprinfo, &pm_dep_thread_lock);
		}
		work = pm_dep_thread_workq;
		pm_dep_thread_workq = work->pdw_next;
		if (pm_dep_thread_tail == work)
			pm_dep_thread_tail = work->pdw_next;
		mutex_exit(&pm_dep_thread_lock);
		pm_process_dep_request(work);

	}
	/*NOTREACHED*/
}

/*
 * Set the power level of the indicated device to unknown (if it is not a
 * backwards compatible device), as it has just been resumed, and it won't
 * know if the power was removed or not. Adjust parent's kidsupcnt if necessary.
 */
void
pm_forget_power_level(dev_info_t *dip)
{
	dev_info_t *pdip = ddi_get_parent(dip);
	int i, count = 0;

	if (!PM_ISBC(dip)) {
		for (i = 0; i < PM_NUMCMPTS(dip); i++)
			count += (PM_CURPOWER(dip, i) == 0);

		if (count && pdip && !PM_WANTS_NOTIFICATION(pdip))
			e_pm_hold_rele_power(pdip, count);

		/*
		 * Count this as a power cycle if we care
		 */
		if (DEVI(dip)->devi_pm_volpmd &&
		    PM_CP(dip, 0)->pmc_cur_pwr == 0)
			DEVI(dip)->devi_pm_volpmd = 0;
		for (i = 0; i < PM_NUMCMPTS(dip); i++)
			e_pm_set_cur_pwr(dip, PM_CP(dip, i), PM_LEVEL_UNKNOWN);
	}
}

/*
 * This function advises the caller whether it should make a power-off
 * transition at this time or not.  If the transition is not advised
 * at this time, the time that the next power-off transition can
 * be made from now is returned through "intervalp" pointer.
 * This function returns:
 *
 *  1  power-off advised
 *  0  power-off not advised, intervalp will point to seconds from
 *	  now that a power-off is advised.  If it is passed the number
 *	  of years that policy specifies the device should last,
 *	  a large number is returned as the time interval.
 *  -1  error
 */
int
pm_trans_check(struct pm_trans_data *datap, time_t *intervalp)
{
	PMD_FUNC(pmf, "pm_trans_check")
	char dbuf[DC_SCSI_MFR_LEN];
	struct pm_scsi_cycles *scp;
	int service_years, service_weeks, full_years;
	time_t now, service_seconds, tdiff;
	time_t within_year, when_allowed;
	char *ptr;
	int lower_bound_cycles, upper_bound_cycles, cycles_allowed;
	int cycles_diff, cycles_over;

	if (datap == NULL) {
		PMD(PMD_TCHECK, ("%s: NULL data pointer!\n", pmf))
		return (-1);
	}

	if (datap->format == DC_SCSI_FORMAT) {
		/*
		 * Power cycles of the scsi drives are distributed
		 * over 5 years with the following percentage ratio:
		 *
		 *	30%, 25%, 20%, 15%, and 10%
		 *
		 * The power cycle quota for each year is distributed
		 * linearly through out the year.  The equation for
		 * determining the expected cycles is:
		 *
		 *	e = a * (n / y)
		 *
		 * e = expected cycles
		 * a = allocated cycles for this year
		 * n = number of seconds since beginning of this year
		 * y = number of seconds in a year
		 *
		 * Note that beginning of the year starts the day that
		 * the drive has been put on service.
		 *
		 * If the drive has passed its expected cycles, we
		 * can determine when it can start to power cycle
		 * again to keep it on track to meet the 5-year
		 * life expectancy.  The equation for determining
		 * when to power cycle is:
		 *
		 *	w = y * (c / a)
		 *
		 * w = when it can power cycle again
		 * y = number of seconds in a year
		 * c = current number of cycles
		 * a = allocated cycles for the year
		 *
		 */
		char pcnt[DC_SCSI_NPY] = { 30, 55, 75, 90, 100 };

		scp = &datap->un.scsi_cycles;
		PMD(PMD_TCHECK, ("%s: format=%d, lifemax=%d, ncycles=%d, "
		    "svc_date=%s, svc_flag=%d\n", pmf, datap->format,
		    scp->lifemax, scp->ncycles, scp->svc_date, scp->flag))
		if (scp->ncycles < 0 || scp->flag != 0) {
			PMD(PMD_TCHECK, ("%s: ncycles < 0 || flag != 0\n", pmf))
			return (-1);
		}

		if (scp->ncycles > scp->lifemax) {
			*intervalp = (LONG_MAX / hz);
			return (0);
		}

		/*
		 * convert service date to time_t
		 */
		bcopy(scp->svc_date, dbuf, DC_SCSI_YEAR_LEN);
		dbuf[DC_SCSI_YEAR_LEN] = '\0';
		ptr = dbuf;
		service_years = stoi(&ptr) - EPOCH_YEAR;
		bcopy(&scp->svc_date[DC_SCSI_YEAR_LEN], dbuf,
		    DC_SCSI_WEEK_LEN);
		dbuf[DC_SCSI_WEEK_LEN] = '\0';

		/*
		 * scsi standard does not specify WW data,
		 * could be (00-51) or (01-52)
		 */
		ptr = dbuf;
		service_weeks = stoi(&ptr);
		if (service_years < 0 ||
		    service_weeks < 0 || service_weeks > 52) {
			PMD(PMD_TCHECK, ("%s: service year %d and week %d\n",
			    pmf, service_years, service_weeks))
			return (-1);
		}

		/*
		 * calculate service date in seconds-since-epoch,
		 * adding one day for each leap-year.
		 *
		 * (years-since-epoch + 2) fixes integer truncation,
		 * example: (8) leap-years during [1972, 2000]
		 * (2000 - 1970) = 30;  and  (30 + 2) / 4 = 8;
		 */
		service_seconds = (service_years * DC_SPY) +
		    (service_weeks * DC_SPW) +
		    (((service_years + 2) / 4) * DC_SPD);

		now = gethrestime_sec();
		/*
		 * since the granularity of 'svc_date' is day not second,
		 * 'now' should be rounded up to full day.
		 */
		now = ((now + DC_SPD -1) / DC_SPD) * DC_SPD;
		if (service_seconds > now) {
			PMD(PMD_TCHECK, ("%s: service date (%ld) later "
			    "than now (%ld)!\n", pmf, service_seconds, now))
			return (-1);
		}

		tdiff = now - service_seconds;
		PMD(PMD_TCHECK, ("%s: age is %ld sec\n", pmf, tdiff))

		/*
		 * NOTE - Leap years are not considered in the calculations
		 * below.
		 */
		full_years = (tdiff / DC_SPY);
		if ((full_years >= DC_SCSI_NPY) &&
		    (scp->ncycles <= scp->lifemax))
			return (1);

		/*
		 * Determine what is the normal cycle usage for the
		 * device at the beginning and the end of this year.
		 */
		lower_bound_cycles = (!full_years) ? 0 :
		    ((scp->lifemax * pcnt[full_years - 1]) / 100);
		upper_bound_cycles = (scp->lifemax * pcnt[full_years]) / 100;

		if (scp->ncycles <= lower_bound_cycles)
			return (1);

		/*
		 * The linear slope that determines how many cycles
		 * are allowed this year is number of seconds
		 * passed this year over total number of seconds in a year.
		 */
		cycles_diff = (upper_bound_cycles - lower_bound_cycles);
		within_year = (tdiff % DC_SPY);
		cycles_allowed = lower_bound_cycles +
		    (((uint64_t)cycles_diff * (uint64_t)within_year) / DC_SPY);
		PMD(PMD_TCHECK, ("%s: lived %d yrs and %ld secs\n", pmf,
		    full_years, within_year))
		PMD(PMD_TCHECK, ("%s: # of cycles allowed %d\n", pmf,
		    cycles_allowed))

		if (scp->ncycles <= cycles_allowed)
			return (1);

		/*
		 * The transition is not advised now but we can
		 * determine when the next transition can be made.
		 *
		 * Depending on how many cycles the device has been
		 * over-used, we may need to skip years with
		 * different percentage quota in order to determine
		 * when the next transition can be made.
		 */
		cycles_over = (scp->ncycles - lower_bound_cycles);
		while (cycles_over > cycles_diff) {
			full_years++;
			if (full_years >= DC_SCSI_NPY) {
				*intervalp = (LONG_MAX / hz);
				return (0);
			}
			cycles_over -= cycles_diff;
			lower_bound_cycles = upper_bound_cycles;
			upper_bound_cycles =
			    (scp->lifemax * pcnt[full_years]) / 100;
			cycles_diff = (upper_bound_cycles - lower_bound_cycles);
		}

		/*
		 * The linear slope that determines when the next transition
		 * can be made is the relative position of used cycles within a
		 * year over total number of cycles within that year.
		 */
		when_allowed = service_seconds + (full_years * DC_SPY) +
		    (((uint64_t)DC_SPY * (uint64_t)cycles_over) / cycles_diff);
		*intervalp = (when_allowed - now);
		if (*intervalp > (LONG_MAX / hz))
			*intervalp = (LONG_MAX / hz);
		PMD(PMD_TCHECK, ("%s: no cycle is allowed in %ld secs\n", pmf,
		    *intervalp))
		return (0);
	}

	PMD(PMD_TCHECK, ("%s: unknown format!\n", pmf))
	return (-1);
}

/*
 * Nexus drivers call into pm framework to indicate which child driver is about
 * to be installed.  In some platforms, ppm may need to configure the hardware
 * for successful installation of a driver.
 */
int
pm_init_child(dev_info_t *dip)
{
	power_req_t power_req;

	ASSERT(ddi_binding_name(dip));
	ASSERT(ddi_get_name_addr(dip));
	pm_ppm_claim(dip);
	if (pm_ppm_claimed(dip)) {	/* if ppm driver claims the node */
		power_req.request_type = PMR_PPM_INIT_CHILD;
		power_req.req.ppm_config_req.who = dip;
		ASSERT(PPM(dip) != NULL);
		return (pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, &power_req,
		    NULL));
	} else {
#ifdef DEBUG
		/* pass it to the default handler so we can debug things */
		power_req.request_type = PMR_PPM_INIT_CHILD;
		power_req.req.ppm_config_req.who = dip;
		(void) pm_ctlops(NULL, dip,
		    DDI_CTLOPS_POWER, &power_req, NULL);
#endif
	}
	return (DDI_SUCCESS);
}

/*
 * Bring parent of a node that is about to be probed up to full power, and
 * arrange for it to stay up until pm_post_probe() or pm_post_attach() decide
 * it is time to let it go down again
 */
void
pm_pre_probe(dev_info_t *dip, pm_ppm_cookie_t *cp)
{
	int result;
	power_req_t power_req;

	bzero(cp, sizeof (*cp));
	cp->ppc_dip = dip;

	pm_ppm_claim(dip);
	if (pm_ppm_claimed(dip)) {	/* if ppm driver claims the node */
		power_req.request_type = PMR_PPM_PRE_PROBE;
		power_req.req.ppm_config_req.who = dip;
		ASSERT(PPM(dip) != NULL);
		(void) pm_ctlops(PPM(dip), dip,
		    DDI_CTLOPS_POWER, &power_req, &result);
		cp->ppc_ppm = PPM(dip);
	} else {
#ifdef DEBUG
		/* pass it to the default handler so we can debug things */
		power_req.request_type = PMR_PPM_PRE_PROBE;
		power_req.req.ppm_config_req.who = dip;
		(void) pm_ctlops(NULL, dip,
		    DDI_CTLOPS_POWER, &power_req, &result);
#endif
		cp->ppc_ppm = NULL;
	}
}

int
pm_pre_config(dev_info_t *dip, char *devnm)
{
	PMD_FUNC(pmf, "pre_config")
	int ret;

	if (MDI_VHCI(dip)) {
		PMD(PMD_SET, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
		ret = mdi_power(dip, MDI_PM_PRE_CONFIG, NULL, devnm, 0);
		return (ret == MDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
	} else if (!PM_GET_PM_INFO(dip))
		return (DDI_SUCCESS);

	PMD(PMD_SET, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	pm_hold_power(dip);
	ret = pm_all_to_normal(dip, PM_CANBLOCK_BLOCK);
	if (ret != DDI_SUCCESS)
		pm_rele_power(dip);
	return (ret);
}

/*
 * This routine is called by devfs during its walk to unconfigue a node.
 * If the call is due to auto mod_unloads and the dip is not at its
 * full power, we return DDI_FAILURE to terminate the walk, otherwise
 * return DDI_SUCCESS.
 */
int
pm_pre_unconfig(dev_info_t *dip, int flags, int *held, char *devnm)
{
	PMD_FUNC(pmf, "pre_unconfig")
	int ret;

	if (MDI_VHCI(dip)) {
		PMD(PMD_SET, ("%s: %s@%s(%s#%d), flags=%x\n", pmf,
		    PM_DEVICE(dip), flags))
		ret = mdi_power(dip, MDI_PM_PRE_UNCONFIG, held, devnm, flags);
		return (ret == MDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
	} else if (!PM_GET_PM_INFO(dip))
		return (DDI_SUCCESS);

	PMD(PMD_SET, ("%s: %s@%s(%s#%d), flags=%x\n", pmf, PM_DEVICE(dip),
	    flags))
	*held = 0;

	/*
	 * If the dip is a leaf node, don't power it up.
	 */
	if (!ddi_get_child(dip))
		return (DDI_SUCCESS);

	/*
	 * Do not power up the node if it is called due to auto-modunload.
	 */
	if ((flags & NDI_AUTODETACH) && !pm_all_at_normal(dip))
		return (DDI_FAILURE);

	pm_hold_power(dip);
	*held = 1;
	ret = pm_all_to_normal(dip, PM_CANBLOCK_BLOCK);
	if (ret != DDI_SUCCESS) {
		pm_rele_power(dip);
		*held = 0;
	}
	return (ret);
}

/*
 * Notify ppm of attach action.  Parent is already held at full power by
 * probe action.
 */
void
pm_pre_attach(dev_info_t *dip, pm_ppm_cookie_t *cp, ddi_attach_cmd_t cmd)
{
	static char *me = "pm_pre_attach";
	power_req_t power_req;
	int result;

	/*
	 * Initialize and fill in the PPM cookie
	 */
	bzero(cp, sizeof (*cp));
	cp->ppc_cmd = (int)cmd;
	cp->ppc_ppm = PPM(dip);
	cp->ppc_dip = dip;

	/*
	 * DDI_ATTACH and DDI_RESUME cmds need to call platform specific
	 * Power Management stuff. DDI_RESUME also has to purge it's
	 * powerlevel information.
	 */
	switch (cmd) {
	case DDI_ATTACH:
		if (cp->ppc_ppm) {	/* if ppm driver claims the node */
			power_req.request_type = PMR_PPM_PRE_ATTACH;
			power_req.req.ppm_config_req.who = dip;
			ASSERT(PPM(dip));
			(void) pm_ctlops(cp->ppc_ppm, dip, DDI_CTLOPS_POWER,
			    &power_req, &result);
		}
#ifdef DEBUG
		else {
			power_req.request_type = PMR_PPM_PRE_ATTACH;
			power_req.req.ppm_config_req.who = dip;
			(void) pm_ctlops(NULL, dip,
			    DDI_CTLOPS_POWER, &power_req, &result);
		}
#endif
		break;
	case DDI_RESUME:
		pm_forget_power_level(dip);

		if (cp->ppc_ppm) {	/* if ppm driver claims the node */
			power_req.request_type = PMR_PPM_PRE_RESUME;
			power_req.req.resume_req.who = cp->ppc_dip;
			power_req.req.resume_req.cmd =
			    (ddi_attach_cmd_t)cp->ppc_cmd;
			ASSERT(PPM(cp->ppc_dip) == cp->ppc_ppm);
			(void) pm_ctlops(cp->ppc_ppm, cp->ppc_dip,
			    DDI_CTLOPS_POWER, &power_req, &result);
		}
#ifdef DEBUG
		else {
			power_req.request_type = PMR_PPM_PRE_RESUME;
			power_req.req.resume_req.who = cp->ppc_dip;
			power_req.req.resume_req.cmd =
			    (ddi_attach_cmd_t)cp->ppc_cmd;
			(void) pm_ctlops(NULL, cp->ppc_dip,
			    DDI_CTLOPS_POWER, &power_req, &result);
		}
#endif
		break;

	case DDI_PM_RESUME:
		break;

	default:
		panic(me);
	}
}

/*
 * Nexus drivers call into pm framework to indicate which child driver is
 * being uninstalled.  In some platforms, ppm may need to reconfigure the
 * hardware since the device driver is no longer installed.
 */
int
pm_uninit_child(dev_info_t *dip)
{
	power_req_t power_req;

	ASSERT(ddi_binding_name(dip));
	ASSERT(ddi_get_name_addr(dip));
	pm_ppm_claim(dip);
	if (pm_ppm_claimed(dip)) {	/* if ppm driver claims the node */
		power_req.request_type = PMR_PPM_UNINIT_CHILD;
		power_req.req.ppm_config_req.who = dip;
		ASSERT(PPM(dip));
		return (pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER, &power_req,
		    NULL));
	} else {
#ifdef DEBUG
		/* pass it to the default handler so we can debug things */
		power_req.request_type = PMR_PPM_UNINIT_CHILD;
		power_req.req.ppm_config_req.who = dip;
		(void) pm_ctlops(NULL, dip, DDI_CTLOPS_POWER, &power_req, NULL);
#endif
	}
	return (DDI_SUCCESS);
}
/*
 * Decrement kidsupcnt so scan can turn the parent back off if it is idle
 * Also notify ppm of result of probe if there is a ppm that cares
 */
void
pm_post_probe(pm_ppm_cookie_t *cp, int ret, int probe_failed)
{
	_NOTE(ARGUNUSED(probe_failed))
	int result;
	power_req_t power_req;

	if (cp->ppc_ppm) {	/* if ppm driver claims the node */
		power_req.request_type = PMR_PPM_POST_PROBE;
		power_req.req.ppm_config_req.who = cp->ppc_dip;
		power_req.req.ppm_config_req.result = ret;
		ASSERT(PPM(cp->ppc_dip) == cp->ppc_ppm);
		(void) pm_ctlops(cp->ppc_ppm, cp->ppc_dip, DDI_CTLOPS_POWER,
		    &power_req, &result);
	}
#ifdef DEBUG
	else {
		power_req.request_type = PMR_PPM_POST_PROBE;
		power_req.req.ppm_config_req.who = cp->ppc_dip;
		power_req.req.ppm_config_req.result = ret;
		(void) pm_ctlops(NULL, cp->ppc_dip, DDI_CTLOPS_POWER,
		    &power_req, &result);
	}
#endif
}

void
pm_post_config(dev_info_t *dip, char *devnm)
{
	PMD_FUNC(pmf, "post_config")

	if (MDI_VHCI(dip)) {
		PMD(PMD_SET, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
		(void) mdi_power(dip, MDI_PM_POST_CONFIG, NULL, devnm, 0);
		return;
	} else if (!PM_GET_PM_INFO(dip))
		return;

	PMD(PMD_SET, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	pm_rele_power(dip);
}

void
pm_post_unconfig(dev_info_t *dip, int held, char *devnm)
{
	PMD_FUNC(pmf, "post_unconfig")

	if (MDI_VHCI(dip)) {
		PMD(PMD_SET, ("%s: %s@%s(%s#%d), held = %d\n", pmf,
		    PM_DEVICE(dip), held))
		(void) mdi_power(dip, MDI_PM_POST_UNCONFIG, &held, devnm, 0);
		return;
	} else if (!PM_GET_PM_INFO(dip))
		return;

	PMD(PMD_SET, ("%s: %s@%s(%s#%d), held = %d\n", pmf, PM_DEVICE(dip),
	    held))
	if (!held)
		return;
	/*
	 * We have held power in pre_unconfig, release it here.
	 */
	pm_rele_power(dip);
}

/*
 * Notify ppm of result of attach if there is a ppm that cares
 */
void
pm_post_attach(pm_ppm_cookie_t *cp, int ret)
{
	int result;
	power_req_t power_req;
	dev_info_t	*dip;

	if (cp->ppc_cmd != DDI_ATTACH)
		return;

	dip = cp->ppc_dip;

	if (ret == DDI_SUCCESS) {
		/*
		 * Attach succeeded, so proceed to doing post-attach pm tasks
		 */
		if (PM_GET_PM_INFO(dip) == NULL)
			(void) pm_start(dip);
	} else {
		/*
		 * Attach may have got pm started before failing
		 */
		pm_stop(dip);
	}

	if (cp->ppc_ppm) {	/* if ppm driver claims the node */
		power_req.request_type = PMR_PPM_POST_ATTACH;
		power_req.req.ppm_config_req.who = cp->ppc_dip;
		power_req.req.ppm_config_req.result = ret;
		ASSERT(PPM(cp->ppc_dip) == cp->ppc_ppm);
		(void) pm_ctlops(cp->ppc_ppm, cp->ppc_dip,
		    DDI_CTLOPS_POWER, &power_req, &result);
	}
#ifdef DEBUG
	else {
		power_req.request_type = PMR_PPM_POST_ATTACH;
		power_req.req.ppm_config_req.who = cp->ppc_dip;
		power_req.req.ppm_config_req.result = ret;
		(void) pm_ctlops(NULL, cp->ppc_dip,
		    DDI_CTLOPS_POWER, &power_req, &result);
	}
#endif
}

/*
 * Notify ppm of attach action.  Parent is already held at full power by
 * probe action.
 */
void
pm_pre_detach(dev_info_t *dip, ddi_detach_cmd_t cmd, pm_ppm_cookie_t *cp)
{
	int result;
	power_req_t power_req;

	bzero(cp, sizeof (*cp));
	cp->ppc_dip = dip;
	cp->ppc_cmd = (int)cmd;

	switch (cmd) {
	case DDI_DETACH:
		pm_detaching(dip);		/* suspend pm while detaching */
		if (pm_ppm_claimed(dip)) {	/* if ppm driver claims node */
			power_req.request_type = PMR_PPM_PRE_DETACH;
			power_req.req.ppm_config_req.who = dip;
			ASSERT(PPM(dip));
			(void) pm_ctlops(PPM(dip), dip, DDI_CTLOPS_POWER,
			    &power_req, &result);
			cp->ppc_ppm = PPM(dip);
		} else {
#ifdef DEBUG
			/* pass to the default handler so we can debug things */
			power_req.request_type = PMR_PPM_PRE_DETACH;
			power_req.req.ppm_config_req.who = dip;
			(void) pm_ctlops(NULL, dip,
			    DDI_CTLOPS_POWER, &power_req, &result);
#endif
			cp->ppc_ppm = NULL;
		}
		break;

	default:
		break;
	}
}

/*
 * Dip is either a leaf node that exported "no-involuntary-power-cycles" prop.,
 * (if devi_pm_noinvol count is 0) or an ancestor of such a node.  We need to
 * make an entry to record the details, which includes certain flag settings.
 */
static void
pm_record_invol_path(char *path, int flags, int noinvolpm, int volpmd,
    int wasvolpmd, major_t major)
{
	PMD_FUNC(pmf, "record_invol_path")
	major_t pm_path_to_major(char *);
	size_t plen;
	pm_noinvol_t *ip, *np, *pp;
	pp = NULL;

	plen = strlen(path) + 1;
	np = kmem_zalloc(sizeof (*np), KM_SLEEP);
	np->ni_size = plen;
	np->ni_path = kmem_alloc(plen, KM_SLEEP);
	np->ni_noinvolpm = noinvolpm;
	np->ni_volpmd = volpmd;
	np->ni_wasvolpmd = wasvolpmd;
	np->ni_flags = flags;
	(void) strcpy(np->ni_path, path);
	/*
	 * If we haven't actually seen the node attached, it is hard to figure
	 * out its major.  If we could hold the node by path, we would be much
	 * happier here.
	 */
	if (major == DDI_MAJOR_T_NONE) {
		np->ni_major = pm_path_to_major(path);
	} else {
		np->ni_major = major;
	}
	rw_enter(&pm_noinvol_rwlock, RW_WRITER);
	for (ip = pm_noinvol_head; ip; pp = ip, ip = ip->ni_next) {
		int comp = strcmp(path, ip->ni_path);
		if (comp < 0) {
			PMD(PMD_NOINVOL, ("%s: %s insert before %s\n",
			    pmf, path, ip->ni_path))
			/* insert before current entry */
			np->ni_next = ip;
			if (pp) {
				pp->ni_next = np;
			} else {
				pm_noinvol_head = np;
			}
			rw_exit(&pm_noinvol_rwlock);
#ifdef DEBUG
			if (pm_debug & PMD_NOINVOL)
				pr_noinvol("record_invol_path exit0");
#endif
			return;
		} else if (comp == 0) {
			panic("%s already in pm_noinvol list", path);
		}
	}
	/*
	 * If we did not find an entry in the list that this should go before,
	 * then it must go at the end
	 */
	if (pp) {
		PMD(PMD_NOINVOL, ("%s: %s append after %s\n", pmf, path,
		    pp->ni_path))
		ASSERT(pp->ni_next == 0);
		pp->ni_next = np;
	} else {
		PMD(PMD_NOINVOL, ("%s: %s added to end-of-list\n", pmf, path))
		ASSERT(!pm_noinvol_head);
		pm_noinvol_head = np;
	}
	rw_exit(&pm_noinvol_rwlock);
#ifdef DEBUG
	if (pm_debug & PMD_NOINVOL)
		pr_noinvol("record_invol_path exit");
#endif
}

void
pm_record_invol(dev_info_t *dip)
{
	char *pathbuf;
	int pm_all_components_off(dev_info_t *);
	int volpmd = (PM_NUMCMPTS(dip) > 0) && pm_all_components_off(dip);

	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);

	pm_record_invol_path(pathbuf, (DEVI(dip)->devi_pm_flags &
	    (PMC_NO_INVOL | PMC_CONSOLE_FB)), DEVI(dip)->devi_pm_noinvolpm,
	    DEVI(dip)->devi_pm_volpmd, volpmd, PM_MAJOR(dip));

	/*
	 * If this child's detach will be holding up its ancestors, then we
	 * allow for an exception to that if all children of this type have
	 * gone down voluntarily.
	 * Now walk down the tree incrementing devi_pm_noinvolpm
	 */
	(void) pm_noinvol_update(PM_BP_NOINVOL_DETACH, 0, volpmd, pathbuf,
	    dip);
	kmem_free(pathbuf, MAXPATHLEN);
}

void
pm_post_detach(pm_ppm_cookie_t *cp, int ret)
{
	dev_info_t *dip = cp->ppc_dip;
	int result;
	power_req_t power_req;

	switch (cp->ppc_cmd) {
	case DDI_DETACH:
		if (cp->ppc_ppm) {	/* if ppm driver claims the node */
			power_req.request_type = PMR_PPM_POST_DETACH;
			power_req.req.ppm_config_req.who = cp->ppc_dip;
			power_req.req.ppm_config_req.result = ret;
			ASSERT(PPM(cp->ppc_dip) == cp->ppc_ppm);
			(void) pm_ctlops(cp->ppc_ppm, cp->ppc_dip,
			    DDI_CTLOPS_POWER, &power_req, &result);
		}
#ifdef DEBUG
		else {
			power_req.request_type = PMR_PPM_POST_DETACH;
			power_req.req.ppm_config_req.who = cp->ppc_dip;
			power_req.req.ppm_config_req.result = ret;
			(void) pm_ctlops(NULL, cp->ppc_dip,
			    DDI_CTLOPS_POWER, &power_req, &result);
		}
#endif
		if (ret == DDI_SUCCESS) {
			/*
			 * For hotplug detach we assume it is *really* gone
			 */
			if (cp->ppc_cmd == DDI_DETACH &&
			    ((DEVI(dip)->devi_pm_flags &
			    (PMC_NO_INVOL | PMC_CONSOLE_FB)) ||
			    DEVI(dip)->devi_pm_noinvolpm))
				pm_record_invol(dip);
			DEVI(dip)->devi_pm_flags &=
			    ~(PMC_NO_INVOL | PMC_NOINVOL_DONE);

			/*
			 * If console fb is detaching, then we don't need to
			 * worry any more about it going off (pm_detaching has
			 * brought up all components)
			 */
			if (PM_IS_CFB(dip)) {
				mutex_enter(&pm_cfb_lock);
				ASSERT(cfb_dip_detaching);
				ASSERT(cfb_dip == NULL);
				ASSERT(pm_cfb_comps_off == 0);
				cfb_dip_detaching = NULL;
				mutex_exit(&pm_cfb_lock);
			}
			pm_stop(dip);	/* make it permanent */
		} else {
			if (PM_IS_CFB(dip)) {
				mutex_enter(&pm_cfb_lock);
				ASSERT(cfb_dip_detaching);
				ASSERT(cfb_dip == NULL);
				ASSERT(pm_cfb_comps_off == 0);
				cfb_dip = cfb_dip_detaching;
				cfb_dip_detaching = NULL;
				mutex_exit(&pm_cfb_lock);
			}
			pm_detach_failed(dip);	/* resume power management */
		}
		break;
	case DDI_PM_SUSPEND:
		break;
	case DDI_SUSPEND:
		break;				/* legal, but nothing to do */
	default:
#ifdef DEBUG
		panic("pm_post_detach: unrecognized cmd %d for detach",
		    cp->ppc_cmd);
		/*NOTREACHED*/
#else
		break;
#endif
	}
}

/*
 * Called after vfs_mountroot has got the clock started to fix up timestamps
 * that were set when root bush drivers attached.  hresttime was 0 then, so the
 * devices look busy but have a 0 busycnt
 */
int
pm_adjust_timestamps(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))

	pm_info_t *info = PM_GET_PM_INFO(dip);
	struct pm_component *cp;
	int i;

	if (!info)
		return (DDI_WALK_CONTINUE);
	PM_LOCK_BUSY(dip);
	for (i = 0; i < PM_NUMCMPTS(dip); i++) {
		cp = PM_CP(dip, i);
		if (cp->pmc_timestamp == 0 && cp->pmc_busycount == 0)
			cp->pmc_timestamp = gethrestime_sec();
	}
	PM_UNLOCK_BUSY(dip);
	return (DDI_WALK_CONTINUE);
}

/*
 * Called at attach time to see if the device being attached has a record in
 * the no involuntary power cycles list.  If so, we do some bookkeeping on the
 * parents and set a flag in the dip
 */
void
pm_noinvol_specd(dev_info_t *dip)
{
	PMD_FUNC(pmf, "noinvol_specd")
	char *pathbuf;
	pm_noinvol_t *ip, *pp = NULL;
	int wasvolpmd;
	int found = 0;

	if (DEVI(dip)->devi_pm_flags & PMC_NOINVOL_DONE)
		return;
	DEVI(dip)->devi_pm_flags |=  PMC_NOINVOL_DONE;
	pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(dip, pathbuf);

	PM_LOCK_DIP(dip);
	DEVI(dip)->devi_pm_volpmd = 0;
	DEVI(dip)->devi_pm_noinvolpm = 0;
	rw_enter(&pm_noinvol_rwlock, RW_READER);
	for (ip = pm_noinvol_head; ip; pp = ip, ip = ip->ni_next) {
		PMD(PMD_NOINVOL, ("%s: comparing '%s' to '%s'\n",
		    pmf, pathbuf, ip->ni_path))
		if (strcmp(pathbuf, ip->ni_path) == 0) {
			found++;
			break;
		}
	}
	rw_exit(&pm_noinvol_rwlock);
	if (!found) {
		PM_UNLOCK_DIP(dip);
		kmem_free(pathbuf, MAXPATHLEN);
		return;
	}
	rw_enter(&pm_noinvol_rwlock, RW_WRITER);
	pp = NULL;
	for (ip = pm_noinvol_head; ip; pp = ip, ip = ip->ni_next) {
		PMD(PMD_NOINVOL, ("%s: comparing '%s' to '%s'\n",
		    pmf, pathbuf, ip->ni_path))
		if (strcmp(pathbuf, ip->ni_path) == 0) {
			ip->ni_flags &= ~PMC_DRIVER_REMOVED;
			DEVI(dip)->devi_pm_flags |= ip->ni_flags;
			/*
			 * Handle special case of console fb
			 */
			if (PM_IS_CFB(dip)) {
				mutex_enter(&pm_cfb_lock);
				cfb_dip = dip;
				PMD(PMD_CFB, ("%s: %s@%s(%s#%d) setting "
				    "cfb_dip\n", pmf, PM_DEVICE(dip)))
				mutex_exit(&pm_cfb_lock);
			}
			DEVI(dip)->devi_pm_noinvolpm = ip->ni_noinvolpm;
			ASSERT((DEVI(dip)->devi_pm_flags &
			    (PMC_NO_INVOL | PMC_CONSOLE_FB)) ||
			    DEVI(dip)->devi_pm_noinvolpm);
			DEVI(dip)->devi_pm_volpmd = ip->ni_volpmd;
			PMD(PMD_NOINVOL, ("%s: noinvol=%d, volpmd=%d, "
			    "wasvolpmd=%d, flags=%x, path=%s\n", pmf,
			    ip->ni_noinvolpm, ip->ni_volpmd,
			    ip->ni_wasvolpmd, ip->ni_flags, ip->ni_path))
			/*
			 * free the entry in hopes the list will now be empty
			 * and we won't have to search it any more until the
			 * device detaches
			 */
			if (pp) {
				PMD(PMD_NOINVOL, ("%s: free %s, prev %s\n",
				    pmf, ip->ni_path, pp->ni_path))
				pp->ni_next = ip->ni_next;
			} else {
				PMD(PMD_NOINVOL, ("%s: free %s head\n",
				    pmf, ip->ni_path))
				ASSERT(pm_noinvol_head == ip);
				pm_noinvol_head = ip->ni_next;
			}
			PM_UNLOCK_DIP(dip);
			wasvolpmd = ip->ni_wasvolpmd;
			rw_exit(&pm_noinvol_rwlock);
			kmem_free(ip->ni_path, ip->ni_size);
			kmem_free(ip, sizeof (*ip));
			/*
			 * Now walk up the tree decrementing devi_pm_noinvolpm
			 * (and volpmd if appropriate)
			 */
			(void) pm_noinvol_update(PM_BP_NOINVOL_ATTACH, 0,
			    wasvolpmd, pathbuf, dip);
#ifdef DEBUG
			if (pm_debug & PMD_NOINVOL)
				pr_noinvol("noinvol_specd exit");
#endif
			kmem_free(pathbuf, MAXPATHLEN);
			return;
		}
	}
	kmem_free(pathbuf, MAXPATHLEN);
	rw_exit(&pm_noinvol_rwlock);
	PM_UNLOCK_DIP(dip);
}

int
pm_all_components_off(dev_info_t *dip)
{
	int i;
	pm_component_t *cp;

	for (i = 0; i < PM_NUMCMPTS(dip); i++) {
		cp = PM_CP(dip, i);
		if (cp->pmc_cur_pwr == PM_LEVEL_UNKNOWN ||
		    cp->pmc_comp.pmc_lvals[cp->pmc_cur_pwr])
			return (0);
	}
	return (1);	/* all off */
}

/*
 * Make sure that all "no involuntary power cycles" devices are attached.
 * Called before doing a cpr suspend to make sure the driver has a say about
 * the power cycle
 */
int
pm_reattach_noinvol(void)
{
	PMD_FUNC(pmf, "reattach_noinvol")
	pm_noinvol_t *ip;
	char *path;
	dev_info_t *dip;

	/*
	 * Prevent the modunload thread from unloading any modules until we
	 * have completely stopped all kernel threads.
	 */
	modunload_disable();
	for (ip = pm_noinvol_head; ip; ip = ip->ni_next) {
		/*
		 * Forget we'v ever seen any entry
		 */
		ip->ni_persistent = 0;
	}
restart:
	rw_enter(&pm_noinvol_rwlock, RW_READER);
	for (ip = pm_noinvol_head; ip; ip = ip->ni_next) {
#ifdef PMDDEBUG
		major_t maj;
		maj = ip->ni_major;
#endif
		path = ip->ni_path;
		if (path != NULL && !(ip->ni_flags & PMC_DRIVER_REMOVED)) {
			if (ip->ni_persistent) {
				/*
				 * If we weren't able to make this entry
				 * go away, then we give up, as
				 * holding/attaching the driver ought to have
				 * resulted in this entry being deleted
				 */
				PMD(PMD_NOINVOL, ("%s: can't reattach %s "
				    "(%s|%d)\n", pmf, ip->ni_path,
				    ddi_major_to_name(maj), (int)maj))
				cmn_err(CE_WARN, "cpr: unable to reattach %s ",
				    ip->ni_path);
				modunload_enable();
				rw_exit(&pm_noinvol_rwlock);
				return (0);
			}
			ip->ni_persistent++;
			rw_exit(&pm_noinvol_rwlock);
			PMD(PMD_NOINVOL, ("%s: holding %s\n", pmf, path))
			dip = e_ddi_hold_devi_by_path(path, 0);
			if (dip == NULL) {
				PMD(PMD_NOINVOL, ("%s: can't hold (%s|%d)\n",
				    pmf, path, (int)maj))
				cmn_err(CE_WARN, "cpr: unable to hold %s "
				    "driver", path);
				modunload_enable();
				return (0);
			} else {
				PMD(PMD_DHR, ("%s: release %s\n", pmf, path))
				/*
				 * Since the modunload thread is stopped, we
				 * don't have to keep the driver held, which
				 * saves a ton of bookkeeping
				 */
				ddi_release_devi(dip);
				goto restart;
			}
		} else {
			PMD(PMD_NOINVOL, ("%s: skip %s; unknown major\n",
			    pmf, ip->ni_path))
			continue;
		}
	}
	rw_exit(&pm_noinvol_rwlock);
	return (1);
}

void
pm_reattach_noinvol_fini(void)
{
	modunload_enable();
}

/*
 * Display pm support code
 */


/*
 * console frame-buffer power-mgmt gets enabled when debugging
 * services are not present or console fbpm override is set
 */
void
pm_cfb_setup(const char *stdout_path)
{
	PMD_FUNC(pmf, "cfb_setup")
	extern int obpdebug;
	char *devname;
	dev_info_t *dip;
	int devname_len;
	extern dev_info_t *fbdip;

	/*
	 * By virtue of this function being called (from consconfig),
	 * we know stdout is a framebuffer.
	 */
	stdout_is_framebuffer = 1;

	if (obpdebug || (boothowto & RB_DEBUG)) {
		if (pm_cfb_override == 0) {
			/*
			 * Console is frame buffer, but we want to suppress
			 * pm on it because of debugging setup
			 */
			pm_cfb_enabled = 0;
			cmn_err(CE_NOTE, "Kernel debugger present: disabling "
			    "console power management.");
			/*
			 * however, we still need to know which is the console
			 * fb in order to suppress pm on it
			 */
		} else {
			cmn_err(CE_WARN, "Kernel debugger present: see "
			    "kmdb(1M) for interaction with power management.");
		}
	}
#ifdef DEBUG
	/*
	 * IF console is fb and is power managed, don't do prom_printfs from
	 * pm debug macro
	 */
	if (pm_cfb_enabled && !pm_debug_to_console) {
		if (pm_debug)
			prom_printf("pm debug output will be to log only\n");
		pm_divertdebug++;
	}
#endif
	devname = i_ddi_strdup((char *)stdout_path, KM_SLEEP);
	devname_len = strlen(devname) + 1;
	PMD(PMD_CFB, ("%s: stripped %s\n", pmf, devname))
	/* if the driver is attached */
	if ((dip = fbdip) != NULL) {
		PMD(PMD_CFB, ("%s: attached: %s@%s(%s#%d)\n", pmf,
		    PM_DEVICE(dip)))
		/*
		 * We set up here as if the driver were power manageable in case
		 * we get a later attach of a pm'able driver (which would result
		 * in a panic later)
		 */
		cfb_dip = dip;
		DEVI(dip)->devi_pm_flags |= (PMC_CONSOLE_FB | PMC_NO_INVOL);
		PMD(PMD_CFB, ("%s: cfb_dip -> %s@%s(%s#%d)\n", pmf,
		    PM_DEVICE(dip)))
#ifdef DEBUG
		if (!(PM_GET_PM_INFO(dip) != NULL && PM_NUMCMPTS(dip))) {
			PMD(PMD_CFB, ("%s: %s@%s(%s#%d) not power-managed\n",
			    pmf, PM_DEVICE(dip)))
		}
#endif
	} else {
		char *ep;
		PMD(PMD_CFB, ("%s: pntd %s failed\n", pmf, devname))
		pm_record_invol_path(devname,
		    (PMC_CONSOLE_FB | PMC_NO_INVOL), 1, 0, 0,
		    DDI_MAJOR_T_NONE);
		for (ep = strrchr(devname, '/'); ep != devname;
		    ep = strrchr(devname, '/')) {
			PMD(PMD_CFB, ("%s: devname %s\n", pmf, devname))
			*ep = '\0';
			dip = pm_name_to_dip(devname, 0);
			if (dip != NULL) {
				/*
				 * Walk up the tree incrementing
				 * devi_pm_noinvolpm
				 */
				(void) pm_noinvol_update(PM_BP_NOINVOL_CFB,
				    0, 0, devname, dip);
				break;
			} else {
				pm_record_invol_path(devname,
				    PMC_NO_INVOL, 1, 0, 0, DDI_MAJOR_T_NONE);
			}
		}
	}
	kmem_free(devname, devname_len);
}

void
pm_cfb_rele(void)
{
	mutex_enter(&pm_cfb_lock);
	/*
	 * this call isn't using the console any  more, it is ok to take it
	 * down if the count goes to 0
	 */
	cfb_inuse--;
	mutex_exit(&pm_cfb_lock);
}

/*
 * software interrupt handler for fbpm; this function exists because we can't
 * bring up the frame buffer power from above lock level.  So if we need to,
 * we instead schedule a softint that runs this routine and takes us into
 * debug_enter (a bit delayed from the original request, but avoiding a panic).
 */
static uint_t
pm_cfb_softint(caddr_t int_handler_arg)
{
	_NOTE(ARGUNUSED(int_handler_arg))
	int rval = DDI_INTR_UNCLAIMED;

	mutex_enter(&pm_cfb_lock);
	if (pm_soft_pending) {
		mutex_exit(&pm_cfb_lock);
		debug_enter((char *)NULL);
		/* acquired in debug_enter before calling pm_cfb_trigger */
		pm_cfb_rele();
		mutex_enter(&pm_cfb_lock);
		pm_soft_pending = 0;
		mutex_exit(&pm_cfb_lock);
		rval = DDI_INTR_CLAIMED;
	} else
		mutex_exit(&pm_cfb_lock);

	return (rval);
}

void
pm_cfb_setup_intr(void)
{
	PMD_FUNC(pmf, "cfb_setup_intr")
	extern void prom_set_outfuncs(void (*)(void), void (*)(void));
	void pm_cfb_check_and_powerup(void);

	mutex_init(&pm_cfb_lock, NULL, MUTEX_SPIN, (void *)ipltospl(SPL8));
#ifdef PMDDEBUG
	mutex_init(&pm_debug_lock, NULL, MUTEX_SPIN, (void *)ipltospl(SPL8));
#endif

	if (!stdout_is_framebuffer) {
		PMD(PMD_CFB, ("%s: console not fb\n", pmf))
		return;
	}

	/*
	 * setup software interrupt handler
	 */
	if (ddi_add_softintr(ddi_root_node(), DDI_SOFTINT_HIGH, &pm_soft_id,
	    NULL, NULL, pm_cfb_softint, NULL) != DDI_SUCCESS)
		panic("pm: unable to register soft intr.");

	prom_set_outfuncs(pm_cfb_check_and_powerup, pm_cfb_rele);
}

/*
 * Checks to see if it is safe to write to the console wrt power management
 * (i.e. if the console is a framebuffer, then it must be at full power)
 * returns 1 when power is off (power-up is needed)
 * returns 0 when power is on (power-up not needed)
 */
int
pm_cfb_check_and_hold(void)
{
	/*
	 * cfb_dip is set iff console is a power manageable frame buffer
	 * device
	 */
	extern int modrootloaded;

	mutex_enter(&pm_cfb_lock);
	cfb_inuse++;
	ASSERT(cfb_inuse);	/* wrap? */
	if (modrootloaded && cfb_dip) {
		/*
		 * don't power down the frame buffer, the prom is using it
		 */
		if (pm_cfb_comps_off) {
			mutex_exit(&pm_cfb_lock);
			return (1);
		}
	}
	mutex_exit(&pm_cfb_lock);
	return (0);
}

/*
 * turn on cfb power (which is known to be off).
 * Must be called below lock level!
 */
void
pm_cfb_powerup(void)
{
	pm_info_t *info;
	int norm;
	int ccount, ci;
	int unused;
#ifdef DEBUG
	/*
	 * Can't reenter prom_prekern, so suppress pm debug messages
	 * (still go to circular buffer).
	 */
	mutex_enter(&pm_debug_lock);
	pm_divertdebug++;
	mutex_exit(&pm_debug_lock);
#endif
	info = PM_GET_PM_INFO(cfb_dip);
	ASSERT(info);

	ccount = PM_NUMCMPTS(cfb_dip);
	for (ci = 0; ci < ccount; ci++) {
		norm = pm_get_normal_power(cfb_dip, ci);
		(void) pm_set_power(cfb_dip, ci, norm, PM_LEVEL_UPONLY,
		    PM_CANBLOCK_BYPASS, 0, &unused);
	}
#ifdef DEBUG
	mutex_enter(&pm_debug_lock);
	pm_divertdebug--;
	mutex_exit(&pm_debug_lock);
#endif
}

/*
 * Check if the console framebuffer is powered up.  If not power it up.
 * Note: Calling pm_cfb_check_and_hold has put a hold on the power state which
 * must be released by calling pm_cfb_rele when the console fb operation
 * is completed.
 */
void
pm_cfb_check_and_powerup(void)
{
	if (pm_cfb_check_and_hold())
		pm_cfb_powerup();
}

/*
 * Trigger a low level interrupt to power up console frame buffer.
 */
void
pm_cfb_trigger(void)
{
	if (cfb_dip == NULL)
		return;

	mutex_enter(&pm_cfb_lock);
	/*
	 * If machine appears to be hung, pulling the keyboard connector of
	 * the console will cause a high level interrupt and go to debug_enter.
	 * But, if the fb is powered down, this routine will be called to bring
	 * it up (by generating a softint to do the work).  If soft interrupts
	 * are not running, and the keyboard connector is pulled again, the
	 * following code detects this condition and calls panic which allows
	 * the fb to be brought up from high level.
	 *
	 * If two nearly simultaneous calls to debug_enter occur (both from
	 * high level) the code described above will cause a panic.
	 */
	if (lbolt <= pm_soft_pending) {
		panicstr = "pm_cfb_trigger: lbolt not advancing";
		panic(panicstr);	/* does a power up at any intr level */
		/* NOTREACHED */
	}
	pm_soft_pending = lbolt;
	mutex_exit(&pm_cfb_lock);
	ddi_trigger_softintr(pm_soft_id);
}

major_t
pm_path_to_major(char *path)
{
	PMD_FUNC(pmf, "path_to_major")
	char *np, *ap, *bp;
	major_t ret;
	size_t len;
	static major_t i_path_to_major(char *, char *);

	PMD(PMD_NOINVOL, ("%s: %s\n", pmf, path))

	np = strrchr(path, '/');
	if (np != NULL)
		np++;
	else
		np = path;
	len = strlen(np) + 1;
	bp = kmem_alloc(len, KM_SLEEP);
	(void) strcpy(bp, np);
	if ((ap = strchr(bp, '@')) != NULL) {
		*ap = '\0';
	}
	PMD(PMD_NOINVOL, ("%s: %d\n", pmf, ddi_name_to_major(np)))
	ret = i_path_to_major(path, np);
	kmem_free(bp, len);
	return (ret);
}

#ifdef DEBUG
#ifndef sparc
clock_t pt_sleep = 1;
#endif

char	*pm_msgp;
char	*pm_bufend;
char	*pm_msgbuf = NULL;
int	pm_logpages = 0x100;
#include <sys/sunldi.h>
#include <sys/uio.h>
clock_t	pm_log_sleep = 1000;
int	pm_extra_cr = 1;
volatile int pm_tty = 1;

#define	PMLOGPGS	pm_logpages

#if defined(__x86)
void pm_printf(char *s);
#endif

/*PRINTFLIKE1*/
void
pm_log(const char *fmt, ...)
{
	va_list adx;
	size_t size;

	mutex_enter(&pm_debug_lock);
	if (pm_msgbuf == NULL) {
		pm_msgbuf = kmem_zalloc(mmu_ptob(PMLOGPGS), KM_SLEEP);
		pm_bufend = pm_msgbuf + mmu_ptob(PMLOGPGS) - 1;
		pm_msgp = pm_msgbuf;
	}
	va_start(adx, fmt);
	size = vsnprintf(NULL, 0, fmt, adx) + 1;
	va_end(adx);
	va_start(adx, fmt);
	if (size > (pm_bufend - pm_msgp)) {		/* wraps */
		bzero(pm_msgp, pm_bufend - pm_msgp);
		(void) vsnprintf(pm_msgbuf, size, fmt, adx);
		if (!pm_divertdebug)
			prom_printf("%s", pm_msgp);
#if defined(__x86)
		if (pm_tty) {
			pm_printf(pm_msgp);
			if (pm_extra_cr)
				pm_printf("\r");
		}
#endif
		pm_msgp = pm_msgbuf + size;
	} else {
		(void) vsnprintf(pm_msgp, size, fmt, adx);
#if defined(__x86)
		if (pm_tty) {
			pm_printf(pm_msgp);
			if (pm_extra_cr)
				pm_printf("\r");
		}
#endif
		if (!pm_divertdebug)
			prom_printf("%s", pm_msgp);
		pm_msgp += size;
	}
	va_end(adx);
	mutex_exit(&pm_debug_lock);
	drv_usecwait((clock_t)pm_log_sleep);
}
#endif	/* DEBUG */

/*
 * We want to save the state of any directly pm'd devices over the suspend/
 * resume process so that we can put them back the way the controlling
 * process left them.
 */
void
pm_save_direct_levels(void)
{
	pm_processes_stopped = 1;
	ddi_walk_devs(ddi_root_node(), pm_save_direct_lvl_walk, 0);
}

static int
pm_save_direct_lvl_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))
	int i;
	int *ip;
	pm_info_t *info = PM_GET_PM_INFO(dip);

	if (!info)
		return (DDI_WALK_CONTINUE);

	if (PM_ISDIRECT(dip) && !PM_ISBC(dip)) {
		if (PM_NUMCMPTS(dip) > 2) {
			info->pmi_lp = kmem_alloc(PM_NUMCMPTS(dip) *
			    sizeof (int), KM_SLEEP);
			ip = info->pmi_lp;
		} else {
			ip = info->pmi_levels;
		}
		/* autopm and processes are stopped, ok not to lock power */
		for (i = 0; i < PM_NUMCMPTS(dip); i++)
			*ip++ = PM_CURPOWER(dip, i);
		/*
		 * There is a small window between stopping the
		 * processes and setting pm_processes_stopped where
		 * a driver could get hung up in a pm_raise_power()
		 * call.  Free any such driver now.
		 */
		pm_proceed(dip, PMP_RELEASE, -1, -1);
	}

	return (DDI_WALK_CONTINUE);
}

void
pm_restore_direct_levels(void)
{
	/*
	 * If cpr didn't call pm_save_direct_levels, (because stopping user
	 * threads failed) then we don't want to try to restore them
	 */
	if (!pm_processes_stopped)
		return;

	ddi_walk_devs(ddi_root_node(), pm_restore_direct_lvl_walk, 0);
	pm_processes_stopped = 0;
}

static int
pm_restore_direct_lvl_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))
	PMD_FUNC(pmf, "restore_direct_lvl_walk")
	int i, nc, result;
	int *ip;

	pm_info_t *info = PM_GET_PM_INFO(dip);
	if (!info)
		return (DDI_WALK_CONTINUE);

	if (PM_ISDIRECT(dip) && !PM_ISBC(dip)) {
		if ((nc = PM_NUMCMPTS(dip)) > 2) {
			ip = &info->pmi_lp[nc - 1];
		} else {
			ip = &info->pmi_levels[nc - 1];
		}
		/*
		 * Because fb drivers fail attempts to turn off the
		 * fb when the monitor is on, but treat a request to
		 * turn on the monitor as a request to turn on the
		 * fb too, we process components in descending order
		 * Because autopm is disabled and processes aren't
		 * running, it is ok to examine current power outside
		 * of the power lock
		 */
		for (i = nc - 1; i >= 0; i--, ip--) {
			if (PM_CURPOWER(dip, i) == *ip)
				continue;
			if (pm_set_power(dip, i, *ip, PM_LEVEL_EXACT,
			    PM_CANBLOCK_BYPASS, 0, &result) != DDI_SUCCESS) {
				cmn_err(CE_WARN, "cpr: unable "
				    "to restore power level of "
				    "component %d of directly "
				    "power manged device %s@%s"
				    " to %d",
				    i, PM_NAME(dip),
				    PM_ADDR(dip), *ip);
				PMD(PMD_FAIL, ("%s: failed to restore "
				    "%s@%s(%s#%d)[%d] exact(%d)->%d, "
				    "errno %d\n", pmf, PM_DEVICE(dip), i,
				    PM_CURPOWER(dip, i), *ip, result))
			}
		}
		if (nc > 2) {
			kmem_free(info->pmi_lp, nc * sizeof (int));
			info->pmi_lp = NULL;
		}
	}
	return (DDI_WALK_CONTINUE);
}

/*
 * Stolen from the bootdev module
 * attempt to convert a path to a major number
 */
static major_t
i_path_to_major(char *path, char *leaf_name)
{
	extern major_t path_to_major(char *pathname);
	major_t maj;

	if ((maj = path_to_major(path)) == DDI_MAJOR_T_NONE) {
		maj = ddi_name_to_major(leaf_name);
	}

	return (maj);
}

/*
 * When user calls rem_drv, we need to forget no-involuntary-power-cycles state
 * An entry in the list means that the device is detached, so we need to
 * adjust its ancestors as if they had just seen this attach, and any detached
 * ancestors need to have their list entries adjusted.
 */
void
pm_driver_removed(major_t major)
{
	static void i_pm_driver_removed(major_t major);

	/*
	 * Serialize removal of drivers. This is to keep ancestors of
	 * a node that is being deleted from getting deleted and added back
	 * with different counters.
	 */
	mutex_enter(&pm_remdrv_lock);
	i_pm_driver_removed(major);
	mutex_exit(&pm_remdrv_lock);
}

/*
 * This routine is called recursively by pm_noinvol_process_ancestors()
 */
static void
i_pm_driver_removed(major_t major)
{
	PMD_FUNC(pmf, "driver_removed")
	static void adjust_ancestors(char *, int);
	static int pm_is_noinvol_ancestor(pm_noinvol_t *);
	static void pm_noinvol_process_ancestors(char *);
	pm_noinvol_t *ip, *pp = NULL;
	int wasvolpmd;
	ASSERT(major != DDI_MAJOR_T_NONE);
	PMD(PMD_NOINVOL, ("%s: %s\n", pmf, ddi_major_to_name(major)))
again:
	rw_enter(&pm_noinvol_rwlock, RW_WRITER);
	for (ip = pm_noinvol_head; ip; pp = ip, ip = ip->ni_next) {
		if (major != ip->ni_major)
			continue;
		/*
		 * If it is an ancestor of no-invol node, which is
		 * not removed, skip it. This is to cover the case of
		 * ancestor removed without removing its descendants.
		 */
		if (pm_is_noinvol_ancestor(ip)) {
			ip->ni_flags |= PMC_DRIVER_REMOVED;
			continue;
		}
		wasvolpmd = ip->ni_wasvolpmd;
		/*
		 * remove the entry from the list
		 */
		if (pp) {
			PMD(PMD_NOINVOL, ("%s: freeing %s, prev is %s\n",
			    pmf, ip->ni_path, pp->ni_path))
			pp->ni_next = ip->ni_next;
		} else {
			PMD(PMD_NOINVOL, ("%s: free %s head\n", pmf,
			    ip->ni_path))
			ASSERT(pm_noinvol_head == ip);
			pm_noinvol_head = ip->ni_next;
		}
		rw_exit(&pm_noinvol_rwlock);
		adjust_ancestors(ip->ni_path, wasvolpmd);
		/*
		 * Had an ancestor been removed before this node, it would have
		 * been skipped. Adjust the no-invol counters for such skipped
		 * ancestors.
		 */
		pm_noinvol_process_ancestors(ip->ni_path);
		kmem_free(ip->ni_path, ip->ni_size);
		kmem_free(ip, sizeof (*ip));
		goto again;
	}
	rw_exit(&pm_noinvol_rwlock);
}

/*
 * returns 1, if *aip is a ancestor of a no-invol node
 *	   0, otherwise
 */
static int
pm_is_noinvol_ancestor(pm_noinvol_t *aip)
{
	pm_noinvol_t *ip;

	ASSERT(strlen(aip->ni_path) != 0);
	for (ip = pm_noinvol_head; ip; ip = ip->ni_next) {
		if (ip == aip)
			continue;
		/*
		 * To be an ancestor, the path must be an initial substring of
		 * the descendent, and end just before a '/' in the
		 * descendent's path.
		 */
		if ((strstr(ip->ni_path, aip->ni_path) == ip->ni_path) &&
		    (ip->ni_path[strlen(aip->ni_path)] == '/'))
			return (1);
	}
	return (0);
}

#define	PM_MAJOR(dip) ddi_name_to_major(ddi_binding_name(dip))
/*
 * scan through the pm_noinvolpm list adjusting ancestors of the current
 * node;  Modifies string *path.
 */
static void
adjust_ancestors(char *path, int wasvolpmd)
{
	PMD_FUNC(pmf, "adjust_ancestors")
	char *cp;
	pm_noinvol_t *lp;
	pm_noinvol_t *pp = NULL;
	major_t locked = DDI_MAJOR_T_NONE;
	dev_info_t *dip;
	char	*pathbuf;
	size_t pathbuflen = strlen(path) + 1;

	/*
	 * First we look up the ancestor's dip.  If we find it, then we
	 * adjust counts up the tree
	 */
	PMD(PMD_NOINVOL, ("%s: %s wasvolpmd %d\n", pmf, path, wasvolpmd))
	pathbuf = kmem_alloc(pathbuflen, KM_SLEEP);
	(void) strcpy(pathbuf, path);
	cp = strrchr(pathbuf, '/');
	if (cp == NULL)	{
		/* if no ancestors, then nothing to do */
		kmem_free(pathbuf, pathbuflen);
		return;
	}
	*cp = '\0';
	dip = pm_name_to_dip(pathbuf, 1);
	if (dip != NULL) {
		locked = PM_MAJOR(dip);

		(void) pm_noinvol_update(PM_BP_NOINVOL_REMDRV, 0, wasvolpmd,
		    path, dip);

		if (locked != DDI_MAJOR_T_NONE)
			ddi_release_devi(dip);
	} else {
		char *apath;
		size_t len = strlen(pathbuf) + 1;
		int  lock_held = 1;

		/*
		 * Now check for ancestors that exist only in the list
		 */
		apath = kmem_alloc(len, KM_SLEEP);
		(void) strcpy(apath, pathbuf);
		rw_enter(&pm_noinvol_rwlock, RW_WRITER);
		for (lp = pm_noinvol_head; lp; pp = lp, lp = lp->ni_next) {
			/*
			 * This can only happen once.  Since we have to drop
			 * the lock, we need to extract the relevant info.
			 */
			if (strcmp(pathbuf, lp->ni_path) == 0) {
				PMD(PMD_NOINVOL, ("%s: %s no %d -> %d\n", pmf,
				    lp->ni_path, lp->ni_noinvolpm,
				    lp->ni_noinvolpm - 1))
				lp->ni_noinvolpm--;
				if (wasvolpmd && lp->ni_volpmd) {
					PMD(PMD_NOINVOL, ("%s: %s vol %d -> "
					    "%d\n", pmf, lp->ni_path,
					    lp->ni_volpmd, lp->ni_volpmd - 1))
					lp->ni_volpmd--;
				}
				/*
				 * remove the entry from the list, if there
				 * are no more no-invol descendants and node
				 * itself is not a no-invol node.
				 */
				if (!(lp->ni_noinvolpm ||
				    (lp->ni_flags & PMC_NO_INVOL))) {
					ASSERT(lp->ni_volpmd == 0);
					if (pp) {
						PMD(PMD_NOINVOL, ("%s: freeing "
						    "%s, prev is %s\n", pmf,
						    lp->ni_path, pp->ni_path))
						pp->ni_next = lp->ni_next;
					} else {
						PMD(PMD_NOINVOL, ("%s: free %s "
						    "head\n", pmf, lp->ni_path))
						ASSERT(pm_noinvol_head == lp);
						pm_noinvol_head = lp->ni_next;
					}
					lock_held = 0;
					rw_exit(&pm_noinvol_rwlock);
					adjust_ancestors(apath, wasvolpmd);
					/* restore apath */
					(void) strcpy(apath, pathbuf);
					kmem_free(lp->ni_path, lp->ni_size);
					kmem_free(lp, sizeof (*lp));
				}
				break;
			}
		}
		if (lock_held)
			rw_exit(&pm_noinvol_rwlock);
		adjust_ancestors(apath, wasvolpmd);
		kmem_free(apath, len);
	}
	kmem_free(pathbuf, pathbuflen);
}

/*
 * Do no-invol processing for any ancestors i.e. adjust counters of ancestors,
 * which were skipped even though their drivers were removed.
 */
static void
pm_noinvol_process_ancestors(char *path)
{
	pm_noinvol_t *lp;

	rw_enter(&pm_noinvol_rwlock, RW_READER);
	for (lp = pm_noinvol_head; lp; lp = lp->ni_next) {
		if (strstr(path, lp->ni_path) &&
		    (lp->ni_flags & PMC_DRIVER_REMOVED)) {
			rw_exit(&pm_noinvol_rwlock);
			i_pm_driver_removed(lp->ni_major);
			return;
		}
	}
	rw_exit(&pm_noinvol_rwlock);
}

/*
 * Returns true if (detached) device needs to be kept up because it exported the
 * "no-involuntary-power-cycles" property or we're pretending it did (console
 * fb case) or it is an ancestor of such a device and has used up the "one
 * free cycle" allowed when all such leaf nodes have voluntarily powered down
 * upon detach.  In any event, we need an exact hit on the path or we return
 * false.
 */
int
pm_noinvol_detached(char *path)
{
	PMD_FUNC(pmf, "noinvol_detached")
	pm_noinvol_t *ip;
	int ret = 0;

	rw_enter(&pm_noinvol_rwlock, RW_READER);
	for (ip = pm_noinvol_head; ip; ip = ip->ni_next) {
		if (strcmp(path, ip->ni_path) == 0) {
			if (ip->ni_flags & PMC_CONSOLE_FB) {
				PMD(PMD_NOINVOL | PMD_CFB, ("%s: inhibits CFB "
				    "%s\n", pmf, path))
				ret = 1;
				break;
			}
#ifdef	DEBUG
			if (ip->ni_noinvolpm != ip->ni_volpmd)
				PMD(PMD_NOINVOL, ("%s: (%d != %d) inhibits %s"
				    "\n", pmf, ip->ni_noinvolpm, ip->ni_volpmd,
				    path))
#endif
			ret = (ip->ni_noinvolpm != ip->ni_volpmd);
			break;
		}
	}
	rw_exit(&pm_noinvol_rwlock);
	return (ret);
}

int
pm_is_cfb(dev_info_t *dip)
{
	return (dip == cfb_dip);
}

#ifdef	DEBUG
/*
 * Return true if all components of the console frame buffer are at
 * "normal" power, i.e., fully on.  For the case where the console is not
 * a framebuffer, we also return true
 */
int
pm_cfb_is_up(void)
{
	return (pm_cfb_comps_off == 0);
}
#endif

/*
 * Preventing scan from powering down the node by incrementing the
 * kidsupcnt.
 */
void
pm_hold_power(dev_info_t *dip)
{
	e_pm_hold_rele_power(dip, 1);
}

/*
 * Releasing the hold by decrementing the kidsupcnt allowing scan
 * to power down the node if all conditions are met.
 */
void
pm_rele_power(dev_info_t *dip)
{
	e_pm_hold_rele_power(dip, -1);
}

/*
 * A wrapper of pm_all_to_normal() to power up a dip
 * to its normal level
 */
int
pm_powerup(dev_info_t *dip)
{
	PMD_FUNC(pmf, "pm_powerup")

	PMD(PMD_ALLNORM, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	ASSERT(!(servicing_interrupt()));

	/*
	 * in case this node is not already participating pm
	 */
	if (!PM_GET_PM_INFO(dip)) {
		if (!DEVI_IS_ATTACHING(dip))
			return (DDI_SUCCESS);
		if (pm_start(dip) != DDI_SUCCESS)
			return (DDI_FAILURE);
		if (!PM_GET_PM_INFO(dip))
			return (DDI_SUCCESS);
	}

	return (pm_all_to_normal(dip, PM_CANBLOCK_BLOCK));
}

int
pm_rescan_walk(dev_info_t *dip, void *arg)
{
	_NOTE(ARGUNUSED(arg))

	if (!PM_GET_PM_INFO(dip) || PM_ISBC(dip))
		return (DDI_WALK_CONTINUE);

	/*
	 * Currently pm_cpr_callb/resume code is the only caller
	 * and it needs to make sure that stopped scan get
	 * reactivated. Otherwise, rescan walk needn't reactive
	 * stopped scan.
	 */
	pm_scan_init(dip);

	(void) pm_rescan(dip);
	return (DDI_WALK_CONTINUE);
}

static dev_info_t *
pm_get_next_descendent(dev_info_t *dip, dev_info_t *tdip)
{
	dev_info_t *wdip, *pdip;

	for (wdip = tdip; wdip != dip; wdip = pdip) {
		pdip = ddi_get_parent(wdip);
		if (pdip == dip)
			return (wdip);
	}
	return (NULL);
}

int
pm_busop_bus_power(dev_info_t *dip, void *impl_arg, pm_bus_power_op_t op,
    void *arg, void *result)
{
	PMD_FUNC(pmf, "bp_bus_power")
	dev_info_t	*cdip;
	pm_info_t	*cinfo;
	pm_bp_child_pwrchg_t	*bpc;
	pm_sp_misc_t		*pspm;
	pm_bp_nexus_pwrup_t *bpn;
	pm_bp_child_pwrchg_t new_bpc;
	pm_bp_noinvol_t *bpi;
	dev_info_t *tdip;
	char *pathbuf;
	int		ret = DDI_SUCCESS;
	int		errno = 0;
	pm_component_t *cp;

	PMD(PMD_SET, ("%s: %s@%s(%s#%d) %s\n", pmf, PM_DEVICE(dip),
	    pm_decode_op(op)))
	switch (op) {
	case BUS_POWER_CHILD_PWRCHG:
		bpc = (pm_bp_child_pwrchg_t *)arg;
		pspm = (pm_sp_misc_t *)bpc->bpc_private;
		tdip = bpc->bpc_dip;
		cdip = pm_get_next_descendent(dip, tdip);
		cinfo = PM_GET_PM_INFO(cdip);
		if (cdip != tdip) {
			/*
			 * If the node is an involved parent, it needs to
			 * power up the node as it is needed.  There is nothing
			 * else the framework can do here.
			 */
			if (PM_WANTS_NOTIFICATION(cdip)) {
				PMD(PMD_SET, ("%s: call bus_power for "
				    "%s@%s(%s#%d)\n", pmf, PM_DEVICE(cdip)))
				return ((*PM_BUS_POWER_FUNC(cdip))(cdip,
				    impl_arg, op, arg, result));
			}
			ASSERT(pspm->pspm_direction == PM_LEVEL_UPONLY ||
			    pspm->pspm_direction == PM_LEVEL_DOWNONLY ||
			    pspm->pspm_direction == PM_LEVEL_EXACT);
			/*
			 * we presume that the parent needs to be up in
			 * order for the child to change state (either
			 * because it must already be on if the child is on
			 * (and the pm_all_to_normal_nexus() will be a nop)
			 * or because it will need to be on for the child
			 * to come on; so we make the call regardless
			 */
			pm_hold_power(cdip);
			if (cinfo) {
				pm_canblock_t canblock = pspm->pspm_canblock;
				ret = pm_all_to_normal_nexus(cdip, canblock);
				if (ret != DDI_SUCCESS) {
					pm_rele_power(cdip);
					return (ret);
				}
			}
			PMD(PMD_SET, ("%s: walk down to %s@%s(%s#%d)\n", pmf,
			    PM_DEVICE(cdip)))
			ret = pm_busop_bus_power(cdip, impl_arg, op, arg,
			    result);
			pm_rele_power(cdip);
		} else {
			ret = pm_busop_set_power(cdip, impl_arg, op, arg,
			    result);
		}
		return (ret);

	case BUS_POWER_NEXUS_PWRUP:
		bpn = (pm_bp_nexus_pwrup_t *)arg;
		pspm = (pm_sp_misc_t *)bpn->bpn_private;

		if (!e_pm_valid_info(dip, NULL) ||
		    !e_pm_valid_comp(dip, bpn->bpn_comp, &cp) ||
		    !e_pm_valid_power(dip, bpn->bpn_comp, bpn->bpn_level)) {
			PMD(PMD_SET, ("%s: %s@%s(%s#%d) has no pm info; EIO\n",
			    pmf, PM_DEVICE(dip)))
			*pspm->pspm_errnop = EIO;
			*(int *)result = DDI_FAILURE;
			return (DDI_FAILURE);
		}

		ASSERT(bpn->bpn_dip == dip);
		PMD(PMD_SET, ("%s: nexus powerup for %s@%s(%s#%d)\n", pmf,
		    PM_DEVICE(dip)))
		new_bpc.bpc_dip = dip;
		pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
		new_bpc.bpc_path = ddi_pathname(dip, pathbuf);
		new_bpc.bpc_comp = bpn->bpn_comp;
		new_bpc.bpc_olevel = PM_CURPOWER(dip, bpn->bpn_comp);
		new_bpc.bpc_nlevel = bpn->bpn_level;
		new_bpc.bpc_private = bpn->bpn_private;
		((pm_sp_misc_t *)(new_bpc.bpc_private))->pspm_direction =
		    PM_LEVEL_UPONLY;
		((pm_sp_misc_t *)(new_bpc.bpc_private))->pspm_errnop =
		    &errno;
		ret = pm_busop_set_power(dip, impl_arg, BUS_POWER_CHILD_PWRCHG,
		    (void *)&new_bpc, result);
		kmem_free(pathbuf, MAXPATHLEN);
		return (ret);

	case BUS_POWER_NOINVOL:
		bpi = (pm_bp_noinvol_t *)arg;
		tdip = bpi->bpni_dip;
		cdip = pm_get_next_descendent(dip, tdip);

		/* In case of rem_drv, the leaf node has been removed */
		if (cdip == NULL)
			return (DDI_SUCCESS);

		cinfo = PM_GET_PM_INFO(cdip);
		if (cdip != tdip) {
			if (PM_WANTS_NOTIFICATION(cdip)) {
				PMD(PMD_NOINVOL,
				    ("%s: call bus_power for %s@%s(%s#%d)\n",
				    pmf, PM_DEVICE(cdip)))
				ret = (*PM_BUS_POWER_FUNC(cdip))
				    (cdip, NULL, op, arg, result);
				if ((cinfo) && (ret == DDI_SUCCESS))
					(void) pm_noinvol_update_node(cdip,
					    bpi);
				return (ret);
			} else {
				PMD(PMD_NOINVOL,
				    ("%s: walk down to %s@%s(%s#%d)\n", pmf,
				    PM_DEVICE(cdip)))
				ret = pm_busop_bus_power(cdip, NULL, op,
				    arg, result);
				/*
				 * Update the current node.
				 */
				if ((cinfo) && (ret == DDI_SUCCESS))
					(void) pm_noinvol_update_node(cdip,
					    bpi);
				return (ret);
			}
		} else {
			/*
			 * For attach, detach, power up:
			 * Do nothing for leaf node since its
			 * counts are already updated.
			 * For CFB and driver removal, since the
			 * path and the target dip passed in is up to and incl.
			 * the immediate ancestor, need to do the update.
			 */
			PMD(PMD_NOINVOL, ("%s: target %s@%s(%s#%d) is "
			    "reached\n", pmf, PM_DEVICE(cdip)))
			if (cinfo && ((bpi->bpni_cmd == PM_BP_NOINVOL_REMDRV) ||
			    (bpi->bpni_cmd == PM_BP_NOINVOL_CFB)))
				(void) pm_noinvol_update_node(cdip, bpi);
			return (DDI_SUCCESS);
		}

	default:
		PMD(PMD_SET, ("%s: operation %d is not supported!\n", pmf, op))
		return (DDI_FAILURE);
	}
}

static int
pm_busop_set_power(dev_info_t *dip, void *impl_arg, pm_bus_power_op_t op,
    void *arg, void *resultp)
{
	_NOTE(ARGUNUSED(impl_arg))
	PMD_FUNC(pmf, "bp_set_power")
	pm_ppm_devlist_t *devl = NULL;
	int clevel, circ;
#ifdef	DEBUG
	int circ_db, ccirc_db;
#endif
	int ret = DDI_SUCCESS;
	dev_info_t *cdip;
	pm_bp_child_pwrchg_t *bpc = (pm_bp_child_pwrchg_t *)arg;
	pm_sp_misc_t *pspm = (pm_sp_misc_t *)bpc->bpc_private;
	pm_canblock_t canblock = pspm->pspm_canblock;
	int scan = pspm->pspm_scan;
	int comp = bpc->bpc_comp;
	int olevel = bpc->bpc_olevel;
	int nlevel = bpc->bpc_nlevel;
	int comps_off_incr = 0;
	dev_info_t *pdip = ddi_get_parent(dip);
	int dodeps;
	int direction = pspm->pspm_direction;
	int *errnop = pspm->pspm_errnop;
#ifdef PMDDEBUG
	char *dir = pm_decode_direction(direction);
#endif
	int *iresp = (int *)resultp;
	time_t	idletime, thresh;
	pm_component_t *cp = PM_CP(dip, comp);
	int work_type;

	*iresp = DDI_SUCCESS;
	*errnop = 0;
	ASSERT(op == BUS_POWER_CHILD_PWRCHG);
	PMD(PMD_SET, ("%s: %s@%s(%s#%d) %s\n", pmf, PM_DEVICE(dip),
	    pm_decode_op(op)))

	/*
	 * The following set of conditions indicate we are here to handle a
	 * driver's pm_[raise|lower]_power request, but the device is being
	 * power managed (PM_DIRECT_PM) by a user process.  For that case
	 * we want to pm_block and pass a status back to the caller based
	 * on whether the controlling process's next activity on the device
	 * matches the current request or not.  This distinction tells
	 * downstream functions to avoid calling into a driver or changing
	 * the framework's power state.  To actually block, we need:
	 *
	 * PM_ISDIRECT(dip)
	 *	no reason to block unless a process is directly controlling dev
	 * direction != PM_LEVEL_EXACT
	 *	EXACT is used by controlling proc's PM_SET_CURRENT_POWER ioctl
	 * !pm_processes_stopped
	 *	don't block if controlling proc already be stopped for cpr
	 * canblock != PM_CANBLOCK_BYPASS
	 *	our caller must not have explicitly prevented blocking
	 */
	if (direction != PM_LEVEL_EXACT && canblock != PM_CANBLOCK_BYPASS) {
		PM_LOCK_DIP(dip);
		while (PM_ISDIRECT(dip) && !pm_processes_stopped) {
			/* releases dip lock */
			ret = pm_busop_match_request(dip, bpc);
			if (ret == EAGAIN) {
				PM_LOCK_DIP(dip);
				continue;
			}
			return (*iresp = ret);
		}
		PM_UNLOCK_DIP(dip);
	}
	/* BC device is never scanned, so power will stick until we are done */
	if (PM_ISBC(dip) && comp != 0 && nlevel != 0 &&
	    direction != PM_LEVEL_DOWNONLY) {
		int nrmpwr0 = pm_get_normal_power(dip, 0);
		if (pm_set_power(dip, 0, nrmpwr0, direction,
		    canblock, 0, resultp) != DDI_SUCCESS) {
			/* *resultp set by pm_set_power */
			return (DDI_FAILURE);
		}
	}
	if (PM_WANTS_NOTIFICATION(pdip)) {
		PMD(PMD_SET, ("%s: pre_notify %s@%s(%s#%d) for child "
		    "%s@%s(%s#%d)\n", pmf, PM_DEVICE(pdip), PM_DEVICE(dip)))
		ret = (*PM_BUS_POWER_FUNC(pdip))(pdip, NULL,
		    BUS_POWER_PRE_NOTIFICATION, bpc, resultp);
		if (ret != DDI_SUCCESS) {
			PMD(PMD_SET, ("%s: failed to pre_notify %s@%s(%s#%d)\n",
			    pmf, PM_DEVICE(pdip)))
			return (DDI_FAILURE);
		}
	} else {
		/*
		 * Since we don't know what the actual power level is,
		 * we place a power hold on the parent no matter what
		 * component and level is changing.
		 */
		pm_hold_power(pdip);
	}
	PM_LOCK_POWER(dip, &circ);
	clevel = PM_CURPOWER(dip, comp);
	/*
	 * It's possible that a call was made to pm_update_maxpower()
	 * on another thread before we took the lock above. So, we need to
	 * make sure that this request isn't processed after the
	 * change of power executed on behalf of pm_update_maxpower().
	 */
	if (nlevel > pm_get_normal_power(dip, comp)) {
		PMD(PMD_SET, ("%s: requested level is higher than normal.\n",
		    pmf))
		ret = DDI_FAILURE;
		*iresp = DDI_FAILURE;
		goto post_notify;
	}
	PMD(PMD_SET, ("%s: %s@%s(%s#%d), cmp=%d, olvl=%d, nlvl=%d, clvl=%d, "
	    "dir=%s\n", pmf, PM_DEVICE(dip), comp, bpc->bpc_olevel, nlevel,
	    clevel, dir))
	switch (direction) {
	case PM_LEVEL_UPONLY:
		/* Powering up */
		if (clevel >= nlevel) {
			PMD(PMD_SET, ("%s: current level is already "
			    "at or above the requested level.\n", pmf))
			*iresp = DDI_SUCCESS;
			ret = DDI_SUCCESS;
			goto post_notify;
		}
		break;
	case PM_LEVEL_EXACT:
		/* specific level request */
		if (clevel == nlevel && !PM_ISBC(dip)) {
			PMD(PMD_SET, ("%s: current level is already "
			    "at the requested level.\n", pmf))
			*iresp = DDI_SUCCESS;
			ret = DDI_SUCCESS;
			goto post_notify;
		} else if (PM_IS_CFB(dip) && (nlevel < clevel)) {
			PMD(PMD_CFB, ("%s: powerdown of console\n", pmf))
			if (!pm_cfb_enabled) {
				PMD(PMD_ERROR | PMD_CFB,
				    ("%s: !pm_cfb_enabled, fails\n", pmf))
				*errnop = EINVAL;
				*iresp = DDI_FAILURE;
				ret = DDI_FAILURE;
				goto post_notify;
			}
			mutex_enter(&pm_cfb_lock);
			while (cfb_inuse) {
				mutex_exit(&pm_cfb_lock);
				if (delay_sig(1) == EINTR) {
					ret = DDI_FAILURE;
					*iresp = DDI_FAILURE;
					*errnop = EINTR;
					goto post_notify;
				}
				mutex_enter(&pm_cfb_lock);
			}
			mutex_exit(&pm_cfb_lock);
		}
		break;
	case PM_LEVEL_DOWNONLY:
		/* Powering down */
		thresh = cur_threshold(dip, comp);
		idletime = gethrestime_sec() - cp->pmc_timestamp;
		if (scan && ((PM_KUC(dip) != 0) ||
		    (cp->pmc_busycount > 0) ||
		    ((idletime < thresh) && !PM_IS_PID(dip)))) {
#ifdef	DEBUG
			if (DEVI(dip)->devi_pm_kidsupcnt != 0)
				PMD(PMD_SET, ("%s: scan failed: "
				    "kidsupcnt != 0\n", pmf))
			if (cp->pmc_busycount > 0)
				PMD(PMD_SET, ("%s: scan failed: "
				    "device become busy\n", pmf))
			if (idletime < thresh)
				PMD(PMD_SET, ("%s: scan failed: device "
				    "hasn't been idle long enough\n", pmf))
#endif
			*iresp = DDI_FAILURE;
			*errnop = EBUSY;
			ret = DDI_FAILURE;
			goto post_notify;
		} else if (clevel != PM_LEVEL_UNKNOWN && clevel <= nlevel) {
			PMD(PMD_SET, ("%s: current level is already at "
			    "or below the requested level.\n", pmf))
			*iresp = DDI_SUCCESS;
			ret = DDI_SUCCESS;
			goto post_notify;
		}
		break;
	}

	if (PM_IS_CFB(dip) && (comps_off_incr =
	    calc_cfb_comps_incr(dip, comp, clevel, nlevel)) > 0) {
		/*
		 * Pre-adjust pm_cfb_comps_off if lowering a console fb
		 * component from full power.  Remember that we tried to
		 * lower power in case it fails and we need to back out
		 * the adjustment.
		 */
		update_comps_off(comps_off_incr, dip);
		PMD(PMD_CFB, ("%s: %s@%s(%s#%d)[%d] %d->%d cfb_comps_off->%d\n",
		    pmf, PM_DEVICE(dip), comp, clevel, nlevel,
		    pm_cfb_comps_off))
	}

	if ((*iresp = power_dev(dip,
	    comp, nlevel, clevel, canblock, &devl)) == DDI_SUCCESS) {
#ifdef DEBUG
		/*
		 * All descendents of this node should already be powered off.
		 */
		if (PM_CURPOWER(dip, comp) == 0) {
			pm_desc_pwrchk_t pdpchk;
			pdpchk.pdpc_dip = dip;
			pdpchk.pdpc_par_involved = PM_WANTS_NOTIFICATION(dip);
			ndi_devi_enter(dip, &circ_db);
			for (cdip = ddi_get_child(dip); cdip != NULL;
			    cdip = ddi_get_next_sibling(cdip)) {
				ndi_devi_enter(cdip, &ccirc_db);
				ddi_walk_devs(cdip, pm_desc_pwrchk_walk,
				    (void *)&pdpchk);
				ndi_devi_exit(cdip, ccirc_db);
			}
			ndi_devi_exit(dip, circ_db);
		}
#endif
		/*
		 * Post-adjust pm_cfb_comps_off if we brought an fb component
		 * back up to full power.
		 */
		if (PM_IS_CFB(dip) && comps_off_incr < 0) {
			update_comps_off(comps_off_incr, dip);
			PMD(PMD_CFB, ("%s: %s@%s(%s#%d)[%d] %d->%d "
			    "cfb_comps_off->%d\n", pmf, PM_DEVICE(dip),
			    comp, clevel, nlevel, pm_cfb_comps_off))
		}
		dodeps = 0;
		if (POWERING_OFF(clevel, nlevel)) {
			if (PM_ISBC(dip)) {
				dodeps = (comp == 0);
			} else {
				int i;
				dodeps = 1;
				for (i = 0; i < PM_NUMCMPTS(dip); i++) {
					/* if some component still on */
					if (PM_CURPOWER(dip, i)) {
						dodeps = 0;
						break;
					}
				}
			}
			if (dodeps)
				work_type = PM_DEP_WK_POWER_OFF;
		} else if (POWERING_ON(clevel, nlevel)) {
			if (PM_ISBC(dip)) {
				dodeps = (comp == 0);
			} else {
				int i;
				dodeps = 1;
				for (i = 0; i < PM_NUMCMPTS(dip); i++) {
					if (i == comp)
						continue;
					if (PM_CURPOWER(dip, i) > 0) {
						dodeps = 0;
						break;
					}
				}
			}
			if (dodeps)
				work_type = PM_DEP_WK_POWER_ON;
		}

		if (dodeps) {
			char *pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);

			(void) ddi_pathname(dip, pathbuf);
			pm_dispatch_to_dep_thread(work_type, pathbuf, NULL,
			    PM_DEP_NOWAIT, NULL, 0);
			kmem_free(pathbuf, MAXPATHLEN);
		}
		if ((PM_CURPOWER(dip, comp) == nlevel) && pm_watchers()) {
			int old;

			/* If old power cached during deadlock, use it. */
			old = (cp->pmc_flags & PM_PHC_WHILE_SET_POWER ?
			    cp->pmc_phc_pwr : olevel);
			mutex_enter(&pm_rsvp_lock);
			pm_enqueue_notify(PSC_HAS_CHANGED, dip, comp, nlevel,
			    old, canblock);
			pm_enqueue_notify_others(&devl, canblock);
			mutex_exit(&pm_rsvp_lock);
		} else {
			pm_ppm_devlist_t *p;
			pm_ppm_devlist_t *next;
			for (p = devl; p != NULL; p = next) {
				next = p->ppd_next;
				kmem_free(p, sizeof (pm_ppm_devlist_t));
			}
			devl = NULL;
		}

		/*
		 * If we are coming from a scan, don't do it again,
		 * else we can have infinite loops.
		 */
		if (!scan)
			pm_rescan(dip);
	} else {
		/* if we incremented pm_comps_off_count, but failed */
		if (comps_off_incr > 0) {
			update_comps_off(-comps_off_incr, dip);
			PMD(PMD_CFB, ("%s: %s@%s(%s#%d)[%d] %d->%d "
			    "cfb_comps_off->%d\n", pmf, PM_DEVICE(dip),
			    comp, clevel, nlevel, pm_cfb_comps_off))
		}
		*errnop = EIO;
	}

post_notify:
	/*
	 * This thread may have been in deadlock with pm_power_has_changed.
	 * Before releasing power lock, clear the flag which marks this
	 * condition.
	 */
	cp->pmc_flags &= ~PM_PHC_WHILE_SET_POWER;

	/*
	 * Update the old power level in the bus power structure with the
	 * actual power level before the transition was made to the new level.
	 * Some involved parents depend on this information to keep track of
	 * their children's power transition.
	 */
	if (*iresp != DDI_FAILURE)
		bpc->bpc_olevel = clevel;

	if (PM_WANTS_NOTIFICATION(pdip)) {
		ret = (*PM_BUS_POWER_FUNC(pdip))(pdip, NULL,
		    BUS_POWER_POST_NOTIFICATION, bpc, resultp);
		PM_UNLOCK_POWER(dip, circ);
		PMD(PMD_SET, ("%s: post_notify %s@%s(%s#%d) for "
		    "child %s@%s(%s#%d), ret=%d\n", pmf, PM_DEVICE(pdip),
		    PM_DEVICE(dip), ret))
	} else {
		nlevel = cur_power(cp); /* in case phc deadlock updated pwr */
		PM_UNLOCK_POWER(dip, circ);
		/*
		 * Now that we know what power transition has occurred
		 * (if any), release the power hold.  Leave the hold
		 * in effect in the case of OFF->ON transition.
		 */
		if (!(clevel == 0 && nlevel > 0 &&
		    (!PM_ISBC(dip) || comp == 0)))
			pm_rele_power(pdip);
		/*
		 * If the power transition was an ON->OFF transition,
		 * remove the power hold from the parent.
		 */
		if ((clevel > 0 || clevel == PM_LEVEL_UNKNOWN) &&
		    nlevel == 0 && (!PM_ISBC(dip) || comp == 0))
			pm_rele_power(pdip);
	}
	if (*iresp != DDI_SUCCESS || ret != DDI_SUCCESS)
		return (DDI_FAILURE);
	else
		return (DDI_SUCCESS);
}

/*
 * If an app (SunVTS or Xsun) has taken control, then block until it
 * gives it up or makes the requested power level change, unless
 * we have other instructions about blocking.  Returns DDI_SUCCESS,
 * DDI_FAILURE or EAGAIN (owner released device from directpm).
 */
static int
pm_busop_match_request(dev_info_t *dip, void *arg)
{
	PMD_FUNC(pmf, "bp_match_request")
	pm_bp_child_pwrchg_t *bpc = (pm_bp_child_pwrchg_t *)arg;
	pm_sp_misc_t *pspm = (pm_sp_misc_t *)bpc->bpc_private;
	int comp = bpc->bpc_comp;
	int nlevel = bpc->bpc_nlevel;
	pm_canblock_t canblock = pspm->pspm_canblock;
	int direction = pspm->pspm_direction;
	int clevel, circ;

	ASSERT(PM_IAM_LOCKING_DIP(dip));
	PM_LOCK_POWER(dip, &circ);
	clevel = PM_CURPOWER(dip, comp);
	PMD(PMD_SET, ("%s: %s@%s(%s#%d), cmp=%d, nlvl=%d, clvl=%d\n",
	    pmf, PM_DEVICE(dip), comp, nlevel, clevel))
	if (direction == PM_LEVEL_UPONLY) {
		if (clevel >= nlevel) {
			PM_UNLOCK_POWER(dip, circ);
			PM_UNLOCK_DIP(dip);
			return (DDI_SUCCESS);
		}
	} else if (clevel == nlevel) {
		PM_UNLOCK_POWER(dip, circ);
		PM_UNLOCK_DIP(dip);
		return (DDI_SUCCESS);
	}
	if (canblock == PM_CANBLOCK_FAIL) {
		PM_UNLOCK_POWER(dip, circ);
		PM_UNLOCK_DIP(dip);
		return (DDI_FAILURE);
	}
	if (canblock == PM_CANBLOCK_BLOCK) {
		/*
		 * To avoid a deadlock, we must not hold the
		 * power lock when we pm_block.
		 */
		PM_UNLOCK_POWER(dip, circ);
		PMD(PMD_SET, ("%s: blocking\n", pmf))
		/* pm_block releases dip lock */
		switch (pm_block(dip, comp, nlevel, clevel)) {
		case PMP_RELEASE:
			return (EAGAIN);
		case PMP_SUCCEED:
			return (DDI_SUCCESS);
		case PMP_FAIL:
			return (DDI_FAILURE);
		}
	} else {
		ASSERT(0);
	}
	_NOTE(NOTREACHED);
	return (DDI_FAILURE);	/* keep gcc happy */
}

static int
pm_all_to_normal_nexus(dev_info_t *dip, pm_canblock_t canblock)
{
	PMD_FUNC(pmf, "all_to_normal_nexus")
	int		*normal;
	int		i, ncomps;
	size_t		size;
	int		changefailed = 0;
	int		ret, result = DDI_SUCCESS;
	pm_bp_nexus_pwrup_t	bpn;
	pm_sp_misc_t	pspm;

	ASSERT(PM_GET_PM_INFO(dip));
	PMD(PMD_ALLNORM, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	if (pm_get_norm_pwrs(dip, &normal, &size) != DDI_SUCCESS) {
		PMD(PMD_ALLNORM, ("%s: can't get norm pwrs\n", pmf))
		return (DDI_FAILURE);
	}
	ncomps = PM_NUMCMPTS(dip);
	for (i = 0; i < ncomps; i++) {
		bpn.bpn_dip = dip;
		bpn.bpn_comp = i;
		bpn.bpn_level = normal[i];
		pspm.pspm_canblock = canblock;
		pspm.pspm_scan = 0;
		bpn.bpn_private = &pspm;
		ret = pm_busop_bus_power(dip, NULL, BUS_POWER_NEXUS_PWRUP,
		    (void *)&bpn, (void *)&result);
		if (ret != DDI_SUCCESS || result != DDI_SUCCESS) {
			PMD(PMD_FAIL | PMD_ALLNORM, ("%s: %s@%s(%s#%d)[%d] "
			    "->%d failure result %d\n", pmf, PM_DEVICE(dip),
			    i, normal[i], result))
			changefailed++;
		}
	}
	kmem_free(normal, size);
	if (changefailed) {
		PMD(PMD_FAIL, ("%s: failed to set %d comps %s@%s(%s#%d) "
		    "full power\n", pmf, changefailed, PM_DEVICE(dip)))
		return (DDI_FAILURE);
	}
	return (DDI_SUCCESS);
}

int
pm_noinvol_update(int subcmd, int volpmd, int wasvolpmd, char *path,
    dev_info_t *tdip)
{
	PMD_FUNC(pmf, "noinvol_update")
	pm_bp_noinvol_t args;
	int ret;
	int result = DDI_SUCCESS;

	args.bpni_path = path;
	args.bpni_dip = tdip;
	args.bpni_cmd = subcmd;
	args.bpni_wasvolpmd = wasvolpmd;
	args.bpni_volpmd = volpmd;
	PMD(PMD_NOINVOL, ("%s: update for path %s tdip %p subcmd %d "
	    "volpmd %d wasvolpmd %d\n", pmf,
	    path, (void *)tdip, subcmd, wasvolpmd, volpmd))
	ret = pm_busop_bus_power(ddi_root_node(), NULL, BUS_POWER_NOINVOL,
	    &args, &result);
	return (ret);
}

void
pm_noinvol_update_node(dev_info_t *dip, pm_bp_noinvol_t *req)
{
	PMD_FUNC(pmf, "noinvol_update_node")

	PMD(PMD_NOINVOL, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	switch (req->bpni_cmd) {
	case PM_BP_NOINVOL_ATTACH:
		PMD(PMD_NOINVOL, ("%s: PM_PB_NOINVOL_ATTACH %s@%s(%s#%d) "
		    "noinvol %d->%d\n", pmf, PM_DEVICE(dip),
		    DEVI(dip)->devi_pm_noinvolpm,
		    DEVI(dip)->devi_pm_noinvolpm - 1))
		ASSERT(DEVI(dip)->devi_pm_noinvolpm);
		PM_LOCK_DIP(dip);
		DEVI(dip)->devi_pm_noinvolpm--;
		if (req->bpni_wasvolpmd) {
			PMD(PMD_NOINVOL, ("%s: PM_BP_NOINVOL_ATTACH "
			    "%s@%s(%s#%d) volpmd %d->%d\n", pmf,
			    PM_DEVICE(dip), DEVI(dip)->devi_pm_volpmd,
			    DEVI(dip)->devi_pm_volpmd - 1))
			if (DEVI(dip)->devi_pm_volpmd)
				DEVI(dip)->devi_pm_volpmd--;
		}
		PM_UNLOCK_DIP(dip);
		break;

	case PM_BP_NOINVOL_DETACH:
		PMD(PMD_NOINVOL, ("%s: PM_BP_NOINVOL_DETACH %s@%s(%s#%d) "
		    "noinvolpm %d->%d\n", pmf, PM_DEVICE(dip),
		    DEVI(dip)->devi_pm_noinvolpm,
		    DEVI(dip)->devi_pm_noinvolpm + 1))
		PM_LOCK_DIP(dip);
		DEVI(dip)->devi_pm_noinvolpm++;
		if (req->bpni_wasvolpmd) {
			PMD(PMD_NOINVOL, ("%s: PM_BP_NOINVOL_DETACH "
			    "%s@%s(%s#%d) volpmd %d->%d\n", pmf,
			    PM_DEVICE(dip), DEVI(dip)->devi_pm_volpmd,
			    DEVI(dip)->devi_pm_volpmd + 1))
			DEVI(dip)->devi_pm_volpmd++;
		}
		PM_UNLOCK_DIP(dip);
		break;

	case PM_BP_NOINVOL_REMDRV:
		PMD(PMD_NOINVOL, ("%s: PM_BP_NOINVOL_REMDRV %s@%s(%s#%d) "
		    "noinvol %d->%d\n", pmf, PM_DEVICE(dip),
		    DEVI(dip)->devi_pm_noinvolpm,
		    DEVI(dip)->devi_pm_noinvolpm - 1))
		ASSERT(DEVI(dip)->devi_pm_noinvolpm);
		PM_LOCK_DIP(dip);
		DEVI(dip)->devi_pm_noinvolpm--;
		if (req->bpni_wasvolpmd) {
			PMD(PMD_NOINVOL,
			    ("%s: PM_BP_NOINVOL_REMDRV %s@%s(%s#%d) "
			    "volpmd %d->%d\n", pmf, PM_DEVICE(dip),
			    DEVI(dip)->devi_pm_volpmd,
			    DEVI(dip)->devi_pm_volpmd - 1))
			/*
			 * A power up could come in between and
			 * clear the volpmd, if that's the case,
			 * volpmd would be clear.
			 */
			if (DEVI(dip)->devi_pm_volpmd)
				DEVI(dip)->devi_pm_volpmd--;
		}
		PM_UNLOCK_DIP(dip);
		break;

	case PM_BP_NOINVOL_CFB:
		PMD(PMD_NOINVOL,
		    ("%s: PM_BP_NOIVOL_CFB %s@%s(%s#%d) noinvol %d->%d\n",
		    pmf, PM_DEVICE(dip), DEVI(dip)->devi_pm_noinvolpm,
		    DEVI(dip)->devi_pm_noinvolpm + 1))
		PM_LOCK_DIP(dip);
		DEVI(dip)->devi_pm_noinvolpm++;
		PM_UNLOCK_DIP(dip);
		break;

	case PM_BP_NOINVOL_POWER:
		PMD(PMD_NOINVOL,
		    ("%s: PM_BP_NOIVOL_PWR %s@%s(%s#%d) volpmd %d->%d\n",
		    pmf, PM_DEVICE(dip),
		    DEVI(dip)->devi_pm_volpmd, DEVI(dip)->devi_pm_volpmd -
		    req->bpni_volpmd))
		PM_LOCK_DIP(dip);
		DEVI(dip)->devi_pm_volpmd -= req->bpni_volpmd;
		PM_UNLOCK_DIP(dip);
		break;

	default:
		break;
	}

}

#ifdef DEBUG
static int
pm_desc_pwrchk_walk(dev_info_t *dip, void *arg)
{
	PMD_FUNC(pmf, "desc_pwrchk")
	pm_desc_pwrchk_t *pdpchk = (pm_desc_pwrchk_t *)arg;
	pm_info_t *info = PM_GET_PM_INFO(dip);
	int i;
	/* LINTED */
	int curpwr, ce_level;

	if (!info)
		return (DDI_WALK_CONTINUE);

	PMD(PMD_SET, ("%s: %s@%s(%s#%d)\n", pmf, PM_DEVICE(dip)))
	for (i = 0; i < PM_NUMCMPTS(dip); i++) {
		/* LINTED */
		if ((curpwr = PM_CURPOWER(dip, i)) == 0)
			continue;
		/* E_FUNC_SET_NOT_USED */
		ce_level = (pdpchk->pdpc_par_involved == 0) ? CE_PANIC :
		    CE_WARN;
		PMD(PMD_SET, ("%s: %s@%s(%s#%d) is powered off while desc "
		    "%s@%s(%s#%d)[%d] is at %d\n", pmf,
		    PM_DEVICE(pdpchk->pdpc_dip), PM_DEVICE(dip), i, curpwr))
		cmn_err(ce_level, "!device %s@%s(%s#%d) is powered on, "
		    "while its ancestor, %s@%s(%s#%d), is powering off!",
		    PM_DEVICE(dip), PM_DEVICE(pdpchk->pdpc_dip));
	}
	return (DDI_WALK_CONTINUE);
}
#endif

/*
 * Record the fact that one thread is borrowing the lock on a device node.
 * Use is restricted to the case where the lending thread will block until
 * the borrowing thread (always curthread) completes.
 */
void
pm_borrow_lock(kthread_t *lender)
{
	lock_loan_t *prev = &lock_loan_head;
	lock_loan_t *cur = (lock_loan_t *)kmem_zalloc(sizeof (*cur), KM_SLEEP);

	cur->pmlk_borrower = curthread;
	cur->pmlk_lender = lender;
	mutex_enter(&pm_loan_lock);
	cur->pmlk_next = prev->pmlk_next;
	prev->pmlk_next = cur;
	mutex_exit(&pm_loan_lock);
}

/*
 * Return the borrowed lock.  A thread can borrow only one.
 */
void
pm_return_lock(void)
{
	lock_loan_t *cur;
	lock_loan_t *prev = &lock_loan_head;

	mutex_enter(&pm_loan_lock);
	ASSERT(prev->pmlk_next != NULL);
	for (cur = prev->pmlk_next; cur; prev = cur, cur = cur->pmlk_next)
		if (cur->pmlk_borrower == curthread)
			break;

	ASSERT(cur != NULL);
	prev->pmlk_next = cur->pmlk_next;
	mutex_exit(&pm_loan_lock);
	kmem_free(cur, sizeof (*cur));
}

#if defined(__x86)

#define	CPR_RXR	0x1
#define	CPR_TXR	0x20
#define	CPR_DATAREG	0x3f8
#define	CPR_LSTAT	0x3fd
#define	CPR_INTRCTL	0x3f9

char
pm_getchar(void)
{
	while ((inb(CPR_LSTAT) & CPR_RXR) != CPR_RXR)
		drv_usecwait(10);

	return (inb(CPR_DATAREG));

}

void
pm_putchar(char c)
{
	while ((inb(CPR_LSTAT) & CPR_TXR) == 0)
		drv_usecwait(10);

	outb(CPR_DATAREG, c);
}

void
pm_printf(char *s)
{
	while (*s) {
		pm_putchar(*s++);
	}
}

#endif

int
pm_ppm_searchlist(pm_searchargs_t *sp)
{
	power_req_t power_req;
	int result = 0;
	/* LINTED */
	int ret;

	power_req.request_type = PMR_PPM_SEARCH_LIST;
	power_req.req.ppm_search_list_req.searchlist = sp;
	ASSERT(DEVI(ddi_root_node())->devi_pm_ppm);
	ret = pm_ctlops((dev_info_t *)DEVI(ddi_root_node())->devi_pm_ppm,
	    ddi_root_node(), DDI_CTLOPS_POWER, &power_req, &result);
	PMD(PMD_SX, ("pm_ppm_searchlist returns %d, result %d\n",
	    ret, result))
	return (result);
}