/*
* 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);
}