/*
* 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.
*/
/*
* Copyright (c) 2009, Intel Corporation.
* All Rights Reserved.
*/
/*
* Platform Power Management master pseudo driver -
* - attaches only when ppm.conf file is present, indicating a
* workstation (since Excalibur era ) that is designed to
* be MOU-3 EPA compliant and which uses platform-specific
* hardware to do so;
* - this pseudo driver uses a set of simple satellite
* device drivers responsible for accessing platform
* specific devices to modify the registers they own.
* ppm drivers tells these satellite drivers what to do
* according to using command values taken from ppm.conf.
*/
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/open.h>
#include <sys/callb.h>
#include <sys/va_list.h>
#include <sys/errno.h>
#include <sys/modctl.h>
#include <sys/sysmacros.h>
#include <sys/ddi_impldefs.h>
#include <sys/promif.h>
#include <sys/epm.h>
#include <sys/sunpm.h>
#include <sys/ppmio.h>
#include <sys/sunldi.h>
#include <sys/ppmvar.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ppm_plat.h>
/*
* Note: When pm_power() is called (directly or indirectly) to change the
* power level of a device and the call returns failure, DO NOT assume the
* level is unchanged. Doublecheck it against ppmd->level.
*/
/*
* cb_ops
*/
static int ppm_open(dev_t *, int, int, cred_t *);
static int ppm_close(dev_t, int, int, cred_t *);
static int ppm_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
static struct cb_ops ppm_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 */
};
/*
* bus_ops
*/
static int ppm_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *,
void *);
static struct bus_ops ppm_bus_ops = {
BUSO_REV, /* busops_rev */
0, /* bus_map */
0, /* bus_get_intrspec */
0, /* bus_add_intrspec */
0, /* bus_remove_intrspec */
0, /* bus_map_fault */
ddi_no_dma_map, /* bus_dma_map */
ddi_no_dma_allochdl, /* bus_dma_allochdl */
NULL, /* bus_dma_freehdl */
NULL, /* bus_dma_bindhdl */
NULL, /* bus_dma_unbindhdl */
NULL, /* bus_dma_flush */
NULL, /* bus_dma_win */
NULL, /* bus_dma_ctl */
ppm_ctlops, /* bus_ctl */
0, /* bus_prop_op */
0, /* bus_get_eventcookie */
0, /* bus_add_eventcall */
0, /* bus_remove_eventcall */
0, /* bus_post_event */
0 /* bus_intr_ctl */
};
/*
* dev_ops
*/
static int ppm_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int ppm_attach(dev_info_t *, ddi_attach_cmd_t);
static int ppm_detach(dev_info_t *, ddi_detach_cmd_t);
static struct dev_ops ppm_ops = {
DEVO_REV, /* devo_rev */
0, /* refcnt */
ppm_getinfo, /* info */
nulldev, /* identify */
nulldev, /* probe */
ppm_attach, /* attach */
ppm_detach, /* detach */
nodev, /* reset */
&ppm_cb_ops, /* cb_ops */
&ppm_bus_ops, /* bus_ops */
nulldev, /* power */
ddi_quiesce_not_needed, /* quiesce */
};
extern struct mod_ops mod_driverops;
static struct modldrv modldrv = {
&mod_driverops,
"platform pm driver",
&ppm_ops
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
/*
* Global data structure and variables
*/
int ppm_inst = -1;
void *ppm_statep;
ppm_domain_t *ppm_domain_p;
callb_id_t *ppm_cprcb_id;
static kmutex_t ppm_cpr_window_lock; /* guard ppm_cpr_window_flag */
static boolean_t ppm_cpr_window_flag; /* set indicating chpt-resume period */
/* LED actions */
#define PPM_LED_SOLIDON 0
#define PPM_LED_BLINKING 1
/*
* Debug
*/
#ifdef DEBUG
uint_t ppm_debug = 0;
#endif
/*
* Local function prototypes and data
*/
static boolean_t ppm_cpr_callb(void *, int);
static int ppm_fetset(ppm_domain_t *, uint8_t);
static int ppm_fetget(ppm_domain_t *, uint8_t *);
static int ppm_gpioset(ppm_domain_t *, int);
static int ppm_manage_cpus(dev_info_t *, power_req_t *, int *);
static int ppm_manage_pci(dev_info_t *, power_req_t *, int *);
static int ppm_manage_pcie(dev_info_t *, power_req_t *, int *);
static int ppm_manage_fet(dev_info_t *, power_req_t *, int *);
static void ppm_manage_led(int);
static void ppm_set_led(ppm_domain_t *, int);
static void ppm_blink_led(void *);
static void ppm_svc_resume_ctlop(dev_info_t *, power_req_t *);
static int ppm_set_level(ppm_dev_t *, int, int, boolean_t);
static int ppm_change_power_level(ppm_dev_t *, int, int);
static int ppm_record_level_change(ppm_dev_t *, int, int);
static int ppm_switch_clock(ppm_domain_t *, int);
static int ppm_pcie_pwr(ppm_domain_t *, int);
static int ppm_power_up_domain(dev_info_t *dip);
static int ppm_power_down_domain(dev_info_t *dip);
int
_init(void)
{
if (ddi_soft_state_init(
&ppm_statep, sizeof (ppm_unit_t), 1) != DDI_SUCCESS) {
PPMD(D_INIT, ("ppm: soft state init\n"))
return (DDI_FAILURE);
}
if (mod_install(&modlinkage) != DDI_SUCCESS) {
ddi_soft_state_fini(&ppm_statep);
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
int
_fini(void)
{
int error;
if ((error = mod_remove(&modlinkage)) == DDI_SUCCESS)
ddi_soft_state_fini(&ppm_statep);
return (error);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/* ARGSUSED */
int
ppm_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
struct ppm_unit *unitp;
dev_t dev;
int instance;
int rval;
if (ppm_inst == -1)
return (DDI_FAILURE);
switch (cmd) {
case DDI_INFO_DEVT2DEVINFO:
if (unitp = ddi_get_soft_state(ppm_statep, (dev_t)arg)) {
*resultp = unitp->dip;
rval = DDI_SUCCESS;
} else
rval = DDI_FAILURE;
return (rval);
case DDI_INFO_DEVT2INSTANCE:
dev = (dev_t)arg;
instance = getminor(dev);
*resultp = (void *)(uintptr_t)instance;
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/*
* attach(9E)
*/
static int
ppm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
ppm_unit_t *unitp;
int ret;
#ifdef DEBUG
char *str = "ppm_attach";
#endif
switch (cmd) {
case DDI_ATTACH:
PPMD(D_ATTACH, ("%s: attaching ...\n", str))
break;
case DDI_RESUME:
PPMD(D_ATTACH, ("%s: Resuming ...\n", str))
unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
mutex_enter(&unitp->lock);
unitp->states &= ~PPM_STATE_SUSPENDED;
mutex_exit(&unitp->lock);
return (DDI_SUCCESS);
default:
cmn_err(CE_WARN, "ppm_attach: unknown command %d, dip(0x%p)",
cmd, (void *)dip);
return (DDI_FAILURE);
}
if (ppm_inst != -1) {
PPMD(D_ATTACH, ("%s: Already attached !", str))
return (DDI_FAILURE);
}
ppm_inst = ddi_get_instance(dip);
if (ddi_soft_state_zalloc(ppm_statep, ppm_inst) != DDI_SUCCESS) {
PPMD(D_ATTACH, ("%s: soft states alloc error!\n", str))
return (DDI_FAILURE);
}
unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
ret = ddi_create_minor_node(dip, "ppm", S_IFCHR, ppm_inst,
"ddi_ppm", 0);
if (ret != DDI_SUCCESS) {
PPMD(D_ATTACH, ("%s: can't create minor node!\n", str))
goto fail1;
}
unitp->dip = dip;
mutex_init(&unitp->lock, NULL, MUTEX_DRIVER, NULL);
/*
* read ppm.conf, construct ppm_domain data structure and
* their sub data structure.
*/
if ((ret = ppm_create_db(dip)) != DDI_SUCCESS)
goto fail2;
/*
* walk down ppm domain control from each domain, initialize
* domain control orthogonal function call handle
*/
ppm_init_cb(dip);
if ((ret = pm_register_ppm(ppm_claim_dev, dip)) != DDI_SUCCESS) {
cmn_err(CE_WARN, "ppm_attach: can't register ppm handler!");
goto fail2;
}
mutex_init(&ppm_cpr_window_lock, NULL, MUTEX_DRIVER, NULL);
ppm_cpr_window_flag = B_FALSE;
ppm_cprcb_id = callb_add(ppm_cpr_callb, (void *)NULL,
CB_CL_CPR_PM, "ppm_cpr");
#if defined(__x86)
/*
* Register callback so that once CPUs have been added to
* the device tree, ppm CPU domains can be allocated using ACPI
* data.
*/
cpupm_ppm_alloc_pstate_domains = ppm_alloc_pstate_domains;
cpupm_ppm_free_pstate_domains = ppm_free_pstate_domains;
/*
* Register callback so that whenever max speed throttle requests
* are received, ppm can redefine the high power level for
* all CPUs in the domain.
*/
cpupm_redefine_topspeed = ppm_redefine_topspeed;
#endif
ddi_report_dev(dip);
return (DDI_SUCCESS);
fail2:
ddi_remove_minor_node(dip, "ddi_ppm");
mutex_destroy(&unitp->lock);
fail1:
ddi_soft_state_free(ppm_statep, ppm_inst);
ppm_inst = -1;
return (DDI_FAILURE);
}
/* ARGSUSED */
static int
ppm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
ppm_unit_t *unitp;
#ifdef DEBUG
char *str = "ppm_detach";
#endif
switch (cmd) {
case DDI_DETACH:
PPMD(D_DETACH, ("%s: detach not allowed.\n", str))
return (DDI_FAILURE);
case DDI_SUSPEND:
PPMD(D_DETACH, ("%s: suspending ...\n", str))
unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
mutex_enter(&unitp->lock);
unitp->states |= PPM_STATE_SUSPENDED;
mutex_exit(&unitp->lock);
/*
* Suspend requires that timeout callouts to be canceled.
* Turning off the LED blinking will cancel the timeout.
*/
ppm_manage_led(PPM_LED_SOLIDON);
return (DDI_SUCCESS);
default:
cmn_err(CE_WARN, "ppm_detach: unsupported command %d, dip(%p)",
cmd, (void *)dip);
return (DDI_FAILURE);
}
}
/* ARGSUSED */
int
ppm_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
{
if (otyp != OTYP_CHR)
return (EINVAL);
PPMD(D_OPEN, ("ppm_open: devp 0x%p, flag 0x%x, otyp %d\n",
(void *)devp, flag, otyp))
return (0);
}
/* ARGSUSED */
int
ppm_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
PPMD(D_CLOSE, ("ppm_close: dev 0x%lx, flag 0x%x, otyp %d\n",
dev, flag, otyp))
return (0);
}
/* ARGSUSED */
int
ppm_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred_p,
int *rval_p)
{
#ifdef DEBUG
char *str = "ppm_ioctl";
#endif
ppm_domain_t *domp = NULL;
uint8_t level, lvl;
int ret = 0;
PPMD(D_IOCTL, ("%s: dev 0x%lx, cmd 0x%x, mode 0x%x\n",
str, dev, cmd, mode))
switch (cmd) {
case PPMGET_DPWR:
{
STRUCT_DECL(ppm_dpwr, dpwr);
struct ppm_unit *unitp;
char *domain;
STRUCT_INIT(dpwr, mode);
ret = ddi_copyin((caddr_t)arg, STRUCT_BUF(dpwr),
STRUCT_SIZE(dpwr), mode);
if (ret != 0)
return (EFAULT);
/* copyin domain name */
domain = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
ret = copyinstr(
STRUCT_FGETP(dpwr, domain), domain, MAXNAMELEN, NULL);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyin domain, line(%d)\n",
str, __LINE__))
ret = EFAULT;
goto err_dpwr;
}
/* locate domain */
if ((domp = ppm_lookup_domain(domain)) == NULL) {
PPMD(D_IOCTL, ("%s: no such domain %s\n", str, domain))
ret = ENODEV;
goto err_dpwr;
}
switch (domp->model) {
case PPMD_FET: /* report power fet ON or OFF */
if ((ret = ppm_fetget(domp, &lvl)) != 0) {
ret = EIO;
goto err_dpwr;
}
level = (lvl == PPMD_ON) ?
PPMIO_POWER_ON : PPMIO_POWER_OFF;
break;
case PPMD_PCI: /* report pci slot clock ON or OFF */
case PPMD_PCI_PROP:
case PPMD_PCIE:
level = (domp->status == PPMD_ON) ?
PPMIO_POWER_ON : PPMIO_POWER_OFF;
break;
case PPMD_LED: /* report LED blinking or solid on */
unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
if (unitp->led_tid == 0)
level = PPMIO_LED_SOLIDON;
else
level = PPMIO_LED_BLINKING;
break;
case PPMD_CPU: /* report cpu speed divisor */
level = domp->devlist->level;
break;
default:
ret = EINVAL;
goto err_dpwr;
}
STRUCT_FSET(dpwr, level, level);
ret = ddi_copyout(STRUCT_BUF(dpwr), (caddr_t)arg,
STRUCT_SIZE(dpwr), mode);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyout, line(%d)\n",
str, __LINE__))
ret = EFAULT;
}
err_dpwr:
kmem_free(domain, MAXNAMELEN);
break;
}
case PPMGET_DOMBYDEV:
{
STRUCT_DECL(ppm_bydev, bydev);
char *path = NULL;
size_t size, l;
STRUCT_INIT(bydev, mode);
ret = ddi_copyin((caddr_t)arg, STRUCT_BUF(bydev),
STRUCT_SIZE(bydev), mode);
if (ret != 0)
return (EFAULT);
/* copyin .path */
path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
ret = copyinstr(
STRUCT_FGETP(bydev, path), path, MAXPATHLEN, NULL);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyin path, line(%d)\n",
str, __LINE__))
kmem_free(path, MAXPATHLEN);
return (EFAULT);
}
/* so far we have up to one domain for a given device */
size = STRUCT_FGET(bydev, size);
domp = ppm_get_domain_by_dev(path);
kmem_free(path, MAXPATHLEN);
if (domp != NULL) {
l = strlen(domp->name) + 1;
if (l > size) {
PPMD(D_IOCTL, ("%s: buffer too small\n", str))
return ((size == 0) ? EINVAL : EFAULT);
}
} else /* no domain found to be associated with given device */
return (ENODEV);
ret = copyoutstr(
domp->name, STRUCT_FGETP(bydev, domlist), l, &l);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyout domlist, line(%d)"
" \n", str, __LINE__))
return (EFAULT);
}
break;
}
case PPMGET_DEVBYDOM:
{
STRUCT_DECL(ppm_bydom, bydom);
char *domain = NULL;
char *devlist = NULL;
ppm_dev_t *ppmd;
dev_info_t *odip = NULL;
char *s, *d;
size_t size, l;
STRUCT_INIT(bydom, mode);
ret = ddi_copyin((caddr_t)arg, STRUCT_BUF(bydom),
STRUCT_SIZE(bydom), mode);
if (ret != 0)
return (EFAULT);
/* copyin .domain */
domain = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
ret = copyinstr(STRUCT_FGETP(bydom, domain), domain,
MAXNAMELEN, NULL);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyin domain, line(%d)\n",
str, __LINE__))
ret = EFAULT;
goto err_bydom;
}
/* locate domain */
if ((domp = ppm_lookup_domain(domain)) == NULL) {
ret = ENODEV;
goto err_bydom;
}
l = 0;
if ((size = STRUCT_FGET(bydom, size)) == 0)
ret = EINVAL;
else
if ((d = devlist = kmem_zalloc(size, KM_SLEEP)) == NULL)
ret = EFAULT;
if (ret != 0)
goto err_bydom;
for (ppmd = domp->devlist; ppmd;
odip = ppmd->dip, ppmd = ppmd->next) {
if (ppmd->dip == odip)
continue;
if (ppmd != domp->devlist)
*d++ = ' ';
l += strlen(ppmd->path) + 1;
if (l > size) {
PPMD(D_IOCTL, ("%s: buffer overflow\n", str))
ret = EFAULT;
goto err_bydom;
}
for (s = ppmd->path; *s != 0; )
*d++ = *s++;
}
*d = 0;
if (*devlist == 0)
goto err_bydom;
ret = copyoutstr(
devlist, STRUCT_FGETP(bydom, devlist), l, &l);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyout devlist, line(%d)"
" \n", str, __LINE__))
ret = EFAULT;
}
err_bydom:
if (devlist)
kmem_free(devlist, size);
if (domain)
kmem_free(domain, MAXNAMELEN);
break;
}
#if defined(__x86)
/*
* Note that these two ioctls exist for test purposes only.
* Unfortunately, there really isn't any other good way of
* unit testing the dynamic redefinition of the top speed as it
* usually occurs due to environmental conditions.
*/
case PPMGET_NORMAL:
case PPMSET_NORMAL:
{
STRUCT_DECL(ppm_norm, norm);
char *path = NULL;
struct pm_component *dcomps;
struct pm_comp *pm_comp;
ppm_dev_t *ppmd;
int i;
STRUCT_INIT(norm, mode);
ret = ddi_copyin((caddr_t)arg, STRUCT_BUF(norm),
STRUCT_SIZE(norm), mode);
if (ret != 0)
return (EFAULT);
/* copyin .path */
path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
ret = copyinstr(
STRUCT_FGETP(norm, path), path, MAXPATHLEN, NULL);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyin path, line(%d)\n",
str, __LINE__))
kmem_free(path, MAXPATHLEN);
return (EFAULT);
}
domp = ppm_get_domain_by_dev(path);
kmem_free(path, MAXPATHLEN);
if (domp == NULL)
return (ENODEV);
ppmd = domp->devlist;
if (cmd == PPMSET_NORMAL) {
if (domp->model != PPMD_CPU)
return (EINVAL);
level = STRUCT_FGET(norm, norm);
dcomps = DEVI(ppmd->dip)->devi_pm_components;
pm_comp = &dcomps[ppmd->cmpt].pmc_comp;
for (i = pm_comp->pmc_numlevels; i > 0; i--) {
if (pm_comp->pmc_lvals[i-1] == level)
break;
}
if (i == 0)
return (EINVAL);
ppm_set_topspeed(ppmd, pm_comp->pmc_numlevels - i);
}
level = pm_get_normal_power(ppmd->dip, 0);
STRUCT_FSET(norm, norm, level);
ret = ddi_copyout(STRUCT_BUF(norm), (caddr_t)arg,
STRUCT_SIZE(norm), mode);
if (ret != 0) {
PPMD(D_IOCTL, ("%s: can't copyout, line(%d)\n",
str, __LINE__))
ret = EFAULT;
}
break;
}
#endif
default:
PPMD(D_IOCTL, ("%s: unsupported ioctl command(%d)\n", str, cmd))
return (EINVAL);
}
return (ret);
}
static int ppm_manage_sx(s3a_t *, int);
static int ppm_search_list(pm_searchargs_t *);
/*
* interface between pm framework and ppm driver
*/
/* ARGSUSED */
static int
ppm_ctlops(dev_info_t *dip, dev_info_t *rdip,
ddi_ctl_enum_t ctlop, void *arg, void *result)
{
power_req_t *reqp = (power_req_t *)arg;
ppm_unit_t *unitp;
ppm_domain_t *domp;
ppm_dev_t *ppmd;
char path[MAXNAMELEN];
ppm_owned_t *owned;
int mode;
int ret = DDI_SUCCESS;
int *res = (int *)result;
s3a_t s3args;
#ifdef DEBUG
char *str = "ppm_ctlops";
int mask = ppm_debug & (D_CTLOPS1 | D_CTLOPS2);
char *ctlstr = ppm_get_ctlstr(reqp->request_type, mask);
if (mask && ctlstr)
PPMD(mask, ("%s: %s, %s\n",
str, ddi_binding_name(rdip), ctlstr))
#endif
if (ctlop != DDI_CTLOPS_POWER) {
return (DDI_FAILURE);
}
unitp = (ppm_unit_t *)ddi_get_soft_state(ppm_statep, ppm_inst);
switch (reqp->request_type) {
/* attempt to blink led if indeed all at lowest */
case PMR_PPM_ALL_LOWEST:
mode = (reqp->req.ppm_all_lowest_req.mode == PM_ALL_LOWEST);
if (!(unitp->states & PPM_STATE_SUSPENDED) && mode)
ppm_manage_led(PPM_LED_BLINKING);
else
ppm_manage_led(PPM_LED_SOLIDON);
return (DDI_SUCCESS);
/* undo the claiming of 'rdip' at attach time */
case PMR_PPM_POST_DETACH:
ASSERT(reqp->req.ppm_set_power_req.who == rdip);
mutex_enter(&unitp->lock);
if (reqp->req.ppm_config_req.result != DDI_SUCCESS ||
(PPM_GET_PRIVATE(rdip) == NULL)) {
mutex_exit(&unitp->lock);
return (DDI_FAILURE);
}
mutex_exit(&unitp->lock);
ppm_rem_dev(rdip);
return (DDI_SUCCESS);
/* chance to adjust pwr_cnt if resume is about to power up rdip */
case PMR_PPM_PRE_RESUME:
ppm_svc_resume_ctlop(rdip, reqp);
return (DDI_SUCCESS);
/*
* synchronizing, so that only the owner of the power lock is
* permitted to change device and component's power level.
*/
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);
}
PPMD(D_LOCKS, ("ppm_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)
ppm_lock_all(domp, reqp, result);
else
ppm_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);
case PMR_PPM_INIT_CHILD:
ASSERT(reqp->req.ppm_lock_power_req.who == rdip);
if ((domp = ppm_lookup_dev(rdip)) == NULL)
return (DDI_SUCCESS);
/*
* We keep track of power-manageable devices starting with
* initialization process. The initializing flag remains
* set until it is cleared by ppm_add_dev(). Power management
* policy for some domains are affected even during device
* initialization. For example, PCI domains should leave
* their clock running meanwhile a device in that domain
* is initializing.
*/
mutex_enter(&domp->lock);
owned = ppm_add_owned(rdip, domp);
ASSERT(owned->initializing == 0);
owned->initializing = 1;
if (PPMD_IS_PCI(domp->model) && domp->status == PPMD_OFF) {
ret = ppm_switch_clock(domp, PPMD_ON);
if (ret == DDI_SUCCESS)
domp->dflags |= PPMD_INITCHILD_CLKON;
}
mutex_exit(&domp->lock);
return (ret);
case PMR_PPM_POST_ATTACH:
ASSERT(reqp->req.ppm_config_req.who == rdip);
domp = ppm_lookup_dev(rdip);
ASSERT(domp);
ASSERT(domp->status == PPMD_ON);
if (reqp->req.ppm_config_req.result == DDI_SUCCESS) {
/*
* call ppm_get_dev, which will increment the
* domain power count by the right number.
* Undo the power count increment, done in PRE_PROBE.
*/
if (PM_GET_PM_INFO(rdip))
ppmd = ppm_get_dev(rdip, domp);
mutex_enter(&domp->lock);
ASSERT(domp->pwr_cnt > 0);
domp->pwr_cnt--;
mutex_exit(&domp->lock);
return (DDI_SUCCESS);
}
ret = ppm_power_down_domain(rdip);
/* FALLTHROUGH */
case PMR_PPM_UNINIT_CHILD:
ASSERT(reqp->req.ppm_lock_power_req.who == rdip);
if ((domp = ppm_lookup_dev(rdip)) == NULL)
return (DDI_SUCCESS);
(void) ddi_pathname(rdip, path);
mutex_enter(&domp->lock);
for (owned = domp->owned; owned; owned = owned->next)
if (strcmp(owned->path, path) == 0)
break;
/*
* In case we didn't go through a complete attach and detach,
* the initializing flag will still be set, so clear it.
*/
if ((owned != NULL) && (owned->initializing))
owned->initializing = 0;
if (PPMD_IS_PCI(domp->model) &&
domp->status == PPMD_ON && domp->pwr_cnt == 0 &&
(domp->dflags & PPMD_INITCHILD_CLKON) &&
ppm_none_else_holds_power(domp)) {
ret = ppm_switch_clock(domp, PPMD_OFF);
if (ret == DDI_SUCCESS)
domp->dflags &= ~PPMD_INITCHILD_CLKON;
}
mutex_exit(&domp->lock);
return (ret);
/* place holders */
case PMR_PPM_UNMANAGE:
case PMR_PPM_PRE_DETACH:
return (DDI_SUCCESS);
case PMR_PPM_PRE_PROBE:
ASSERT(reqp->req.ppm_config_req.who == rdip);
return (ppm_power_up_domain(rdip));
case PMR_PPM_POST_PROBE:
ASSERT(reqp->req.ppm_config_req.who == rdip);
if (reqp->req.ppm_config_req.result == DDI_PROBE_SUCCESS ||
reqp->req.ppm_config_req.result == DDI_PROBE_DONTCARE)
return (DDI_SUCCESS);
/* Probe failed */
PPMD(D_CTLOPS1 | D_CTLOPS2, ("%s: probe failed for %s@%s "
"rv %d\n", str, PM_NAME(rdip), PM_ADDR(rdip),
reqp->req.ppm_config_req.result))
return (ppm_power_down_domain(rdip));
case PMR_PPM_PRE_ATTACH:
ASSERT(reqp->req.ppm_config_req.who == rdip);
/* Domain has already been powered up in PRE_PROBE */
domp = ppm_lookup_dev(rdip);
ASSERT(domp);
ASSERT(domp->status == PPMD_ON);
return (DDI_SUCCESS);
/* ppm intercepts power change process to the claimed devices */
case PMR_PPM_SET_POWER:
case PMR_PPM_POWER_CHANGE_NOTIFY:
if ((ppmd = PPM_GET_PRIVATE(rdip)) == NULL) {
domp = ppm_lookup_dev(rdip);
ASSERT(domp);
ppmd = ppm_get_dev(rdip, domp);
}
switch (ppmd->domp->model) {
case PPMD_CPU:
return (ppm_manage_cpus(rdip, reqp, result));
case PPMD_FET:
return (ppm_manage_fet(rdip, reqp, result));
case PPMD_PCI:
case PPMD_PCI_PROP:
return (ppm_manage_pci(rdip, reqp, result));
case PPMD_PCIE:
return (ppm_manage_pcie(rdip, reqp, result));
default:
cmn_err(CE_WARN, "ppm_ctlops: domain model %d does"
" not support PMR_PPM_SET_POWER ctlop",
ppmd->domp->model);
return (DDI_FAILURE);
}
case PMR_PPM_ENTER_SX:
case PMR_PPM_EXIT_SX:
s3args.s3a_state = reqp->req.ppm_power_enter_sx_req.sx_state;
s3args.s3a_test_point =
reqp->req.ppm_power_enter_sx_req.test_point;
s3args.s3a_wakephys = reqp->req.ppm_power_enter_sx_req.wakephys;
s3args.s3a_psr = reqp->req.ppm_power_enter_sx_req.psr;
ret = ppm_manage_sx(&s3args,
reqp->request_type == PMR_PPM_ENTER_SX);
if (ret) {
PPMD(D_CPR, ("ppm_manage_sx returns %d\n", ret))
return (DDI_FAILURE);
} else {
return (DDI_SUCCESS);
}
case PMR_PPM_SEARCH_LIST:
ret = ppm_search_list(reqp->req.ppm_search_list_req.searchlist);
reqp->req.ppm_search_list_req.result = ret;
*res = ret;
if (ret) {
PPMD(D_CPR, ("ppm_search_list returns %d\n", ret))
return (DDI_FAILURE);
} else {
PPMD(D_CPR, ("ppm_search_list returns %d\n", ret))
return (DDI_SUCCESS);
}
default:
cmn_err(CE_WARN, "ppm_ctlops: unrecognized ctlops req(%d)",
reqp->request_type);
return (DDI_FAILURE);
}
}
/*
* 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
*/
int
ppm_revert_cpu_power(ppm_dev_t *ecpup, int level)
{
ppm_dev_t *cpup;
int ret = DDI_SUCCESS;
for (cpup = ecpup->domp->devlist; cpup != ecpup; cpup = cpup->next) {
PPMD(D_CPU, ("ppm_revert_cpu_power: \"%s\", revert to "
"level %d\n", cpup->path, level))
ret = pm_power(cpup->dip, 0, level);
if (ret == DDI_SUCCESS) {
cpup->level = level;
cpup->rplvl = PM_LEVEL_UNKNOWN;
}
}
return (ret);
}
/*
* ppm_manage_cpus - Process a request to change the power level of a cpu.
* If not all cpus want to be at the same level, OR if we are currently
* refusing slowdown requests due to thermal stress, we cache the request.
* Otherwise, set all cpus to the new power level.
*/
/* ARGSUSED */
static int
ppm_manage_cpus(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
char *str = "ppm_manage_cpus";
#endif
int old, new, ret, kmflag;
ppm_dev_t *ppmd, *cpup;
int change_notify = 0;
pm_ppm_devlist_t *devlist = NULL, *p;
int do_rescan = 0;
*result = DDI_SUCCESS;
switch (reqp->request_type) {
case PMR_PPM_SET_POWER:
break;
case PMR_PPM_POWER_CHANGE_NOTIFY:
change_notify = 1;
break;
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;
if (change_notify) {
ppmd->level = new;
ppmd->rplvl = PM_LEVEL_UNKNOWN;
PPMD(D_CPU, ("%s: Notify cpu dip %p power level has changed "
"from %d to %d", str, (void *)dip, old, new))
return (DDI_SUCCESS);
}
if (ppm_manage_early_cpus(dip, new, result))
return (*result);
if (new == ppmd->level) {
PPMD(D_CPU, ("%s: already at power level %d\n", str, new))
return (DDI_SUCCESS);
}
/*
* A request from lower to higher level transition is granted and
* made effective on all cpus. A request from higher to lower must
* be agreed upon by all cpus.
*/
ppmd->rplvl = new;
for (cpup = ppmd->domp->devlist; cpup; cpup = cpup->next) {
if (cpup->rplvl == new)
continue;
if (new < old) {
PPMD(D_SOME, ("%s: not all cpus wants to be at new "
"level %d yet.\n", str, new))
return (DDI_SUCCESS);
}
/*
* If a single cpu requests power up, honor the request
* powering up all cpus.
*/
if (new > old) {
PPMD(D_SOME, ("%s: powering up device(%s@%s, %p) "
"because of request from dip(%s@%s, %p), "
"need pm_rescan\n", str, PM_NAME(cpup->dip),
PM_ADDR(cpup->dip), (void *)cpup->dip,
PM_NAME(dip), PM_ADDR(dip), (void *)dip))
do_rescan++;
}
}
PPMD(D_SETLVL, ("%s: \"%s\" set power level old %d, new %d \n",
str, ppmd->path, ppmd->level, new))
ret = ppm_change_cpu_power(ppmd, 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 (cpup = ppmd->domp->devlist; cpup; cpup = cpup->next) {
if (cpup->dip == dip)
continue;
if ((p = kmem_zalloc(sizeof (pm_ppm_devlist_t),
kmflag)) == NULL) {
break;
}
p->ppd_who = cpup->dip;
p->ppd_cmpt = cpup->cmpt;
p->ppd_old_level = old;
p->ppd_new_level = new;
p->ppd_next = devlist;
PPMD(D_SETLVL, ("%s: devlist entry[\"%s\"] %d -> %d\n",
str, cpup->path, old, new))
devlist = p;
}
reqp->req.ppm_set_power_req.cookie = (void *) devlist;
if (do_rescan > 0) {
for (cpup = ppmd->domp->devlist; cpup;
cpup = cpup->next) {
if (cpup->dip == dip)
continue;
pm_rescan(cpup->dip);
}
}
}
return (ret);
}
/*
* ppm_svc_resume_ctlop - this is a small bookkeeping ppm does -
* increments its FET domain power count, in anticipation of that
* the indicated device(dip) would be powered up by its driver as
* a result of cpr resuming.
*/
/* ARGSUSED */
static void
ppm_svc_resume_ctlop(dev_info_t *dip, power_req_t *reqp)
{
ppm_domain_t *domp;
ppm_dev_t *ppmd;
int powered; /* power up count per dip */
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->model == PPMD_FET) || PPMD_IS_PCI(domp->model) ||
(domp->model == PPMD_PCIE)) {
for (ppmd = domp->devlist; ppmd; ppmd = ppmd->next) {
if (ppmd->dip == dip && ppmd->level)
powered++;
}
/*
* All fets and clocks are held on during suspend -
* resume window regardless their domain devices' power
* level.
*/
ASSERT(domp->status == PPMD_ON);
/*
* The difference indicates the number of components
* being off prior to suspend operation, that is the
* amount needs to be compensated in order to sync up
* bookkeeping with reality, for PROM reset would have
* brought up all devices.
*/
if (powered < PM_NUMCMPTS(dip))
domp->pwr_cnt += PM_NUMCMPTS(dip) - powered;
}
for (ppmd = domp->devlist; ppmd; ppmd = ppmd->next) {
if (ppmd->dip == dip)
ppmd->level = ppmd->rplvl = PM_LEVEL_UNKNOWN;
}
mutex_exit(&domp->lock);
}
#ifdef DEBUG
static int ppmbringup = 0;
#endif
int
ppm_bringup_domains()
{
#ifdef DEBUG
char *str = "ppm_bringup_domains";
#endif
ppm_domain_t *domp;
int ret = DDI_SUCCESS;
PPMD(D_CPR, ("%s[%d]: enter\n", str, ++ppmbringup))
for (domp = ppm_domain_p; domp; domp = domp->next) {
if ((!PPMD_IS_PCI(domp->model) && (domp->model != PPMD_FET) &&
(domp->model != PPMD_PCIE)) || (domp->devlist == NULL))
continue;
mutex_enter(&domp->lock);
if (domp->status == PPMD_ON) {
mutex_exit(&domp->lock);
continue;
}
switch (domp->model) {
case PPMD_FET:
ret = ppm_fetset(domp, PPMD_ON);
break;
case PPMD_PCI:
case PPMD_PCI_PROP:
ret = ppm_switch_clock(domp, PPMD_ON);
break;
case PPMD_PCIE:
ret = ppm_pcie_pwr(domp, PPMD_ON);
break;
default:
break;
}
mutex_exit(&domp->lock);
}
PPMD(D_CPR, ("%s[%d]: exit\n", str, ppmbringup))
return (ret);
}
#ifdef DEBUG
static int ppmsyncbp = 0;
#endif
int
ppm_sync_bookkeeping()
{
#ifdef DEBUG
char *str = "ppm_sync_bookkeeping";
#endif
ppm_domain_t *domp;
int ret = DDI_SUCCESS;
PPMD(D_CPR, ("%s[%d]: enter\n", str, ++ppmsyncbp))
for (domp = ppm_domain_p; domp; domp = domp->next) {
if ((!PPMD_IS_PCI(domp->model) && (domp->model != PPMD_FET) &&
(domp->model != PPMD_PCIE)) || (domp->devlist == NULL))
continue;
mutex_enter(&domp->lock);
if ((domp->pwr_cnt != 0) || !ppm_none_else_holds_power(domp)) {
mutex_exit(&domp->lock);
continue;
}
/*
* skip NULL .devlist slot, for some may host pci device
* that can not tolerate clock off or not even participate
* in PM.
*/
if (domp->devlist == NULL)
continue;
switch (domp->model) {
case PPMD_FET:
ret = ppm_fetset(domp, PPMD_OFF);
break;
case PPMD_PCI:
case PPMD_PCI_PROP:
ret = ppm_switch_clock(domp, PPMD_OFF);
break;
case PPMD_PCIE:
ret = ppm_pcie_pwr(domp, PPMD_OFF);
break;
default:
break;
}
mutex_exit(&domp->lock);
}
PPMD(D_CPR, ("%s[%d]: exit\n", str, ppmsyncbp))
return (ret);
}
/*
* pre-suspend window;
*
* power up every FET and PCI clock that are off;
*
* set ppm_cpr_window global flag to indicate
* that even though all pm_scan requested power transitions
* will be honored as usual but that until we're out
* of this window, no FET or clock will be turned off
* for domains with pwr_cnt decremented down to 0.
* Such is to avoid accessing the orthogonal drivers that own
* the FET and clock registers that may not be resumed yet.
*
* at post-resume window, walk through each FET and PCI domains,
* bring pwr_cnt and domp->status to sense: if pwr-cnt == 0,
* and noinvol check okays, power down the FET or PCI. At last,
* clear the global flag ppm_cpr_window.
*
* ASSERT case 1, during cpr window, checks pwr_cnt against power
* transitions;
* ASSERT case 2, out of cpr window, checks four things:
* pwr_cnt <> power transition in/out of 0
* <> status <> record of noinvol device detached
*
*/
/* ARGSUSED */
static boolean_t
ppm_cpr_callb(void *arg, int code)
{
int ret;
switch (code) {
case CB_CODE_CPR_CHKPT:
/* pre-suspend: start of cpr window */
mutex_enter(&ppm_cpr_window_lock);
ASSERT(ppm_cpr_window_flag == B_FALSE);
ppm_cpr_window_flag = B_TRUE;
mutex_exit(&ppm_cpr_window_lock);
ret = ppm_bringup_domains();
break;
case CB_CODE_CPR_RESUME:
/* post-resume: end of cpr window */
ret = ppm_sync_bookkeeping();
mutex_enter(&ppm_cpr_window_lock);
ASSERT(ppm_cpr_window_flag == B_TRUE);
ppm_cpr_window_flag = B_FALSE;
mutex_exit(&ppm_cpr_window_lock);
break;
}
return (ret == DDI_SUCCESS);
}
/*
* Initialize our private version of real power level
* as well as lowest and highest levels the device supports;
* relate to ppm_add_dev
*/
void
ppm_dev_init(ppm_dev_t *ppmd)
{
struct pm_component *dcomps;
struct pm_comp *pm_comp;
dev_info_t *dip;
int maxi, i;
ASSERT(MUTEX_HELD(&ppmd->domp->lock));
ppmd->level = PM_LEVEL_UNKNOWN;
ppmd->rplvl = PM_LEVEL_UNKNOWN;
/* increment pwr_cnt per component */
if ((ppmd->domp->model == PPMD_FET) ||
PPMD_IS_PCI(ppmd->domp->model) ||
(ppmd->domp->model == PPMD_PCIE))
ppmd->domp->pwr_cnt++;
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];
/*
* If 66mhz PCI device on pci 66mhz bus supports D2 state
* (config reg PMC bit 10 set), ppm could turn off its bus
* clock once it is at D3hot.
*/
if (ppmd->domp->dflags & PPMD_PCI66MHZ) {
for (i = 0; i < maxi; i++)
if (pm_comp->pmc_lvals[i] == PM_LEVEL_D2) {
ppmd->flags |= PPMDEV_PCI66_D2;
break;
}
}
}
/*
* If device is in PCI_PROP domain and has exported the
* property listed in ppm.conf, its clock will be turned
* off when all pm'able devices in that domain are at D3.
*/
if ((ppmd->domp->model == PPMD_PCI_PROP) &&
(ppmd->domp->propname != NULL) &&
ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
ppmd->domp->propname))
ppmd->flags |= PPMDEV_PCI_PROP_CLKPM;
}
/*
* relate to ppm_rem_dev
*/
void
ppm_dev_fini(ppm_dev_t *ppmd)
{
ASSERT(MUTEX_HELD(&ppmd->domp->lock));
/* decrement pwr_cnt per component */
if ((ppmd->domp->model == PPMD_FET) ||
PPMD_IS_PCI(ppmd->domp->model) ||
(ppmd->domp->model == PPMD_PCIE))
if (ppmd->level != ppmd->lowest)
ppmd->domp->pwr_cnt--;
}
/*
* Each power fet controls the power of one or more platform
* device(s) within their domain. Hence domain devices' power
* level change has been monitored, such that once all devices
* are powered off, the fet is turned off to save more power.
*
* To power on any domain device, the domain power fet
* needs to be turned on first. always one fet per domain.
*/
static int
ppm_manage_fet(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
char *str = "ppm_manage_fet";
#endif
int (*pwr_func)(ppm_dev_t *, int, int);
int new, old, cmpt;
ppm_dev_t *ppmd;
ppm_domain_t *domp;
int incr = 0;
int dummy_ret;
*result = DDI_SUCCESS;
switch (reqp->request_type) {
case PMR_PPM_SET_POWER:
pwr_func = ppm_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 = ppm_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:
*result = DDI_FAILURE;
PPMD(D_FET, ("%s: unknown request type %d for %s@%s\n",
str, reqp->request_type, PM_NAME(dip), PM_ADDR(dip)))
return (DDI_FAILURE);
}
for (ppmd = PPM_GET_PRIVATE(dip); ppmd; ppmd = ppmd->next)
if (cmpt == ppmd->cmpt)
break;
if (!ppmd) {
PPMD(D_FET, ("%s: dip(%p): old(%d)->new(%d): no ppm_dev"
" found for cmpt(%d)", str, (void *)dip, old, new, cmpt))
*result = DDI_FAILURE;
return (DDI_FAILURE);
}
domp = ppmd->domp;
PPMD(D_FET, ("%s: %s@%s %s old %d, new %d, c%d, level %d, "
"status %s\n", str, PM_NAME(dip), PM_ADDR(dip),
ppm_get_ctlstr(reqp->request_type, ~0), old, new, cmpt,
ppmd->level, (domp->status == PPMD_OFF ? "off" : "on")))
ASSERT(old == ppmd->level);
if (new == ppmd->level) {
PPMD(D_FET, ("nop\n"))
return (DDI_SUCCESS);
}
PPM_LOCK_DOMAIN(domp);
/*
* In general, a device's published lowest power level does not
* have to be 0 if power-off is not tolerated. i.e. a device
* instance may export its lowest level > 0. It is reasonable to
* assume that level 0 indicates off state, positive level values
* indicate power states above off, include full power state.
*/
if (new > 0) { /* device powering up or to different positive level */
if (domp->status == PPMD_OFF) {
/* can not be in (chpt, resume) window */
ASSERT(ppm_cpr_window_flag == B_FALSE);
ASSERT(old == 0 && domp->pwr_cnt == 0);
PPMD(D_FET, ("About to turn fet on for %s@%s c%d\n",
PM_NAME(dip), PM_ADDR(dip), cmpt))
*result = ppm_fetset(domp, PPMD_ON);
if (*result != DDI_SUCCESS) {
PPMD(D_FET, ("\tCan't turn on power FET: "
"ret(%d)\n", *result))
PPM_UNLOCK_DOMAIN(domp);
return (DDI_FAILURE);
}
}
/*
* If powering up, pre-increment the count before
* calling pwr_func, because we are going to release
* the domain lock and another thread might turn off
* domain power otherwise.
*/
if (old == 0) {
domp->pwr_cnt++;
incr = 1;
}
PPMD(D_FET, ("\t%s domain power count: %d\n",
domp->name, domp->pwr_cnt))
}
PPM_UNLOCK_DOMAIN(domp);
ASSERT(domp->pwr_cnt > 0);
if ((*result = (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS) {
PPMD(D_FET, ("\t%s power change failed: ret(%d)\n",
ppmd->path, *result))
}
PPM_LOCK_DOMAIN(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(domp->pwr_cnt > 0);
domp->pwr_cnt--;
}
PPMD(D_FET, ("\t%s domain power count: %d\n",
domp->name, domp->pwr_cnt))
/*
* call to pwr_func will update ppm data structures, if it
* succeeds. ppm should return whatever is the return value
* from call to pwr_func. This way pm and ppm data structures
* always in sync. Use dummy_ret from here for any further
* return values.
*/
if ((domp->pwr_cnt == 0) &&
(ppm_cpr_window_flag == B_FALSE) &&
ppm_none_else_holds_power(domp)) {
PPMD(D_FET, ("About to turn FET off for %s@%s c%d\n",
PM_NAME(dip), PM_ADDR(dip), cmpt))
dummy_ret = ppm_fetset(domp, PPMD_OFF);
if (dummy_ret != DDI_SUCCESS) {
PPMD(D_FET, ("\tCan't turn off FET: ret(%d)\n",
dummy_ret))
}
}
PPM_UNLOCK_DOMAIN(domp);
ASSERT(domp->pwr_cnt >= 0);
return (*result);
}
/*
* the actual code that turn on or off domain power fet and
* update domain status
*/
static int
ppm_fetset(ppm_domain_t *domp, uint8_t value)
{
char *str = "ppm_fetset";
int key;
ppm_dc_t *dc;
int ret;
clock_t temp;
clock_t delay = 0;
key = (value == PPMD_ON) ? PPMDC_FET_ON : PPMDC_FET_OFF;
for (dc = domp->dc; dc; dc = dc->next)
if (dc->cmd == key)
break;
if (!dc || !dc->lh) {
PPMD(D_FET, ("%s: %s domain: NULL ppm_dc handle\n",
str, domp->name))
return (DDI_FAILURE);
}
if (key == PPMDC_FET_ON) {
PPM_GET_IO_DELAY(dc, delay);
if (delay > 0 && domp->last_off_time > 0) {
/*
* provide any delay required before turning on.
* some devices e.g. Samsung DVD require minimum
* of 1 sec between OFF->ON. no delay is required
* for the first time.
*/
temp = ddi_get_lbolt();
temp -= domp->last_off_time;
temp = drv_hztousec(temp);
if (temp < delay) {
/*
* busy wait untill we meet the
* required delay. Since we maintain
* time stamps in terms of clock ticks
* we might wait for longer than required
*/
PPMD(D_FET, ("%s : waiting %lu micro seconds "
"before on\n", domp->name,
delay - temp));
drv_usecwait(delay - temp);
}
}
}
switch (dc->method) {
#ifdef sun4u
case PPMDC_I2CKIO: {
i2c_gpio_t i2c_req;
i2c_req.reg_mask = dc->m_un.i2c.mask;
i2c_req.reg_val = dc->m_un.i2c.val;
ret = ldi_ioctl(dc->lh, dc->m_un.i2c.iowr,
(intptr_t)&i2c_req, FWRITE | FKIOCTL, kcred, NULL);
break;
}
#endif
case PPMDC_KIO:
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iowr,
(intptr_t)&(dc->m_un.kio.val), FWRITE | FKIOCTL, kcred,
NULL);
break;
default:
PPMD(D_FET, ("\t%s: unsupported domain control method %d\n",
str, domp->dc->method))
return (DDI_FAILURE);
}
PPMD(D_FET, ("%s: %s domain(%s) FET from %s to %s\n", str,
(ret == 0) ? "turned" : "failed to turn",
domp->name,
(domp->status == PPMD_ON) ? "ON" : "OFF",
(value == PPMD_ON) ? "ON" : "OFF"))
if (ret == DDI_SUCCESS) {
domp->status = value;
if (key == PPMDC_FET_OFF)
/*
* record the time, when it is off. time is recorded
* in clock ticks
*/
domp->last_off_time = ddi_get_lbolt();
/* implement any post op delay. */
if (key == PPMDC_FET_ON) {
PPM_GET_IO_POST_DELAY(dc, delay);
PPMD(D_FET, ("%s : waiting %lu micro seconds "
"after on\n", domp->name, delay))
if (delay > 0)
drv_usecwait(delay);
}
}
return (ret);
}
/*
* read power fet status
*/
static int
ppm_fetget(ppm_domain_t *domp, uint8_t *lvl)
{
char *str = "ppm_fetget";
ppm_dc_t *dc = domp->dc;
uint_t kio_val;
int off_val;
int ret;
if (!dc->lh) {
PPMD(D_FET, ("%s: %s domain NULL ppm_dc layered handle\n",
str, domp->name))
return (DDI_FAILURE);
}
if (!dc->next) {
cmn_err(CE_WARN, "%s: expect both fet on and fet off ops "
"defined, found only one in domain(%s)", str, domp->name);
return (DDI_FAILURE);
}
switch (dc->method) {
#ifdef sun4u
case PPMDC_I2CKIO: {
i2c_gpio_t i2c_req;
i2c_req.reg_mask = dc->m_un.i2c.mask;
ret = ldi_ioctl(dc->lh, dc->m_un.i2c.iord,
(intptr_t)&i2c_req, FWRITE | FKIOCTL, kcred, NULL);
if (ret) {
PPMD(D_FET, ("%s: PPMDC_I2CKIO failed: ret(%d)\n",
str, ret))
return (ret);
}
off_val = (dc->cmd == PPMDC_FET_OFF) ? dc->m_un.i2c.val :
dc->next->m_un.i2c.val;
*lvl = (i2c_req.reg_val == off_val) ? PPMD_OFF : PPMD_ON;
PPMD(D_FET, ("%s: %s domain FET %s\n", str, domp->name,
(i2c_req.reg_val == off_val) ? "OFF" : "ON"))
break;
}
#endif
case PPMDC_KIO:
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iord,
(intptr_t)&kio_val, FWRITE | FKIOCTL, kcred, NULL);
if (ret) {
PPMD(D_FET, ("%s: PPMDC_KIO failed: ret(%d)\n",
str, ret))
return (ret);
}
off_val = (dc->cmd == PPMDC_FET_OFF) ? dc->m_un.kio.val :
dc->next->m_un.kio.val;
*lvl = (kio_val == off_val) ? PPMD_OFF : PPMD_ON;
PPMD(D_FET, ("%s: %s domain FET %s\n", str, domp->name,
(kio_val == off_val) ? "OFF" : "ON"))
break;
default:
PPMD(D_FET, ("%s: unsupported domain control method %d\n",
str, domp->dc->method))
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
/*
* the actual code that switches pci clock and update domain status
*/
static int
ppm_switch_clock(ppm_domain_t *domp, int onoff)
{
#ifdef DEBUG
char *str = "ppm_switch_clock";
#endif
int cmd, pio_save;
ppm_dc_t *dc;
int ret;
extern int do_polled_io;
extern uint_t cfb_inuse;
ppm_dev_t *pdev;
cmd = (onoff == PPMD_ON) ? PPMDC_CLK_ON : PPMDC_CLK_OFF;
dc = ppm_lookup_dc(domp, cmd);
if (!dc) {
PPMD(D_PCI, ("%s: no ppm_dc found for domain (%s)\n",
str, domp->name))
return (DDI_FAILURE);
}
switch (dc->method) {
case PPMDC_KIO:
/*
* If we're powering up cfb on a Stop-A, we only
* want to do polled i/o to turn ON the clock
*/
pio_save = do_polled_io;
if ((cfb_inuse) && (cmd == PPMDC_CLK_ON)) {
for (pdev = domp->devlist; pdev; pdev = pdev->next) {
if (pm_is_cfb(pdev->dip)) {
do_polled_io = 1;
break;
}
}
}
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iowr,
(intptr_t)&(dc->m_un.kio.val), FWRITE | FKIOCTL,
kcred, NULL);
do_polled_io = pio_save;
if (ret == 0) {
if (cmd == PPMDC_CLK_ON) {
domp->status = PPMD_ON;
/*
* PCI PM spec requires 50ms delay
*/
drv_usecwait(50000);
} else
domp->status = PPMD_OFF;
}
PPMD(D_PCI, ("%s: %s pci clock %s for domain (%s)\n", str,
(ret == 0) ? "turned" : "failed to turn",
(cmd == PPMDC_CLK_OFF) ? "OFF" : "ON",
domp->name))
break;
default:
PPMD(D_PCI, ("%s: unsupported domain control method %d\n",
str, dc->method))
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
/*
* pci slot domain is formed of pci device(s) reside in a pci slot.
* This function monitors domain device's power level change, such
* that,
* when all domain power count has gone to 0, it attempts to turn off
* the pci slot's clock;
* if any domain device is powering up, it'll turn on the pci slot's
* clock as the first thing.
*/
/* ARGUSED */
static int
ppm_manage_pci(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
char *str = "ppm_manage_pci";
#endif
int (*pwr_func)(ppm_dev_t *, int, int);
int old, new, cmpt;
ppm_dev_t *ppmd;
ppm_domain_t *domp;
int incr = 0;
int dummy_ret;
*result = DDI_SUCCESS;
switch (reqp->request_type) {
case PMR_PPM_SET_POWER:
pwr_func = ppm_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 = ppm_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:
*result = DDI_FAILURE;
return (DDI_FAILURE);
}
for (ppmd = PPM_GET_PRIVATE(dip); ppmd; ppmd = ppmd->next)
if (cmpt == ppmd->cmpt)
break;
if (!ppmd) {
PPMD(D_PCI, ("%s: dip(%p): old(%d), new(%d): no ppm_dev"
" found for cmpt(%d)", str, (void *)dip, old, new, cmpt))
*result = DDI_FAILURE;
return (DDI_FAILURE);
}
domp = ppmd->domp;
PPMD(D_PCI, ("%s: %s, dev(%s), c%d, old %d, new %d\n", str,
ppm_get_ctlstr(reqp->request_type, ~0),
ppmd->path, cmpt, old, new))
ASSERT(old == ppmd->level);
if (new == ppmd->level)
return (DDI_SUCCESS);
PPM_LOCK_DOMAIN(domp);
if (new > 0) { /* device powering up */
if (domp->status == PPMD_OFF) {
/* cannot be off during (chpt, resume) window */
ASSERT(ppm_cpr_window_flag == B_FALSE);
/* either both OFF or both ON */
ASSERT(!((old == 0) ^ (domp->pwr_cnt == 0)));
PPMD(D_PCI, ("About to turn clock on for %s@%s c%d\n",
PM_NAME(dip), PM_ADDR(dip), cmpt))
*result = ppm_switch_clock(domp, PPMD_ON);
if (*result != DDI_SUCCESS) {
PPMD(D_PCI, ("\tcan't switch on pci clock: "
"ret(%d)\n", *result))
PPM_UNLOCK_DOMAIN(domp);
return (DDI_FAILURE);
}
}
if (old == 0) {
domp->pwr_cnt++;
incr = 1;
}
PPMD(D_PCI, ("\t%s domain power count: %d\n",
domp->name, domp->pwr_cnt))
}
PPM_UNLOCK_DOMAIN(domp);
ASSERT(domp->pwr_cnt > 0);
if ((*result = (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS) {
PPMD(D_PCI, ("\t%s power change failed: ret(%d)\n",
ppmd->path, *result))
}
PPM_LOCK_DOMAIN(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(domp->pwr_cnt > 0);
domp->pwr_cnt--;
}
PPMD(D_PCI, ("\t%s domain power count: %d\n",
domp->name, domp->pwr_cnt))
/*
* call to pwr_func will update ppm data structures, if it
* succeeds. ppm should return whatever is the return value
* from call to pwr_func. This way pm and ppm data structures
* always in sync. Use dummy_ret from here for any further
* return values.
*/
if ((domp->pwr_cnt == 0) &&
(ppm_cpr_window_flag == B_FALSE) &&
ppm_none_else_holds_power(domp)) {
PPMD(D_PCI, ("About to turn clock off for %s@%s c%d\n",
PM_NAME(dip), PM_ADDR(dip), cmpt))
dummy_ret = ppm_switch_clock(domp, PPMD_OFF);
if (dummy_ret != DDI_SUCCESS) {
PPMD(D_PCI, ("\tCan't switch clock off: "
"ret(%d)\n", dummy_ret))
}
}
PPM_UNLOCK_DOMAIN(domp);
ASSERT(domp->pwr_cnt >= 0);
return (*result);
}
/*
* When the driver for the primary PCI-Express child has set the device to
* lowest power (D3hot), we come here to save even more power by transitioning
* the slot to D3cold. Similarly, if the slot is in D3cold and we need to
* power up the child, we come here first to power up the slot.
*/
/* ARGUSED */
static int
ppm_manage_pcie(dev_info_t *dip, power_req_t *reqp, int *result)
{
#ifdef DEBUG
char *str = "ppm_manage_pcie";
#endif
int (*pwr_func)(ppm_dev_t *, int, int);
int old, new, cmpt;
ppm_dev_t *ppmd;
ppm_domain_t *domp;
int incr = 0;
int dummy_ret;
*result = DDI_SUCCESS;
switch (reqp->request_type) {
case PMR_PPM_SET_POWER:
pwr_func = ppm_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 = ppm_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:
*result = DDI_FAILURE;
return (DDI_FAILURE);
}
for (ppmd = PPM_GET_PRIVATE(dip); ppmd; ppmd = ppmd->next)
if (cmpt == ppmd->cmpt)
break;
if (!ppmd) {
PPMD(D_PCI, ("%s: dip(%p): old(%d), new(%d): no ppm_dev"
" found for cmpt(%d)", str, (void *)dip, old, new, cmpt))
*result = DDI_FAILURE;
return (DDI_FAILURE);
}
domp = ppmd->domp;
PPMD(D_PCI, ("%s: %s, dev(%s), c%d, old %d, new %d\n", str,
ppm_get_ctlstr(reqp->request_type, ~0),
ppmd->path, cmpt, old, new))
ASSERT(old == ppmd->level);
if (new == ppmd->level)
return (DDI_SUCCESS);
PPM_LOCK_DOMAIN(domp);
if (new > 0) { /* device powering up */
if (domp->status == PPMD_OFF) {
/* cannot be off during (chpt, resume) window */
ASSERT(ppm_cpr_window_flag == B_FALSE);
/* either both OFF or both ON */
ASSERT(!((old == 0) ^ (domp->pwr_cnt == 0)));
PPMD(D_PCI, ("About to turn on pcie slot for "
"%s@%s c%d\n", PM_NAME(dip), PM_ADDR(dip), cmpt))
*result = ppm_pcie_pwr(domp, PPMD_ON);
if (*result != DDI_SUCCESS) {
PPMD(D_PCI, ("\tcan't switch on pcie slot: "
"ret(%d)\n", *result))
PPM_UNLOCK_DOMAIN(domp);
return (DDI_FAILURE);
}
}
if (old == 0) {
domp->pwr_cnt++;
incr = 1;
}
PPMD(D_PCI, ("\t%s domain power count: %d\n",
domp->name, domp->pwr_cnt))
}
PPM_UNLOCK_DOMAIN(domp);
ASSERT(domp->pwr_cnt > 0);
if ((*result = (*pwr_func)(ppmd, cmpt, new)) != DDI_SUCCESS) {
PPMD(D_PCI, ("\t%s power change failed: ret(%d)\n",
ppmd->path, *result))
}
PPM_LOCK_DOMAIN(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(domp->pwr_cnt > 0);
domp->pwr_cnt--;
}
PPMD(D_PCI, ("\t%s domain power count: %d\n",
domp->name, domp->pwr_cnt))
/*
* call to pwr_func will update ppm data structures, if it
* succeeds. ppm should return whatever is the return value
* from call to pwr_func. This way pm and ppm data structures
* always in sync. Use dummy_ret from here for any further
* return values.
*/
if ((domp->pwr_cnt == 0) &&
(ppm_cpr_window_flag == B_FALSE) &&
ppm_none_else_holds_power(domp)) {
PPMD(D_PCI, ("About to turn off pcie slot for %s@%s c%d\n",
PM_NAME(dip), PM_ADDR(dip), cmpt))
dummy_ret = ppm_pcie_pwr(domp, PPMD_OFF);
if (dummy_ret != DDI_SUCCESS) {
PPMD(D_PCI, ("\tCan't switch pcie slot off: "
"ret(%d)\n", dummy_ret))
}
}
PPM_UNLOCK_DOMAIN(domp);
ASSERT(domp->pwr_cnt >= 0);
return (*result);
}
/*
* Set or clear a bit on a GPIO device. These bits are used for various device-
* specific purposes.
*/
static int
ppm_gpioset(ppm_domain_t *domp, int key)
{
#ifdef DEBUG
char *str = "ppm_gpioset";
#endif
ppm_dc_t *dc;
int ret;
clock_t delay = 0;
for (dc = domp->dc; dc; dc = dc->next)
if (dc->cmd == key)
break;
if (!dc || !dc->lh) {
PPMD(D_GPIO, ("%s: %s domain: NULL ppm_dc handle\n",
str, domp->name))
return (DDI_FAILURE);
}
PPM_GET_IO_DELAY(dc, delay);
if (delay > 0) {
PPMD(D_GPIO, ("%s : waiting %lu micro seconds "
"before change\n", domp->name, delay))
drv_usecwait(delay);
}
switch (dc->method) {
#ifdef sun4u
case PPMDC_I2CKIO: {
i2c_gpio_t i2c_req;
ppm_dev_t *pdev;
int pio_save;
extern int do_polled_io;
extern uint_t cfb_inuse;
i2c_req.reg_mask = dc->m_un.i2c.mask;
i2c_req.reg_val = dc->m_un.i2c.val;
pio_save = do_polled_io;
if (cfb_inuse) {
for (pdev = domp->devlist; pdev; pdev = pdev->next) {
if (pm_is_cfb(pdev->dip)) {
do_polled_io = 1;
PPMD(D_GPIO, ("%s: cfb is in use, "
"i2c transaction is done in "
"poll-mode.\n", str))
break;
}
}
}
ret = ldi_ioctl(dc->lh, dc->m_un.i2c.iowr,
(intptr_t)&i2c_req, FWRITE | FKIOCTL, kcred, NULL);
do_polled_io = pio_save;
PPMD(D_GPIO, ("%s: %s domain(%s) from %s by writing %x "
"to gpio\n",
str, (ret == 0) ? "turned" : "FAILed to turn",
domp->name,
(domp->status == PPMD_ON) ? "ON" : "OFF",
dc->m_un.i2c.val))
break;
}
#endif
case PPMDC_KIO:
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iowr,
(intptr_t)&(dc->m_un.kio.val), FWRITE | FKIOCTL, kcred,
NULL);
PPMD(D_GPIO, ("%s: %s domain(%s) from %s by writing %x "
"to gpio\n",
str, (ret == 0) ? "turned" : "FAILed to turn",
domp->name,
(domp->status == PPMD_ON) ? "ON" : "OFF",
dc->m_un.kio.val))
break;
default:
PPMD(D_GPIO, ("\t%s: unsupported domain control method %d\n",
str, domp->dc->method))
return (DDI_FAILURE);
}
/* implement any post op delay. */
PPM_GET_IO_POST_DELAY(dc, delay);
if (delay > 0) {
PPMD(D_GPIO, ("%s : waiting %lu micro seconds "
"after change\n", domp->name, delay))
drv_usecwait(delay);
}
return (ret);
}
static int
ppm_pcie_pwr(ppm_domain_t *domp, int onoff)
{
#ifdef DEBUG
char *str = "ppm_pcie_pwr";
#endif
int ret = DDI_FAILURE;
ppm_dc_t *dc;
clock_t delay;
ASSERT(onoff == PPMD_OFF || onoff == PPMD_ON);
dc = ppm_lookup_dc(domp,
onoff == PPMD_ON ? PPMDC_PRE_PWR_ON : PPMDC_PRE_PWR_OFF);
if (dc) {
/*
* Invoke layered ioctl for pcie root complex nexus to
* transition the link
*/
ASSERT(dc->method == PPMDC_KIO);
delay = dc->m_un.kio.delay;
if (delay > 0) {
PPMD(D_GPIO, ("%s : waiting %lu micro seconds "
"before change\n", domp->name, delay))
drv_usecwait(delay);
}
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iowr,
(intptr_t)&(dc->m_un.kio.val),
FWRITE | FKIOCTL, kcred, NULL);
if (ret == DDI_SUCCESS) {
delay = dc->m_un.kio.post_delay;
if (delay > 0) {
PPMD(D_GPIO, ("%s : waiting %lu micro seconds "
"after change\n", domp->name, delay))
drv_usecwait(delay);
}
} else {
PPMD(D_PCI, ("%s: ldi_ioctl FAILED for domain(%s)\n",
str, domp->name))
return (ret);
}
}
switch (onoff) {
case PPMD_OFF:
/* Turn off the clock for this slot. */
if ((ret = ppm_gpioset(domp, PPMDC_CLK_OFF)) != DDI_SUCCESS) {
PPMD(D_GPIO,
("%s: failed to turn off domain(%s) clock\n",
str, domp->name))
return (ret);
}
/* Turn off the power to this slot */
if ((ret = ppm_gpioset(domp, PPMDC_PWR_OFF)) != DDI_SUCCESS) {
PPMD(D_GPIO,
("%s: failed to turn off domain(%s) power\n",
str, domp->name))
return (ret);
}
break;
case PPMD_ON:
/* Assert RESET for this slot. */
if ((ret = ppm_gpioset(domp, PPMDC_RESET_ON)) != DDI_SUCCESS) {
PPMD(D_GPIO,
("%s: failed to assert reset for domain(%s)\n",
str, domp->name))
return (ret);
}
/* Turn on the power to this slot */
if ((ret = ppm_gpioset(domp, PPMDC_PWR_ON)) != DDI_SUCCESS) {
PPMD(D_GPIO,
("%s: failed to turn on domain(%s) power\n",
str, domp->name))
return (ret);
}
/* Turn on the clock for this slot */
if ((ret = ppm_gpioset(domp, PPMDC_CLK_ON)) != DDI_SUCCESS) {
PPMD(D_GPIO,
("%s: failed to turn on domain(%s) clock\n",
str, domp->name))
return (ret);
}
/* De-assert RESET for this slot. */
if ((ret = ppm_gpioset(domp, PPMDC_RESET_OFF)) != DDI_SUCCESS) {
PPMD(D_GPIO,
("%s: failed to de-assert reset for domain(%s)\n",
str, domp->name))
return (ret);
}
dc = ppm_lookup_dc(domp, PPMDC_POST_PWR_ON);
if (dc) {
/*
* Invoke layered ioctl to PCIe root complex nexus
* to transition the link.
*/
ASSERT(dc->method == PPMDC_KIO);
delay = dc->m_un.kio.delay;
if (delay > 0) {
PPMD(D_GPIO, ("%s: waiting %lu micro seconds "
"before change\n", domp->name, delay))
drv_usecwait(delay);
}
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iowr,
(intptr_t)&(dc->m_un.kio.val),
FWRITE | FKIOCTL, kcred, NULL);
if (ret != DDI_SUCCESS) {
PPMD(D_PCI, ("%s: layered ioctl to PCIe"
"root complex nexus FAILed\n", str))
return (ret);
}
delay = dc->m_un.kio.post_delay;
if (delay > 0) {
PPMD(D_GPIO, ("%s: waiting %lu micro "
"seconds after change\n",
domp->name, delay))
drv_usecwait(delay);
}
}
break;
default:
ASSERT(0);
}
PPMD(D_PCI, ("%s: turned domain(%s) PCIe slot power from %s to %s\n",
str, domp->name, (domp->status == PPMD_ON) ? "ON" : "OFF",
onoff == PPMD_ON ? "ON" : "OFF"))
domp->status = onoff;
return (ret);
}
/*
* 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
ppm_set_level(ppm_dev_t *ppmd, int cmpt, int level, boolean_t change)
{
#ifdef DEBUG
char *str = "ppm_set_level";
#endif
int ret;
ret = DDI_SUCCESS;
if (change)
ret = pm_power(ppmd->dip, cmpt, level);
PPMD(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
ppm_change_power_level(ppm_dev_t *ppmd, int cmpt, int level)
{
return (ppm_set_level(ppmd, cmpt, level, B_TRUE));
}
static int
ppm_record_level_change(ppm_dev_t *ppmd, int cmpt, int level)
{
return (ppm_set_level(ppmd, cmpt, level, B_FALSE));
}
static void
ppm_manage_led(int action)
{
ppm_domain_t *domp;
ppm_unit_t *unitp;
timeout_id_t tid;
PPMD(D_LED, ("ppm_manage_led: action: %s\n",
(action == PPM_LED_BLINKING) ? "PPM_LED_BLINKING" :
"PPM_LED_SOLIDON"))
/*
* test whether led operation is practically supported,
* if not, we waive without pressing for reasons
*/
if (!ppm_lookup_dc(NULL, PPMDC_LED_ON))
return;
unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
for (domp = ppm_domain_p; (domp && (domp->model != PPMD_LED)); )
domp = domp->next;
mutex_enter(&unitp->lock);
if (action == PPM_LED_BLINKING) {
ppm_set_led(domp, PPMD_OFF);
unitp->led_tid = timeout(
ppm_blink_led, domp, PPM_LEDOFF_INTERVAL);
} else { /* PPM_LED_SOLIDON */
ASSERT(action == PPM_LED_SOLIDON);
tid = unitp->led_tid;
unitp->led_tid = 0;
mutex_exit(&unitp->lock);
(void) untimeout(tid);
mutex_enter(&unitp->lock);
ppm_set_led(domp, PPMD_ON);
}
mutex_exit(&unitp->lock);
}
static void
ppm_set_led(ppm_domain_t *domp, int val)
{
int ret;
ret = ppm_gpioset(domp,
(val == PPMD_ON) ? PPMDC_LED_ON : PPMDC_LED_OFF);
PPMD(D_LED, ("ppm_set_led: %s LED from %s\n",
(ret == 0) ? "turned" : "FAILed to turn",
(domp->status == PPMD_ON) ? "ON to OFF" : "OFF to ON"))
if (ret == DDI_SUCCESS)
domp->status = val;
}
static void
ppm_blink_led(void *arg)
{
ppm_unit_t *unitp;
clock_t intvl;
ppm_domain_t *domp = arg;
unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
mutex_enter(&unitp->lock);
if (unitp->led_tid == 0) {
mutex_exit(&unitp->lock);
return;
}
if (domp->status == PPMD_ON) {
ppm_set_led(domp, PPMD_OFF);
intvl = PPM_LEDOFF_INTERVAL;
} else {
ppm_set_led(domp, PPMD_ON);
intvl = PPM_LEDON_INTERVAL;
}
unitp->led_tid = timeout(ppm_blink_led, domp, intvl);
mutex_exit(&unitp->lock);
}
/*
* Function to power up a domain, if required. It also increments the
* domain pwr_cnt to prevent it from going down.
*/
static int
ppm_power_up_domain(dev_info_t *dip)
{
int ret = DDI_SUCCESS;
ppm_domain_t *domp;
char *str = "ppm_power_up_domain";
domp = ppm_lookup_dev(dip);
ASSERT(domp);
mutex_enter(&domp->lock);
switch (domp->model) {
case PPMD_FET:
if (domp->status == PPMD_OFF) {
if ((ret = ppm_fetset(domp, PPMD_ON)) ==
DDI_SUCCESS) {
PPMD(D_FET, ("%s: turned on fet for %s@%s\n",
str, PM_NAME(dip), PM_ADDR(dip)))
} else {
PPMD(D_FET, ("%s: couldn't turn on fet "
"for %s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
}
}
break;
case PPMD_PCI:
case PPMD_PCI_PROP:
if (domp->status == PPMD_OFF) {
if ((ret = ppm_switch_clock(domp, PPMD_ON)) ==
DDI_SUCCESS) {
PPMD(D_PCI, ("%s: turned on clock for "
"%s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
} else {
PPMD(D_PCI, ("%s: couldn't turn on clock "
"for %s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
}
}
break;
case PPMD_PCIE:
if (domp->status == PPMD_OFF) {
if ((ret = ppm_pcie_pwr(domp, PPMD_ON)) ==
DDI_SUCCESS) {
PPMD(D_PCI, ("%s: turned on link for "
"%s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
} else {
PPMD(D_PCI, ("%s: couldn't turn on link "
"for %s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
}
}
break;
default:
break;
}
if (ret == DDI_SUCCESS)
domp->pwr_cnt++;
mutex_exit(&domp->lock);
return (ret);
}
/*
* Decrements the domain pwr_cnt. if conditions to power down the domain
* are met, powers down the domain,.
*/
static int
ppm_power_down_domain(dev_info_t *dip)
{
int ret = DDI_SUCCESS;
char *str = "ppm_power_down_domain";
ppm_domain_t *domp;
domp = ppm_lookup_dev(dip);
ASSERT(domp);
mutex_enter(&domp->lock);
ASSERT(domp->pwr_cnt > 0);
domp->pwr_cnt--;
switch (domp->model) {
case PPMD_FET:
if ((domp->pwr_cnt == 0) &&
(ppm_cpr_window_flag == B_FALSE) &&
ppm_none_else_holds_power(domp)) {
if ((ret = ppm_fetset(domp, PPMD_OFF)) ==
DDI_SUCCESS) {
PPMD(D_FET, ("%s: turned off FET for %s@%s \n",
str, PM_NAME(dip), PM_ADDR(dip)))
} else {
PPMD(D_FET, ("%s: couldn't turn off FET for "
" %s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
}
}
break;
case PPMD_PCI:
case PPMD_PCI_PROP:
if ((domp->pwr_cnt == 0) &&
(ppm_cpr_window_flag == B_FALSE) &&
ppm_none_else_holds_power(domp)) {
if ((ret = ppm_switch_clock(domp, PPMD_OFF)) ==
DDI_SUCCESS) {
PPMD(D_PCI, ("%s: turned off clock for %s@%s\n",
str, PM_NAME(dip), PM_ADDR(dip)))
} else {
PPMD(D_PCI, ("%s: couldn't turn off clock "
"for %s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
}
}
break;
case PPMD_PCIE:
if ((domp->pwr_cnt == 0) &&
(ppm_cpr_window_flag == B_FALSE) &&
ppm_none_else_holds_power(domp)) {
if ((ret = ppm_pcie_pwr(domp, PPMD_OFF)) ==
DDI_SUCCESS) {
PPMD(D_PCI, ("%s: turned off link for %s@%s\n",
str, PM_NAME(dip), PM_ADDR(dip)))
} else {
PPMD(D_PCI, ("%s: couldn't turn off link "
"for %s@%s\n", str, PM_NAME(dip),
PM_ADDR(dip)))
}
}
break;
default:
break;
}
mutex_exit(&domp->lock);
return (ret);
}
static int
ppm_manage_sx(s3a_t *s3ap, int enter)
{
ppm_domain_t *domp = ppm_lookup_domain("domain_estar");
ppm_dc_t *dc;
int ret = 0;
if (domp == NULL) {
PPMD(D_CPR, ("ppm_manage_sx: can't find estar domain\n"))
return (ENODEV);
}
PPMD(D_CPR, ("ppm_manage_sx %x, enter %d\n", s3ap->s3a_state,
enter))
switch (s3ap->s3a_state) {
case S3:
if (enter) {
dc = ppm_lookup_dc(domp, PPMDC_ENTER_S3);
} else {
dc = ppm_lookup_dc(domp, PPMDC_EXIT_S3);
}
ASSERT(dc && dc->method == PPMDC_KIO);
PPMD(D_CPR,
("ppm_manage_sx: calling acpi driver (handle %p)"
" with %x\n", (void *)dc->lh, dc->m_un.kio.iowr))
ret = ldi_ioctl(dc->lh, dc->m_un.kio.iowr,
(intptr_t)s3ap, FWRITE | FKIOCTL, kcred, NULL);
break;
case S4:
/* S4 is not supported yet */
return (EINVAL);
default:
ASSERT(0);
}
return (ret);
}
/*
* Search enable/disable lists, which are encoded in ppm.conf as an array
* of char strings.
*/
static int
ppm_search_list(pm_searchargs_t *sl)
{
int i;
int flags = DDI_PROP_DONTPASS;
ppm_unit_t *unitp = ddi_get_soft_state(ppm_statep, ppm_inst);
char **pp;
char *starp;
uint_t nelements;
char *manuf = sl->pms_manufacturer;
char *prod = sl->pms_product;
if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, unitp->dip, flags,
sl->pms_listname, &pp, &nelements) != DDI_PROP_SUCCESS) {
PPMD(D_CPR, ("ppm_search_list prop lookup %s failed--EINVAL\n",
sl->pms_listname))
return (EINVAL);
}
ASSERT((nelements & 1) == 0); /* must be even */
PPMD(D_CPR, ("ppm_search_list looking for %s, %s\n", manuf, prod))
for (i = 0; i < nelements; i += 2) {
PPMD(D_CPR, ("checking %s, %s", pp[i], pp[i+1]))
/* we support only a trailing '*' pattern match */
if ((starp = strchr(pp[i], '*')) != NULL && *(starp + 1) == 0) {
/* LINTED - ptrdiff overflow */
if (strncmp(manuf, pp[i], (starp - pp[i])) != 0) {
PPMD(D_CPR, (" no match %s with %s\n",
manuf, pp[i + 1]))
continue;
}
}
if ((starp = strchr(pp[i + 1], '*')) != NULL &&
*(starp + 1) == 0) {
if (strncmp(prod,
/* LINTED - ptrdiff overflow */
pp[i + 1], (starp - pp[i + 1])) != 0) {
PPMD(D_CPR, (" no match %s with %s\n",
prod, pp[i + 1]))
continue;
}
}
if (strcmp(manuf, pp[i]) == 0 &&
(strcmp(prod, pp[i + 1]) == 0)) {
PPMD(D_CPR, (" match\n"))
ddi_prop_free(pp);
return (0);
}
PPMD(D_CPR, (" no match %s with %s or %s with %s\n",
manuf, pp[i], prod, pp[i + 1]))
}
ddi_prop_free(pp);
return (ENODEV);
}