excalibur/io/xcalppm.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Platform Power Management driver for SUNW,Sun-Blade-1000
 */
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ppmvar.h>
#include <sys/ppmio.h>
#include <sys/xcalppm_reg.h>
#include <sys/xcalppm_var.h>
#include <sys/stat.h>
#include <sys/epm.h>
#include <sys/archsystm.h>
#include <sys/cpuvar.h>
#include <sys/cheetahregs.h>
#include <sys/us3_module.h>

/*
 * Locking Considerations
 *
 * To look at and/or modify xcppm_domain fields or elements of its list of
 * xcppm_dev structures the domain_lock for the affected domain must be held.
 *
 * When the autopm framework needs to change the power of a component of a
 * device, it needs to hold the associated power lock (see discussion at
 * top of uts/common/os/sunpm.c).
 *
 * If the framework needs to lock a dev/cmpt for a device which this ppm
 * has claimed, xcppm_ctlops will be called with PMR_PPM_LOCK_POWER.  Ppm
 * needs to be involved because, due to platform constraints, changing the
 * power of one device may require that other devices be changed in the same
 * operation.
 *
 * In some domains (e.g., cpus) the power lock must be acquired for all the
 * affected devices to avoid possible corruption of the power states.  The
 * joint change must be an atomic operation.  Ppm handles this by acquiring
 * the domain lock, then walking the list of affected devices and acquiring
 * the power lock for each of them.  To unlock, the list is traversed and
 * each of the power locks is freed, followed by freeing the domain lock.
 *
 * For other domains ppm will only be changing the power of a single device
 * that is known to the framework.  In these cases, the locking is done by
 * acquiring the domain lock and directly calling the framework routine for
 * getting a single power lock.
 */

static int	xcppm_attach(dev_info_t *, ddi_attach_cmd_t);
static int	xcppm_detach(dev_info_t *, ddi_detach_cmd_t);
static int	xcppm_ctlops(dev_info_t *, dev_info_t *,
		    ddi_ctl_enum_t, void *, void *);
static void	xcppm_dev_init(ppm_dev_t *);
static void	xcppm_dev_fini(ppm_dev_t *);
static void	xcppm_iocset(uint8_t);
static uint8_t	xcppm_iocget(void);

/*
 * Note: 1394 and pciupa were originally required to be LOCK_ALL domains.
 * However, the underlying nexus drivers aren't able to do power mgmt
 * (because of hw implementation issues).  The locking protocol for these
 * domains is changed to LOCK_ONE to simplify other code.  The domain
 * code itself will be removed in the future.
 */
static ppm_domain_t xcppm_1394 = { "domain_1394",	PPMD_LOCK_ONE };
static ppm_domain_t xcppm_cpu  = { "domain_cpu",	PPMD_LOCK_ALL };
static ppm_domain_t xcppm_fet  = { "domain_powerfet",	PPMD_LOCK_ONE };
static ppm_domain_t xcppm_upa  = { "domain_pciupa",	PPMD_LOCK_ONE };

ppm_domain_t *ppm_domains[] = {
	&xcppm_1394,
	&xcppm_cpu,
	&xcppm_fet,
	&xcppm_upa,
	NULL
};


struct ppm_funcs ppmf = {
	xcppm_dev_init,			/* dev_init */
	xcppm_dev_fini,			/* dev_fini */
	xcppm_iocset,			/* iocset */
	xcppm_iocget,			/* iocget */
};


/*
 * The order of entries must be from slowest to fastest and in
 * one-to-one correspondence with the cpu_level array.
 */
static const uint16_t bbc_estar_control_masks[] = {
	BBC_ESTAR_SLOW, BBC_ESTAR_MEDIUM, BBC_ESTAR_FAST
};

int bbc_delay = 10;			/* microsec */


/*
 * Configuration data structures
 */
static struct cb_ops xcppm_cb_ops = {
	ppm_open,		/* open */
	ppm_close,		/* close */
	nodev,			/* strategy */
	nodev,			/* print */
	nodev,			/* dump */
	nodev,			/* read */
	nodev,			/* write */
	ppm_ioctl,		/* ioctl */
	nodev,			/* devmap */
	nodev,			/* mmap */
	nodev,			/* segmap */
	nochpoll,		/* poll */
	ddi_prop_op,		/* prop_op */
	NULL,			/* streamtab */
	D_MP | D_NEW,		/* driver compatibility flag */
	CB_REV,			/* cb_ops revision */
	nodev,			/* async read */
	nodev			/* async write */
};

static struct bus_ops xcppm_bus_ops = {
	BUSO_REV,
	0,
	0,
	0,
	0,
	0,
	ddi_no_dma_map,
	ddi_no_dma_allochdl,
	ddi_no_dma_freehdl,
	ddi_no_dma_bindhdl,
	ddi_no_dma_unbindhdl,
	ddi_no_dma_flush,
	ddi_no_dma_win,
	ddi_no_dma_mctl,
	xcppm_ctlops,
	0,
	0,			/* (*bus_get_eventcookie)();	*/
	0,			/* (*bus_add_eventcall)();	*/
	0,			/* (*bus_remove_eventcall)();	*/
	0			/* (*bus_post_event)();		*/
};

static struct dev_ops xcppm_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* refcnt */
	ppm_getinfo,		/* info */
	nulldev,		/* identify */
	nulldev,		/* probe */
	xcppm_attach,		/* attach */
	xcppm_detach,		/* detach */
	nodev,			/* reset */
	&xcppm_cb_ops,		/* driver operations */
	&xcppm_bus_ops,		/* bus operations */
	NULL,			/* power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
	&mod_driverops,		/* type of module - pseudo */
	"platform pm driver",
	&xcppm_ops
};

static struct modlinkage modlinkage = {
	MODREV_1,
	&modldrv,
	NULL
};


int
_init(void)
{
	return (ppm_init(&modlinkage, sizeof (xcppm_unit_t), "xc"));
}


int
_fini(void)
{
	return (EBUSY);
}


int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}


static int
xcppm_map_all_regs(dev_info_t *dip)
{
	ddi_device_acc_attr_t attr_be, attr_le;
	int rv0, rv1, rv2, rv3;
	xcppm_unit_t *unitp;
	caddr_t base_addr;
	uint8_t data8;

	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	attr_be.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr_be.devacc_attr_endian_flags  = DDI_STRUCTURE_BE_ACC;
	attr_be.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

	attr_le.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr_le.devacc_attr_endian_flags  = DDI_STRUCTURE_LE_ACC;
	attr_le.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

	rv0 = ddi_regs_map_setup(dip, 0, &base_addr, 0, 0, &attr_be,
	    &unitp->hndls.bbc_estar_ctrl);

	unitp->regs.bbc_estar_ctrl = (uint16_t *)(base_addr +
	    BBC_ESTAR_CTRL_OFFSET);
	unitp->regs.bbc_assert_change = (uint32_t *)(base_addr +
	    BBC_ASSERT_CHANGE_OFFSET);
	unitp->regs.bbc_pll_settle = (uint32_t *)(base_addr +
	    BBC_PLL_SETTLE_OFFSET);

	rv1 = ddi_regs_map_setup(dip, 1,
	    (caddr_t *)&unitp->regs.rio_mode_auxio,
	    0, 0, &attr_le, &unitp->hndls.rio_mode_auxio);

	rv2 = ddi_regs_map_setup(dip, 2, &base_addr,
	    0, 0, &attr_le, &unitp->hndls.gpio_bank_select);

	unitp->regs.gpio_bank_sel_index = (uint8_t *)(base_addr +
	    GPIO_BANK_SEL_INDEX_OFFSET);
	unitp->regs.gpio_bank_sel_data = (uint8_t *)(base_addr +
	    GPIO_BANK_SEL_DATA_OFFSET);

	rv3 = ddi_regs_map_setup(dip, 3, &base_addr, 0, 0, &attr_le,
	    &unitp->hndls.gpio_data_ports);

	unitp->regs.gpio_port1_data = (uint8_t *)(base_addr +
	    GPIO_PORT1_DATA_OFFSET);
	unitp->regs.gpio_port2_data = (uint8_t *)(base_addr +
	    GPIO_PORT2_DATA_OFFSET);

	if (rv0 != DDI_SUCCESS || rv1 != DDI_SUCCESS ||
	    rv2 != DDI_SUCCESS || rv3 != DDI_SUCCESS) {
		if (rv0 == DDI_SUCCESS)
			ddi_regs_map_free(&unitp->hndls.bbc_estar_ctrl);
		if (rv1 == DDI_SUCCESS)
			ddi_regs_map_free(&unitp->hndls.rio_mode_auxio);
		if (rv2 == DDI_SUCCESS)
			ddi_regs_map_free(&unitp->hndls.gpio_bank_select);
		if (rv3 == DDI_SUCCESS)
			ddi_regs_map_free(&unitp->hndls.gpio_data_ports);
		return (DDI_FAILURE);
	}

	/*
	 * Ppm uses GPIO bits in Bank 0.  Make sure Bank 0 is selected.
	 */
	data8 = SIO_CONFIG2_INDEX;
	XCPPM_SETGET8(unitp->hndls.gpio_bank_select,
	    unitp->regs.gpio_bank_sel_index, data8);
	data8 = XCPPM_GET8(unitp->hndls.gpio_bank_select,
	    unitp->regs.gpio_bank_sel_data);

	data8 &= 0x7f;	/* Set Bit7 to zero */
	XCPPM_SETGET8(unitp->hndls.gpio_bank_select,
	    unitp->regs.gpio_bank_sel_data, data8);

	return (DDI_SUCCESS);
}


static int
xcppm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
#ifdef DEBUG
	char *str = "xcppm_attach";
#endif
	xcppm_unit_t *unitp;
	ppm_domain_t **dompp;
	int retval;

	DPRINTF(D_ATTACH, ("%s: attach cmd %d\n", str, cmd));
	retval = DDI_SUCCESS;

	switch (cmd) {
	case DDI_ATTACH:
		if (ppm_inst != -1) {
			DPRINTF(D_ERROR,
			    ("%s: instance already attached\n", str));
			return (DDI_FAILURE);
		}
		ppm_inst = ddi_get_instance(dip);

		/*
		 * Allocate and initialize soft state structure
		 */
		if (ddi_soft_state_zalloc(ppm_statep, ppm_inst) != 0)
			return (DDI_FAILURE);
		unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
		mutex_init(&unitp->unit_lock, NULL, MUTEX_DRIVER, NULL);
		mutex_init(&unitp->creator_lock, NULL, MUTEX_DRIVER, NULL);

		if (ddi_create_minor_node(dip, "ppm", S_IFCHR,
		    ppm_inst, "ddi_ppm", 0) == DDI_FAILURE) {
			ddi_soft_state_free(ppm_statep, ppm_inst);
			DPRINTF(D_ERROR,
			    ("%s: Can't create minor for 0x%p\n", str,
			    (void *)dip));
			return (DDI_FAILURE);
		}
		ddi_report_dev(dip);
		unitp->dip = dip;

		if (retval = ppm_create_db(dip))
			return (retval);

		/*
		 * Map all of the registers under the ppm node.
		 */
		if (xcppm_map_all_regs(dip) != DDI_SUCCESS)
			return (DDI_FAILURE);

		if ((retval =
		    pm_register_ppm(ppm_claim_dev, dip)) != DDI_SUCCESS) {
			DPRINTF(D_ERROR,
			    ("%s: can't register ppm handler\n", str));
			return (retval);
		}

		for (dompp = ppm_domains; *dompp; dompp++)
			mutex_init(&(*dompp)->lock, NULL, MUTEX_DRIVER, NULL);

		break;

	case DDI_RESUME:
		unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
		mutex_enter(&unitp->unit_lock);
		unitp->state &= ~XCPPM_ST_SUSPENDED;
		mutex_exit(&unitp->unit_lock);
		break;

	default:
		cmn_err(CE_CONT, "xcppm_attach: unknown "
		    "attach command %d, dip 0x%p\n", cmd, (void *)dip);
		retval = DDI_FAILURE;
	}

	return (retval);
}


/*
 * set the front panel LED:
 * PPM_LEDON turns it on, PPM_LEDOFF turns it off.
 * for GPIO register: 0x0 means led-on, 0x2 means led-off.
 */
static void
xcppm_set_led(int action)
{
	xcppm_unit_t *unitp;
	uint8_t	reg;

	ASSERT(action == PPM_LEDON || action == PPM_LEDOFF);
	DPRINTF(D_LED, ("xcppm_set_led: Turn LED %s\n",
	    (action == PPM_LEDON) ? "on" : "off"));

	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	reg = XCPPM_GET8(unitp->hndls.gpio_data_ports,
	    unitp->regs.gpio_port1_data);
	if (action == PPM_LEDON)
		reg &= ~LED;
	else
		reg |= LED;
	XCPPM_SETGET8(unitp->hndls.gpio_data_ports,
	    unitp->regs.gpio_port1_data, reg);
}


static void
xcppm_blink_led(void *action)
{
	xcppm_unit_t *unitp;
	int new_action;
	clock_t intvl;

	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	mutex_enter(&unitp->unit_lock);
	if (unitp->led_tid == 0) {
		mutex_exit(&unitp->unit_lock);
		return;
	}

	if ((int)(uintptr_t)action == PPM_LEDON) {
		new_action = PPM_LEDOFF;
		intvl = PPM_LEDOFF_INTERVAL;
	} else {
		ASSERT((int)(uintptr_t)action == PPM_LEDOFF);
		new_action = PPM_LEDON;
		intvl = PPM_LEDON_INTERVAL;
	}

	xcppm_set_led(new_action);
	unitp->led_tid = timeout(xcppm_blink_led, (void *)(uintptr_t)new_action,
	    intvl);
	mutex_exit(&unitp->unit_lock);
}


static void
xcppm_freeze_led(void *action)
{
	xcppm_unit_t *unitp;
	timeout_id_t tid;

	DPRINTF(D_LOWEST, ("xcppm_freeze_led: action %d\n",
	    (int)(uintptr_t)action));
	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	mutex_enter(&unitp->unit_lock);
	tid = unitp->led_tid;
	unitp->led_tid = 0;
	mutex_exit(&unitp->unit_lock);
	(void) untimeout(tid);
	mutex_enter(&unitp->unit_lock);
	xcppm_set_led((int)(uintptr_t)action);
	mutex_exit(&unitp->unit_lock);
}


/* ARGSUSED */
static int
xcppm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	xcppm_unit_t *unitp;

	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	DPRINTF(D_DETACH, ("xcppm_detach: cmd %d\n", cmd));

	switch (cmd) {
	case DDI_DETACH:
		return (DDI_FAILURE);

	case DDI_SUSPEND:
		mutex_enter(&unitp->unit_lock);
		unitp->state |= XCPPM_ST_SUSPENDED;
		mutex_exit(&unitp->unit_lock);

		/*
		 * Suspend requires that timeout callouts to be canceled.
		 * Turning off the LED blinking will cancel the timeout.
		 */
		xcppm_freeze_led((void *)PPM_LEDON);
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}


/*
 * Device we claimed has detached.  We must get rid of
 * our state which was used to track this device.
 */
static void
xcppm_detach_ctlop(dev_info_t *dip, power_req_t *reqp)
{
	ppm_dev_t *ppmd;

	ppmd = PPM_GET_PRIVATE(dip);
	if (ppmd == NULL || reqp->req.ppm_config_req.result != DDI_SUCCESS)
		return;

	ppm_rem_dev(dip);
}


/*
 * The system is being resumed from a cpr suspend operation and this
 * device's attach entry will be called shortly.  The driver will set
 * the device's power to a conventional starting value, and we need to
 * stay in sync and set our private copy to the same value.
 */
/* ARGSUSED */
static void
xcppm_resume_ctlop(dev_info_t *dip, power_req_t *reqp)
{
	ppm_domain_t *domp;
	ppm_dev_t *ppmd;
	int powered;

	ppmd = PPM_GET_PRIVATE(dip);
	if (ppmd == NULL)
		return;

	/*
	 * Maintain correct powered count for domain which cares
	 */
	powered = 0;
	domp = ppmd->domp;
	mutex_enter(&domp->lock);
	if (domp == &xcppm_fet) {
		for (ppmd = domp->devlist; ppmd; ppmd = ppmd->next) {
			if (ppmd->dip == dip && ppmd->level)
				powered++;
		}

		/*
		 * If this device was powered off when the system was
		 * suspended, this resume acts like a power-on transition,
		 * so we adjust the count.
		 */
		if (powered == 0)
			domp->pwr_cnt++;
	}

	for (ppmd = domp->devlist; ppmd; ppmd = ppmd->next) {
		if (ppmd->dip == dip)
			ppmd->level = ppmd->rplvl = PM_LEVEL_UNKNOWN;
	}
	mutex_exit(&domp->lock);
}


/*
 * Change the power level for a component of a device.  If the change
 * arg is true, we call the framework to actually change the device's
 * power; otherwise, we just update our own copy of the power level.
 */
static int
xcppm_set_level(ppm_dev_t *ppmd, int cmpt, int level, boolean_t change)
{
#ifdef DEBUG
	char *str = "xcppm_set_level";
#endif
	int ret;

	ret = DDI_SUCCESS;
	if (change)
		ret = pm_power(ppmd->dip, cmpt, level);

	DPRINTF(D_SETLVL, ("%s: \"%s\" change=%d, old %d, new %d, ret %d\n",
	    str, ppmd->path, change, ppmd->level, level, ret));

	if (ret == DDI_SUCCESS) {
		ppmd->level = level;
		ppmd->rplvl = PM_LEVEL_UNKNOWN;
	}

	return (ret);
}


static int
xcppm_change_power_level(ppm_dev_t *ppmd, int cmpt, int level)
{
	return (xcppm_set_level(ppmd, cmpt, level, B_TRUE));
}


static int
xcppm_record_level_change(ppm_dev_t *ppmd, int cmpt, int level)
{
	return (xcppm_set_level(ppmd, cmpt, level, B_FALSE));
}


static uint8_t
xcppm_gpio_port2(int action, uint8_t pos)
{
#ifdef DEBUG
	char *str = "xcppm_gpio_port2";
#endif
	xcppm_unit_t *unitp;
	uint8_t data8, buf8;
	uint8_t	ret;

	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	mutex_enter(&unitp->gpio_lock);

	data8 = buf8 = XCPPM_GET8(unitp->hndls.gpio_data_ports,
	    unitp->regs.gpio_port2_data);

	switch (action) {
	case XCPPM_GETBIT:
		ret = data8 & pos;
		DPRINTF(D_GPIO, ("%s: READ: GPIO Bank2 value 0x%x\n",
		    str, buf8));
		break;

	case XCPPM_SETBIT:
	case XCPPM_CLRBIT:
		if (action == XCPPM_SETBIT)
			data8 |= pos;
		else
			data8 &= ~pos;
		XCPPM_SETGET8(unitp->hndls.gpio_data_ports,
		    unitp->regs.gpio_port2_data, data8);
		ret = data8 & pos;
		DPRINTF(D_GPIO, ("%s: %s: GPIO Bank2 "
		    "bit 0x%x changed from 0x%x to 0x%x\n",
		    str, (action == XCPPM_SETBIT) ? "UP" : "DOWN",
		    pos, buf8, data8));
		break;

	default:
		cmn_err(CE_PANIC, "xcalppm: unrecognized register "
		    "IO command %d\n", action);
		break;
	}
	mutex_exit(&unitp->gpio_lock);

	return (ret);
}


/*
 * Raise the power level of a subrange of cpus.  Used when cpu driver
 * failed an attempt to lower the power of a cpu (probably because
 * it got busy).  Need to revert the ones we already changed.
 *
 * ecpup = the ppm_dev_t for the cpu which failed to lower power
 * level = power level to reset prior cpus to
 */
static void
xcppm_revert_cpu_power(ppm_dev_t *ecpup, int level)
{
	ppm_dev_t *cpup;

	for (cpup = xcppm_cpu.devlist; cpup != ecpup; cpup = cpup->next) {
		DPRINTF(D_CPU, ("xrcp: \"%s\", revert to level %d\n",
		    cpup->path, level));
		(void) xcppm_change_power_level(cpup, 0, level);
	}
}

/*
 * Switch the DC/DC converter.  Clearing the GPIO bit in SuperI/O puts
 * the converter in low power mode and setting the bit puts it back in
 * normal mode.
 */
static void
xcppm_switch_dcdc_converter(int action)
{
	int tries = XCPPM_VCL_TRIES;
	uint_t spl;
	uint64_t stick_begin, stick_end;
	uint64_t tick_begin, tick_end;
	uint64_t cur_speed_ratio, full_speed_ratio;
	static int xcppm_dcdc_lpm;

	switch (action) {
	case XCPPM_SETBIT:
		if (xcppm_dcdc_lpm) {
			DPRINTF(D_CPU, ("xcppm_switch_dcdc_converter: "
			    "switch to normal power mode.\n"));
			(void) xcppm_gpio_port2(action, HIGHPWR);
			xcppm_dcdc_lpm = 0;
		}
		break;
	case XCPPM_CLRBIT:
		/*
		 * In some fast CPU configurations, DC/DC converter was
		 * put in low power mode before CPUs made the transition
		 * to 1/32 of clock speed.  In those cases, system was
		 * shut down by hardware for protection.  To resolve that
		 * problem, we make sure CPUs have made the clock transition
		 * before the DC/DC converter has been put to low power mode.
		 */
		ASSERT(xcppm_dcdc_lpm == 0);
		kpreempt_disable();
		full_speed_ratio = cpunodes[CPU->cpu_id].clock_freq /
		    sys_tick_freq;
		while (tries) {
			spl = ddi_enter_critical();
			tick_begin = gettick_counter();
			stick_timestamp((int64_t *)&stick_begin);
			ddi_exit_critical(spl);
			drv_usecwait(XCPPM_VCL_DELAY);
			spl = ddi_enter_critical();
			tick_end = gettick_counter();
			stick_timestamp((int64_t *)&stick_end);
			ddi_exit_critical(spl);
			cur_speed_ratio = (tick_end - tick_begin) /
			    (stick_end - stick_begin);

			/*
			 * tick/stick at current speed should at most be
			 * equal to full-speed tick/stick, adjusted with
			 * full/lowest clock speed ratio.  If not, speed
			 * transition has not happened yet.
			 */
			if (cur_speed_ratio <= ((full_speed_ratio /
			    XCPPM_VCL_DIVISOR) + 1)) {
				DPRINTF(D_CPU, ("xcppm_switch_dcdc_converter: "
				    "switch to low power mode.\n"));
				(void) xcppm_gpio_port2(action, HIGHPWR);
				xcppm_dcdc_lpm = 1;
				break;
			}
			DPRINTF(D_CPU, ("xcppm_switch_dcdc_converter: CPU "
			    "has not made transition to lowest speed yet "
			    "(%d)\n", tries));
			tries--;
		}
		kpreempt_enable();
		break;
	}
}

static void
xcppm_rio_mode(xcppm_unit_t *unitp, int mode)
{
	uint32_t data32, buf32;

	mutex_enter(&unitp->gpio_lock);
	data32 = buf32 = XCPPM_GET32(unitp->hndls.rio_mode_auxio,
	    unitp->regs.rio_mode_auxio);
	if (mode == XCPPM_SETBIT)
		data32 |= RIO_BBC_ESTAR_MODE;
	else
		data32 &= ~RIO_BBC_ESTAR_MODE;
	XCPPM_SETGET32(unitp->hndls.rio_mode_auxio,
	    unitp->regs.rio_mode_auxio, data32);
	mutex_exit(&unitp->gpio_lock);

	DPRINTF(D_CPU, ("xcppm_rio_mode: %s: change from 0x%x to 0x%x\n",
	    (mode == XCPPM_SETBIT) ? "DOWN" : "UP", buf32, data32));
}


/*
 * change the power level of all cpus to the arg value;
 * the caller needs to ensure that a legal transition is requested.
 */
static int
xcppm_change_cpu_power(int newlevel)
{
#ifdef DEBUG
	char *str = "xcppm_ccp";
#endif
	int index, level, oldlevel;
	int lowest, highest;
	int undo_flag, ret;
	int speedup, incr;
	uint32_t data32;
	uint16_t data16;
	xcppm_unit_t *unitp;
	ppm_dev_t *cpup;
	dev_info_t *dip;
	char *chstr;

	unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
	ASSERT(unitp);
	cpup = xcppm_cpu.devlist;
	lowest = cpup->lowest;
	highest = cpup->highest;

	/*
	 * not all cpus may have transitioned to a known level by this time
	 */
	oldlevel = (cpup->level == PM_LEVEL_UNKNOWN) ? highest : cpup->level;
	dip = cpup->dip;
	ASSERT(dip);

	DPRINTF(D_CPU, ("%s: old %d, new %d, highest %d, lowest %d\n",
	    str, oldlevel, newlevel, highest, lowest));

	if (newlevel > oldlevel) {
		chstr = "UP";
		speedup = 1;
		incr = 1;
	} else if (newlevel < oldlevel) {
		chstr = "DOWN";
		speedup = 0;
		incr = -1;
	} else
		return (DDI_SUCCESS);

	undo_flag = 0;
	if (speedup) {
		/*
		 * If coming up from lowest power level, set the E*
		 * mode bit in GPIO to make power supply efficient
		 * at normal power.
		 */
		if (oldlevel == cpup->lowest) {
			xcppm_switch_dcdc_converter(XCPPM_SETBIT);
			undo_flag = 1;
		}
	} else {
		/*
		 * set BBC Estar mode bit in RIO AUXIO register
		 */
		if (oldlevel == highest) {
			xcppm_rio_mode(unitp, XCPPM_SETBIT);
			undo_flag = 1;
		}
	}

	/*
	 * this loop will execute 1x or 2x depending on
	 * number of times we need to change clock rates
	 */
	for (level = oldlevel+incr; level != newlevel+incr; level += incr) {
		for (cpup = xcppm_cpu.devlist; cpup; cpup = cpup->next) {
			if (cpup->level == level)
				continue;
			ret = xcppm_change_power_level(cpup, 0, level);
			DPRINTF(D_CPU, ("%s: \"%s\", %s to level %d, ret %d\n",
			    str, cpup->path, chstr, cpup->level, ret));
			if (ret == DDI_SUCCESS)
				continue;

			/*
			 * if the driver was unable to lower cpu speed,
			 * the cpu probably got busy; set the previous
			 * cpus back to the original level
			 */
			if (speedup == 0)
				xcppm_revert_cpu_power(cpup, level + 1);

			if (undo_flag) {
				if (speedup)
					xcppm_switch_dcdc_converter(
					    XCPPM_CLRBIT);
				else
					xcppm_rio_mode(unitp, XCPPM_CLRBIT);
			}
			return (ret);
		}

		index = level - 1;
		spm_change_schizo_speed(index);
		DPRINTF(D_CPU, ("%s: safari config reg changed\n", str));

		/*
		 * set the delay times for changing to this rate
		 */
		data32 = XCPPM_BBC_DELAY(index);
		XCPPM_SETGET32(unitp->hndls.bbc_estar_ctrl,
		    (caddr_t)unitp->regs.bbc_assert_change, data32);
		DPRINTF(D_CPU, ("%s: %s: Wrote E* Assert Change Time "
		    "(t1) = 0x%x\n", str, chstr, data32));

		data32 = XCPPM_BBC_DELAY(index);
		XCPPM_SETGET32(unitp->hndls.bbc_estar_ctrl,
		    (caddr_t)unitp->regs.bbc_pll_settle, data32);
		DPRINTF(D_CPU, ("%s: %s: Wrote E* PLL Settle Time "
		    "(t4) = 0x%x\n", str, chstr, data32));

		data16 = bbc_estar_control_masks[index];
		XCPPM_SETGET16(unitp->hndls.bbc_estar_ctrl,
		    (caddr_t)unitp->regs.bbc_estar_ctrl, data16);
		DPRINTF(D_CPU, ("%s: %s: Wrote BCC E* Control = 0x%x\n",
		    str, chstr, data16));
	}

	/*
	 * clear CPU Estar Mode bit in the gpio register
	 */
	if (speedup) {
		if (newlevel == highest)
			xcppm_rio_mode(unitp, XCPPM_CLRBIT);
	} else {
		if (newlevel == lowest)
			xcppm_switch_dcdc_converter(XCPPM_CLRBIT);
	}

	return (DDI_SUCCESS);
}


/*
 * Process a request to change the power level of a cpu.  If all cpus
 * don't want to be at the same power yet, or if we are currently
 * refusing slowdown requests due to thermal stress, just cache the
 * request.  Otherwise, make the change for all cpus.
 */
/* ARGSUSED */
static int
xcppm_manage_cpus(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
	char *str = "xcppm_manage_cpus";
#endif
	int old, new, ret, kmflag;
	ppm_dev_t *ppmd;
	pm_ppm_devlist_t *devlist = NULL, *p;
	int		do_rescan = 0;
	dev_info_t	*rescan_dip;

	*result = DDI_SUCCESS;
	switch (reqp->request_type) {
	case PMR_PPM_SET_POWER:
		break;
	case PMR_PPM_POWER_CHANGE_NOTIFY:
		/* cpu driver can`t change cpu power level by itself */
	default:
		return (DDI_FAILURE);
	}

	ppmd = PPM_GET_PRIVATE(dip);
	ASSERT(MUTEX_HELD(&ppmd->domp->lock));
	old = reqp->req.ppm_set_power_req.old_level;
	new = reqp->req.ppm_set_power_req.new_level;

	/*
	 * At power on, the cpus are at full speed.  There is no hardware
	 * transition needed for going from unknown to full.  However, the
	 * state of the pm framework and cpu driver needs to be adjusted.
	 */
	if (ppmd->level == PM_LEVEL_UNKNOWN && new == ppmd->highest) {
		*result = ret = xcppm_change_power_level(ppmd, 0, new);
		if (ret != DDI_SUCCESS) {
			DPRINTF(D_CPU, ("%s: Failed to change "
			    "power level to %d\n", str, new));
		}
		return (ret);
	}

	if (new == ppmd->level) {
		DPRINTF(D_CPU, ("%s: already at power level %d\n", str, new));
		return (DDI_SUCCESS);
	}

	ppmd->rplvl = new;

	/*
	 * A request from lower to higher level transition is granted and
	 * made effective on both cpus. For more than two cpu platform model,
	 * the following code needs to be modified to remember the rest of
	 * the unsoliciting cpus to be rescan'ed.
	 * A request from higher to lower must be agreed by all cpus.
	 */
	for (ppmd = xcppm_cpu.devlist; ppmd; ppmd = ppmd->next) {
		if (ppmd->rplvl == new)
			continue;

		if (new < old) {
			DPRINTF(D_SOME, ("%s: not all cpus want to go down to "
			    "level %d yet\n", str, new));
			return (DDI_SUCCESS);
		}

		/*
		 * If a single cpu requests power up, honor the request
		 * by powering up both cpus.
		 */
		if (new > old) {
			DPRINTF(D_SOME, ("%s: powering up device(%s@%s, %p) "
			    "because of request from dip(%s@%s, %p), "
			    "need pm_rescan\n", str, PM_NAME(ppmd->dip),
			    PM_ADDR(ppmd->dip), (void *)ppmd->dip,
			    PM_NAME(dip), PM_ADDR(dip), (void *)dip))
			do_rescan++;
			rescan_dip = ppmd->dip;
			break;
		}
	}

	ret = xcppm_change_cpu_power(new);
	*result = ret;

	if (ret == DDI_SUCCESS) {
		if (reqp->req.ppm_set_power_req.canblock == PM_CANBLOCK_BLOCK)
			kmflag = KM_SLEEP;
		else
			kmflag = KM_NOSLEEP;

		for (ppmd = xcppm_cpu.devlist; ppmd; ppmd = ppmd->next) {
			if (ppmd->dip == dip)
				continue;

			if ((p = kmem_zalloc(sizeof (pm_ppm_devlist_t),
			    kmflag)) == NULL) {
				break;
			}
			p->ppd_who = ppmd->dip;
			p->ppd_cmpt = ppmd->cmpt;
			p->ppd_old_level = old;
			p->ppd_new_level = new;
			p->ppd_next = devlist;

			devlist = p;
		}
		reqp->req.ppm_set_power_req.cookie = (void *) devlist;

		if (do_rescan > 0)
			pm_rescan(rescan_dip);
	}

	return (ret);
}


/*
 * If powering off and all devices in this domain will now be off,
 * shut off common power.  If powering up and no devices up yet,
 * turn on common power.  Always make the requested power level
 * change for the target device.
 */
static int
xcppm_manage_fet(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
	char *str = "xcppm_manage_fet";
#endif
	int (*pwr_func)(ppm_dev_t *, int, int);
	int new, old, cmpt, incr = 0;
	ppm_dev_t *ppmd;

	ppmd = PPM_GET_PRIVATE(dip);
	DPRINTF(D_FET, ("%s: \"%s\", req %s\n", str,
	    ppmd->path, ppm_get_ctlstr(reqp->request_type, ~0)));

	*result = DDI_SUCCESS;	/* change later for failures */
	switch (reqp->request_type) {
	case PMR_PPM_SET_POWER:
		pwr_func = xcppm_change_power_level;
		old = reqp->req.ppm_set_power_req.old_level;
		new = reqp->req.ppm_set_power_req.new_level;
		cmpt = reqp->req.ppm_set_power_req.cmpt;
		break;
	case PMR_PPM_POWER_CHANGE_NOTIFY:
		pwr_func = xcppm_record_level_change;
		old = reqp->req.ppm_notify_level_req.old_level;
		new = reqp->req.ppm_notify_level_req.new_level;
		cmpt = reqp->req.ppm_notify_level_req.cmpt;
		break;
	default:
		return (*result = DDI_FAILURE);

	}

	/* This is common code for SET_POWER and POWER_CHANGE_NOTIFY cases */
	DPRINTF(D_FET, ("%s: \"%s\", old %d, new %d\n",
	    str, ppmd->path, old, new));

	ASSERT(old == ppmd->level);
	if (new == ppmd->level)
		return (DDI_SUCCESS);

	PPM_LOCK_DOMAIN(ppmd->domp);
	/*
	 * Devices in this domain are known to have 0 (off) as their
	 * lowest power level.  We use this fact to simplify the logic.
	 */
	if (new > 0) {
		if (ppmd->domp->pwr_cnt == 0)
			(void) xcppm_gpio_port2(XCPPM_SETBIT, DRVON);
		if (old == 0) {
			ppmd->domp->pwr_cnt++;
			incr = 1;
			DPRINTF(D_FET, ("%s: UP cnt = %d\n",
			    str, ppmd->domp->pwr_cnt));
		}
	}

	PPM_UNLOCK_DOMAIN(ppmd->domp);

	ASSERT(ppmd->domp->pwr_cnt > 0);

	if ((*result = (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS) {
		DPRINTF(D_FET, ("%s: \"%s\" power change failed \n",
		    str, ppmd->path));
	}

	PPM_LOCK_DOMAIN(ppmd->domp);

	/*
	 * Decr the power count in two cases:
	 *
	 *   1) request was to power device down and was successful
	 *   2) request was to power up (we pre-incremented count), but failed.
	 */
	if ((*result == DDI_SUCCESS && ppmd->level == 0) ||
	    (*result != DDI_SUCCESS && incr)) {
		ASSERT(ppmd->domp->pwr_cnt > 0);
		ppmd->domp->pwr_cnt--;
		DPRINTF(D_FET, ("%s: DN cnt = %d\n", str, ppmd->domp->pwr_cnt));
		if (ppmd->domp->pwr_cnt == 0)
			(void) xcppm_gpio_port2(XCPPM_CLRBIT, DRVON);
	}

	PPM_UNLOCK_DOMAIN(ppmd->domp);
	ASSERT(ppmd->domp->pwr_cnt >= 0);
	return (*result == DDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
}


/*
 * Since UPA64S relies on PCI B staying at nominal 33MHz in order to
 * have its interrupt pulse function properly, we ensure
 * - Lowering PCI B only if UPA64S is at low power, otherwise defer
 *   the action until UPA64S goes down; hence right after UPA64S goes
 *   down, perform the deferred action for PCI B;
 * - Always raise PCI B power prior to raising UPA64S power.
 *
 * Both UPA64S and PCI B devices are considered each other's dependency
 * device whenever actual power transition is handled (PMR_PPM_SET_POWER).
 */
static int
xcppm_manage_pciupa(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
	char *str = "xcppm_manage_pciupa";
#endif
	int (*pwr_func)(ppm_dev_t *, int, int);
	uint_t flags = 0, co_flags = 0;
	ppm_dev_t *ppmd, *codev;
	int new, cmpt, retval;

	ppmd = PPM_GET_PRIVATE(dip);
	DPRINTF(D_PCIUPA, ("%s: \"%s\", req %s\n", str,
	    ppmd->path, ppm_get_ctlstr(reqp->request_type, ~0)));

	*result = DDI_SUCCESS;

	switch (reqp->request_type) {
	case PMR_PPM_SET_POWER:
		pwr_func = xcppm_change_power_level;
		new = reqp->req.ppm_set_power_req.new_level;
		cmpt = reqp->req.ppm_set_power_req.cmpt;
		break;
	case PMR_PPM_POWER_CHANGE_NOTIFY:
		pwr_func = xcppm_record_level_change;
		new = reqp->req.ppm_notify_level_req.new_level;
		cmpt = reqp->req.ppm_notify_level_req.cmpt;
		break;
	default:
		*result = DDI_FAILURE;
		return (DDI_FAILURE);
	}

	/* Common code for SET_POWER and POWER_CHANGE_NOTIFY cases */
	ASSERT(ppmd);	/* since it should be locked already */

	if (new == ppmd->level)
		return (DDI_SUCCESS);

	DPRINTF(D_PCIUPA, ("%s: \"%s\", levels: current %d, new %d\n",
	    str, ppmd->path, ppmd->level, new));

	/*
	 * find power-wise co-related device
	 */
	flags =  ppmd->flags;

#ifdef DEBUG
	if (flags & ~(XCPPMF_PCIB|XCPPMF_UPA))
		DPRINTF(D_ERROR, ("%s: invalid ppmd->flags value 0x%x\n", str,
		    ppmd->flags));
#endif

	if (flags == XCPPMF_UPA)
		co_flags = XCPPMF_PCIB;
	else if (flags == XCPPMF_PCIB)
		co_flags = XCPPMF_UPA;

	for (codev = ppmd->domp->devlist; codev; codev = codev->next)
		if ((codev->cmpt == 0) && (codev->flags == co_flags))
			break;

	if (new > ppmd->level) {
		/*
		 * Raise power level -
		 * pre-raising: upa ensure pci is powered up.
		 */
		if ((flags == XCPPMF_UPA) && codev &&
		    (codev->level != codev->highest)) {
			if ((retval = xcppm_change_power_level(codev,
			    0, codev->highest)) != DDI_SUCCESS &&
			    codev->level != codev->highest) {
				*result = retval;
				return (DDI_FAILURE);
			}
		}
		if ((retval = (*pwr_func)(ppmd, 0, new)) != DDI_SUCCESS) {
			*result = retval;
			return (DDI_FAILURE);
		}
	} else if (new < ppmd->level) {
		/*
		 * Lower power level
		 *
		 * once upa is attached, pci checks upa level:
		 * if upa is at high level, defer the request and return.
		 * otherwise, set power level then check and lower pci level.
		 */
		if ((flags == XCPPMF_PCIB) && codev &&
		    (codev->level != codev->lowest)) {
			ppmd->rplvl = new;
			return (DDI_SUCCESS);
		}
		if ((retval = (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS &&
		    ppmd->level != new) {
			*result = retval;
			return (DDI_FAILURE);
		}

		if (flags == XCPPMF_UPA) {
			if (codev && (codev->rplvl != PM_LEVEL_UNKNOWN) &&
			    (codev->rplvl < codev->level)) {
				DPRINTF(D_PCIUPA, ("%s: codev \"%s\" "
				    "rplvl %d level %d\n", str, codev->path,
				    codev->rplvl, codev->level));
				if ((retval = xcppm_change_power_level(
				    codev, 0, codev->rplvl)) != DDI_SUCCESS) {
					*result = retval;
					return (DDI_FAILURE);
				}
			}
		}
	}

	return (DDI_SUCCESS);
}


/*
 * When all of the children of the 1394 nexus are idle, a call will be
 * made to the nexus driver's own power entry point to lower power.  Ppm
 * intercepts this and kills 1394 cable power (since the driver doesn't
 * have access to the required register).  Similar logic applies when
 * coming up from the state where all the children were off.
 */
static int
xcppm_manage_1394(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
	char *str = "xcppm_manage_1394";
#endif
	int (*pwr_func)(ppm_dev_t *, int, int);
	int new, old, cmpt;
	ppm_dev_t *ppmd;

	ppmd = PPM_GET_PRIVATE(dip);
	DPRINTF(D_1394, ("%s: \"%s\", req %s\n", str,
	    ppmd->path, ppm_get_ctlstr(reqp->request_type, ~0)));

	switch (reqp->request_type) {
	case PMR_PPM_SET_POWER:
		pwr_func = xcppm_change_power_level;
		old = reqp->req.ppm_set_power_req.old_level;
		new = reqp->req.ppm_set_power_req.new_level;
		cmpt = reqp->req.ppm_set_power_req.cmpt;
		break;
	case PMR_PPM_POWER_CHANGE_NOTIFY:
		pwr_func = xcppm_record_level_change;
		old = reqp->req.ppm_notify_level_req.old_level;
		new = reqp->req.ppm_notify_level_req.new_level;
		cmpt = reqp->req.ppm_notify_level_req.cmpt;
		break;
	default:
		return (*result = DDI_FAILURE);
	}


	/* Common code for SET_POWER and POWER_CHANGE_NOTIFY cases */
	DPRINTF(D_1394, ("%s: dev %s@%s, old %d new %d\n", str,
	    ddi_binding_name(dip), ddi_get_name_addr(dip), old, new));

	ASSERT(ppmd);	/* since it must already be locked */
	ASSERT(old == ppmd->level);

	if (new == ppmd->level)
		return (*result = DDI_SUCCESS);

	/* the reduce power case */
	if (cmpt == 0 && new < ppmd->level) {
		if ((*result =
		    (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}
		if (new == ppmd->lowest)
			(void) xcppm_gpio_port2(XCPPM_CLRBIT, CPEN);
		ppmd->level = new;
		return (DDI_SUCCESS);
	}

	/* the increase power case */
	if (cmpt == 0 && new > ppmd->level) {
		if (ppmd->level == ppmd->lowest) {
			(void) xcppm_gpio_port2(XCPPM_SETBIT, CPEN);
			delay(1);
		}
		/*
		 * Even if pwr_func fails we need to check current level again
		 * because it could have been changed by an intervening
		 * POWER_CHANGE_NOTIFY operation.
		 */
		if ((*result =
		    (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS &&
		    ppmd->level == ppmd->lowest) {
			(void) xcppm_gpio_port2(XCPPM_CLRBIT, CPEN);
		} else {
			ppmd->level = new;
		}

		return (*result == DDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
	}

	/*
	 * We get here if component was non-zero.  This is not what we
	 * expect.  Let the device deal with it and just pass back the
	 * result.
	 */
	*result = xcppm_change_power_level(ppmd, cmpt, new);
	return (*result == DDI_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
}


/*
 * lock, unlock, or trylock for one power mutex
 */
static void
xcppm_lock_one(ppm_dev_t *ppmd, power_req_t *reqp, int *iresp)
{
	switch (reqp->request_type) {
	case PMR_PPM_LOCK_POWER:
		pm_lock_power_single(ppmd->dip,
		    reqp->req.ppm_lock_power_req.circp);
		break;

	case PMR_PPM_UNLOCK_POWER:
		pm_unlock_power_single(ppmd->dip,
		    reqp->req.ppm_unlock_power_req.circ);
		break;

	case PMR_PPM_TRY_LOCK_POWER:
		*iresp = pm_try_locking_power_single(ppmd->dip,
		    reqp->req.ppm_lock_power_req.circp);
		break;
	}
}


/*
 * lock, unlock, or trylock all devices within a domain.
 */
static void
xcppm_lock_all(ppm_domain_t *domp, power_req_t *reqp, int *iresp)
{
	/*
	 * To simplify the implementation we let all the devices
	 * in the domain be represented by a single device (dip).
	 * We use the first device in the domain's devlist.  This
	 * is safe because we return with the domain lock held
	 * which prevents the list from changing.
	 */
	if (reqp->request_type == PMR_PPM_LOCK_POWER) {
		if (!MUTEX_HELD(&domp->lock))
			mutex_enter(&domp->lock);
		domp->refcnt++;
		ASSERT(domp->devlist != NULL);
		pm_lock_power_single(domp->devlist->dip,
		    reqp->req.ppm_lock_power_req.circp);
		/* domain lock remains held */
		return;
	} else if (reqp->request_type == PMR_PPM_UNLOCK_POWER) {
		ASSERT(MUTEX_HELD(&domp->lock));
		ASSERT(domp->devlist != NULL);
		pm_unlock_power_single(domp->devlist->dip,
		    reqp->req.ppm_unlock_power_req.circ);
		if (--domp->refcnt == 0)
			mutex_exit(&domp->lock);
		return;
	}

	ASSERT(reqp->request_type == PMR_PPM_TRY_LOCK_POWER);
	if (!MUTEX_HELD(&domp->lock))
		if (!mutex_tryenter(&domp->lock)) {
			*iresp = 0;
			return;
		}
	*iresp = pm_try_locking_power_single(domp->devlist->dip,
	    reqp->req.ppm_lock_power_req.circp);
	if (*iresp)
		domp->refcnt++;
	else
		mutex_exit(&domp->lock);
}


/*
 * The pm framework calls us here to manage power for a device.
 * We maintain state which tells us whether we need to turn off/on
 * system board power components based on the status of all the devices
 * sharing a component.
 *
 */
/* ARGSUSED */
static int
xcppm_ctlops(dev_info_t *dip, dev_info_t *rdip,
    ddi_ctl_enum_t ctlop, void *arg, void *result)
{
	power_req_t *reqp = arg;
	xcppm_unit_t *unitp;
	ppm_domain_t *domp;
	ppm_dev_t *ppmd;

#ifdef DEBUG
	char path[MAXPATHLEN], *ctlstr, *str = "xcppm_ctlops";
	uint_t mask = ppm_debug & (D_CTLOPS1 | D_CTLOPS2);
	if (mask && (ctlstr = ppm_get_ctlstr(reqp->request_type, mask))) {
		prom_printf("%s: \"%s\", %s\n", str,
		    ddi_pathname(rdip, path), ctlstr);
	}
#endif

	if (ctlop != DDI_CTLOPS_POWER)
		return (DDI_FAILURE);

	switch (reqp->request_type) {
	case PMR_PPM_UNMANAGE:
	case PMR_PPM_PRE_PROBE:
	case PMR_PPM_POST_PROBE:
	case PMR_PPM_PRE_ATTACH:
	case PMR_PPM_PRE_DETACH:
		return (DDI_SUCCESS);

	/*
	 * There is no hardware configuration required to be done on this
	 * platform prior to installing drivers.
	 */
	case PMR_PPM_INIT_CHILD:
	case PMR_PPM_UNINIT_CHILD:
		return (DDI_SUCCESS);

	case PMR_PPM_ALL_LOWEST:
		DPRINTF(D_LOWEST, ("%s: all devices at lowest power = %d\n",
		    str, reqp->req.ppm_all_lowest_req.mode));
		if (reqp->req.ppm_all_lowest_req.mode == PM_ALL_LOWEST) {
			unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
			mutex_enter(&unitp->unit_lock);
			if (unitp->state & XCPPM_ST_SUSPENDED) {
				mutex_exit(&unitp->unit_lock);
				return (DDI_SUCCESS);
			}

			xcppm_set_led(PPM_LEDON);
			unitp->led_tid = timeout(xcppm_blink_led,
			    (void *)PPM_LEDON, PPM_LEDON_INTERVAL);
			mutex_exit(&unitp->unit_lock);
			DPRINTF(D_LOWEST, ("%s: LED blink started\n", str));
		} else {
			xcppm_freeze_led((void *)PPM_LEDON);
			DPRINTF(D_LOWEST, ("%s: LED freeze ON\n", str));
		}
		return (DDI_SUCCESS);

	case PMR_PPM_POST_ATTACH:
		/*
		 * After a successful attach, if we haven't already created
		 * our private data structure for this device, ppm_get_dev()
		 * will force it to be created.
		 */
		ppmd = PPM_GET_PRIVATE(rdip);
		if (reqp->req.ppm_config_req.result != DDI_SUCCESS) {
			if (ppmd)
				ppm_rem_dev(rdip);
		} else if (!ppmd) {
			domp = ppm_lookup_dev(rdip);
			ASSERT(domp);
			(void) ppm_get_dev(rdip, domp);
		}
		return (DDI_SUCCESS);

	case PMR_PPM_POST_DETACH:
		xcppm_detach_ctlop(rdip, reqp);
		*(int *)result = DDI_SUCCESS;
		return (DDI_SUCCESS);

	case PMR_PPM_PRE_RESUME:
		xcppm_resume_ctlop(rdip, reqp);
		return (DDI_SUCCESS);

	case PMR_PPM_UNLOCK_POWER:
	case PMR_PPM_TRY_LOCK_POWER:
	case PMR_PPM_LOCK_POWER:
		ppmd = PPM_GET_PRIVATE(rdip);
		if (ppmd)
			domp = ppmd->domp;
		else if (reqp->request_type != PMR_PPM_UNLOCK_POWER) {
			domp = ppm_lookup_dev(rdip);
			ASSERT(domp);
			ppmd = ppm_get_dev(rdip, domp);
		}

		ASSERT(domp->dflags == PPMD_LOCK_ALL ||
		    domp->dflags == PPMD_LOCK_ONE);
		DPRINTF(D_LOCKS, ("xcppm_lock_%s: \"%s\", %s\n",
		    (domp->dflags == PPMD_LOCK_ALL) ? "all" : "one",
		    ppmd->path, ppm_get_ctlstr(reqp->request_type, D_LOCKS)));

		if (domp->dflags == PPMD_LOCK_ALL)
			xcppm_lock_all(domp, reqp, result);
		else
			xcppm_lock_one(ppmd, reqp, result);
		return (DDI_SUCCESS);

	case PMR_PPM_POWER_LOCK_OWNER:
		ASSERT(reqp->req.ppm_power_lock_owner_req.who == rdip);
		ppmd = PPM_GET_PRIVATE(rdip);
		if (ppmd)
			domp = ppmd->domp;
		else {
			domp = ppm_lookup_dev(rdip);
			ASSERT(domp);
			ppmd = ppm_get_dev(rdip, domp);
		}

		/*
		 * In case of LOCK_ALL, effective owner of the power lock
		 * is the owner of the domain lock. otherwise, it is the owner
		 * of the power lock.
		 */
		if (domp->dflags & PPMD_LOCK_ALL)
			reqp->req.ppm_power_lock_owner_req.owner =
			    mutex_owner(&domp->lock);
		else {
			reqp->req.ppm_power_lock_owner_req.owner =
			    DEVI(rdip)->devi_busy_thread;
		}
		return (DDI_SUCCESS);

	default:
		ppmd = PPM_GET_PRIVATE(rdip);
		if (ppmd == NULL) {
			domp = ppm_lookup_dev(rdip);
			ASSERT(domp);
			ppmd = ppm_get_dev(rdip, domp);
		}

#ifdef DEBUG
		if ((reqp->request_type == PMR_PPM_SET_POWER) &&
		    (ppm_debug & D_SETPWR)) {
			prom_printf("%s: \"%s\", PMR_PPM_SET_POWER\n",
			    str, ppmd->path);
		}
#endif

		if (ppmd->domp == &xcppm_cpu)
			return (xcppm_manage_cpus(rdip, reqp, result));
		else if (ppmd->domp == &xcppm_fet)
			return (xcppm_manage_fet(rdip, reqp, result));
		else if (ppmd->domp == &xcppm_upa)
			return (xcppm_manage_pciupa(rdip, reqp, result));
		else {
			ASSERT(ppmd->domp == &xcppm_1394);
			return (xcppm_manage_1394(rdip, reqp, result));
		}
	}
}


/*
 * Initialize our private version of real power level
 * as well as lowest and highest levels the device supports;
 * see ppmf and ppm_add_dev
 */
static void
xcppm_dev_init(ppm_dev_t *ppmd)
{
	struct pm_component *dcomps;
	struct pm_comp *pm_comp;
	dev_info_t *dip;
	int maxi;

	ASSERT(MUTEX_HELD(&ppmd->domp->lock));
	ppmd->level = PM_LEVEL_UNKNOWN;
	ppmd->rplvl = PM_LEVEL_UNKNOWN;

	dip = ppmd->dip;
	/*
	 * ppm exists to handle power-manageable devices which require
	 * special handling on the current platform.  However, a
	 * driver for such a device may choose not to support power
	 * management on a particular load/attach.  In this case we
	 * we create a structure to represent a single-component device
	 * for which "level" = PM_LEVEL_UNKNOWN and "lowest" = 0
	 * are effectively constant.
	 */
	if (PM_GET_PM_INFO(dip)) {
		dcomps = DEVI(dip)->devi_pm_components;
		pm_comp = &dcomps[ppmd->cmpt].pmc_comp;

		ppmd->lowest = pm_comp->pmc_lvals[0];
		ASSERT(ppmd->lowest >= 0);
		maxi = pm_comp->pmc_numlevels - 1;
		ppmd->highest = pm_comp->pmc_lvals[maxi];
	}

	/*
	 * add any domain-specific initialization here
	 */
	if (ppmd->domp == &xcppm_fet) {
		/*
		 * when a new device is added to domain_powefet
		 * it is counted here as being powered up.
		 */
		ppmd->domp->pwr_cnt++;
		DPRINTF(D_FET, ("xcppm_dev_init: UP cnt = %d\n",
		    ppmd->domp->pwr_cnt));
	} else if (ppmd->domp == &xcppm_upa) {
		/*
		 * There may be a better way to determine the device type
		 * instead of comparing to hard coded string names.
		 */
		if (strstr(ppmd->path, "pci@8,700000"))
			ppmd->flags = XCPPMF_PCIB;
		else if (strstr(ppmd->path, "upa@8,480000"))
			ppmd->flags = XCPPMF_UPA;
	}
}


/*
 * see ppmf and ppm_rem_dev
 */
static void
xcppm_dev_fini(ppm_dev_t *ppmd)
{
	ASSERT(MUTEX_HELD(&ppmd->domp->lock));
	if (ppmd->domp == &xcppm_fet) {
		if (ppmd->level != ppmd->lowest) {
			ppmd->domp->pwr_cnt--;
			DPRINTF(D_FET, ("xcppm_dev_fini: DN cnt = %d\n",
			    ppmd->domp->pwr_cnt));
		};
	}
}


/*
 * see ppmf and ppm_ioctl, PPMIOCSET
 */
static void
xcppm_iocset(uint8_t value)
{
	int action;

	if (value == PPM_IDEV_POWER_ON)
		action = XCPPM_SETBIT;
	else if (value == PPM_IDEV_POWER_OFF)
		action = XCPPM_CLRBIT;
	(void) xcppm_gpio_port2(action, DRVON);
}


/*
 * see ppmf and ppm_ioctl, PPMIOCGET
 */
static uint8_t
xcppm_iocget(void)
{
	uint8_t bit;

	bit = xcppm_gpio_port2(XCPPM_GETBIT, DRVON);
	return ((bit == DRVON) ? PPM_IDEV_POWER_ON : PPM_IDEV_POWER_OFF);
}