io/ppm/acpippm.c

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

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/open.h>
#include <sys/modctl.h>
#include <sys/promif.h>
#include <sys/stat.h>
#include <sys/ddi_impldefs.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/epm.h>
#include <sys/acpi/acpi.h>
#include <sys/acpica.h>
#include <sys/psm_types.h>

/*
 *  ACPI Power Management Driver
 *
 *  acpippm deals with those bits of ppm functionality that
 *  must be mediated by ACPI
 *
 *  The routines in this driver is referenced by Platform
 *  Power Management driver of X86 workstation systems.
 *  acpippm driver is loaded because it is listed as a platform driver
 *  It is initially configured as a pseudo driver.
 */
extern void pc_tod_set_rtc_offsets(ACPI_TABLE_FADT *);
extern int acpica_use_safe_delay;

/*
 * Configuration Function prototypes and data structures
 */
static int  appm_attach(dev_info_t *, ddi_attach_cmd_t);
static int  appm_detach(dev_info_t *, ddi_detach_cmd_t);
static int  appm_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int  appm_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
static int  appm_close(dev_t dev, int flag, int otyp, cred_t *cred_p);
static int  appm_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/*
 * Configuration data structures
 */
static struct cb_ops appm_cbops = {
    appm_open,      /* open */
    appm_close,     /* close */
    nodev,          /* strategy */
    nodev,          /* print */
    nodev,          /* dump */
    nodev,          /* read */
    nodev,          /* write */
    appm_ioctl,     /* ioctl */
    nodev,          /* devmap */
    nodev,          /* mmap */
    nodev,          /* segmap */
    nochpoll,       /* chpoll */
    ddi_prop_op,        /* prop_op */
    NULL,           /* stream */
    D_MP | D_NEW,       /* flag */
    CB_REV,         /* rev */
    nodev,          /* aread */
    nodev,          /* awrite */
};

static struct dev_ops appm_ops = {
    DEVO_REV,       /* devo_rev */
    0,          /* refcnt */
    appm_getinfo,       /* getinfo */
    nulldev,        /* identify */
    nulldev,        /* probe */
    appm_attach,        /* attach */
    appm_detach,        /* detach */
    nodev,          /* reset */
    &appm_cbops,        /* cb_ops */
    NULL,           /* bus_ops */
    NULL,           /* power */
    ddi_quiesce_not_needed,     /* quiesce */
};

extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
    &mod_driverops,
    "ACPI ppm driver",
    &appm_ops,
};

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

/*
 * Driver state structure
 */
typedef struct {
    dev_info_t      *dip;
    ddi_acc_handle_t    devid_hndl;
    ddi_acc_handle_t    estar_hndl;
    int         lyropen;        /* ref count */
} appm_unit;

/*
 * Driver global variables
 *
 * appm_lock synchronize the access of lyr handle to each appm
 * minor device, therefore write to tomatillo device is
 * sequentialized.  Lyr protocol requires pairing up lyr open
 * and close, so only a single reference is allowed per minor node.
 */
static void *appm_statep;
static kmutex_t  appm_lock;

/*
 * S3 stuff:
 */
extern int acpi_enter_sleepstate(s3a_t *);
extern int acpi_exit_sleepstate(s3a_t *);


int
_init(void)
{
    int error;

    if ((error = ddi_soft_state_init(&appm_statep,
        sizeof (appm_unit), 0)) != DDI_SUCCESS) {
        return (error);
    }

    mutex_init(&appm_lock, NULL, MUTEX_DRIVER, NULL);

    if ((error = mod_install(&modlinkage)) != DDI_SUCCESS) {
        mutex_destroy(&appm_lock);
        ddi_soft_state_fini(&appm_statep);
        return (error);
    }

    return (error);
}

int
_fini(void)
{
    int error;

    if ((error = mod_remove(&modlinkage)) == DDI_SUCCESS) {
        mutex_destroy(&appm_lock);
        ddi_soft_state_fini(&appm_statep);
    }

    return (error);

}

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


/*
 * Driver attach(9e) entry point
 */
static int
appm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    char    *str = "appm_attach";
    int     instance;
    appm_unit   *unitp;
    ACPI_TABLE_FADT *fadt = NULL;
    int     rv = DDI_SUCCESS;

    switch (cmd) {
    case DDI_ATTACH:
        break;
    case DDI_RESUME:
        return (DDI_SUCCESS);
    default:
        cmn_err(CE_WARN, "%s: cmd %d unsupported.\n", str, cmd);
        return (DDI_FAILURE);
    }

    instance = ddi_get_instance(dip);
    rv = ddi_soft_state_zalloc(appm_statep, instance);
    if (rv != DDI_SUCCESS) {
        cmn_err(CE_WARN, "%s: failed alloc for dev(%s@%s)",
            str, ddi_binding_name(dip),
            ddi_get_name_addr(dip) ? ddi_get_name_addr(dip) : " ");
        return (rv);
    }

    if ((unitp = ddi_get_soft_state(appm_statep, instance)) == NULL) {
        rv = DDI_FAILURE;
        goto doerrs;
    }

    /*
     * Export "ddi-kernel-ioctl" property - prepared to support
     * kernel ioctls (driver layering).
     * XXX is this still needed?
     * XXXX (RSF) Not that I am aware of.
     */
    rv = ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
        DDI_KERNEL_IOCTL, NULL, 0);
    if (rv != DDI_PROP_SUCCESS)
        goto doerrs;

    ddi_report_dev(dip);
    unitp->dip = dip;

    /*
     * XXX here we would do whatever we need to to determine if the
     * XXX platform supports ACPI, and fail the attach if not.
     * XXX If it does, we do whatever setup is needed to get access to
     * XXX ACPI register space.
     */

    unitp->lyropen = 0;

    /*
     * create minor node for kernel_ioctl calls
     */
    rv = ddi_create_minor_node(dip, "acpi-ppm", S_IFCHR, instance, 0, 0);
    if (rv != DDI_SUCCESS)
        goto doerrs;

    /* Get the FADT */
    if (AcpiGetTable(ACPI_SIG_FADT, 1,
        (ACPI_TABLE_HEADER **)&fadt) != AE_OK)
        return (rv);

    /* Init the RTC offsets */
    if (fadt != NULL)
        pc_tod_set_rtc_offsets(fadt);

    return (rv);

doerrs:

    if (ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS |
        DDI_PROP_NOTPROM, DDI_KERNEL_IOCTL))
        ddi_prop_remove_all(dip);

    ddi_soft_state_free(appm_statep, instance);

    return (rv);
}


/*
 * Driver getinfo(9e) entry routine
 */
/* ARGSUSED */
static int
appm_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
    appm_unit   *unitp;
    int     instance;

    switch (cmd) {
    case DDI_INFO_DEVT2DEVINFO:
        instance = getminor((dev_t)arg);
        unitp = ddi_get_soft_state(appm_statep, instance);
        if (unitp == NULL) {
            return (DDI_FAILURE);
        }
        *result = (void *) unitp->dip;
        return (DDI_SUCCESS);

    case DDI_INFO_DEVT2INSTANCE:
        instance = getminor((dev_t)arg);
        *result = (void *)(uintptr_t)instance;
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);
    }
}


/*
 * detach(9e)
 */
/* ARGSUSED */
static int
appm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    char *str = "appm_detach";

    switch (cmd) {
    case DDI_DETACH:
        return (DDI_FAILURE);
    case DDI_SUSPEND:
        return (DDI_SUCCESS);
    default:
        cmn_err(CE_WARN, "%s: cmd %d unsupported", str, cmd);
        return (DDI_FAILURE);
    }
}


/* ARGSUSED */
static int
appm_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
{
    appm_unit   *unitp;

    /* not intended to allow sysadmin level root process to open it */
    if (drv_priv(cred_p) != DDI_SUCCESS)
        return (EPERM);

    if ((unitp = ddi_get_soft_state(
        appm_statep, getminor(*dev_p))) == NULL) {
        cmn_err(CE_WARN, "appm_open: failed to get soft state!");
        return (DDI_FAILURE);
    }

    mutex_enter(&appm_lock);
    if (unitp->lyropen != 0) {
        mutex_exit(&appm_lock);
        return (EBUSY);
    }
    unitp->lyropen++;
    mutex_exit(&appm_lock);

    return (DDI_SUCCESS);
}


/* ARGSUSED */
static int
appm_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
    appm_unit   *unitp;

    if ((unitp =
        ddi_get_soft_state(appm_statep, getminor(dev))) == NULL)
        return (DDI_FAILURE);

    mutex_enter(&appm_lock);
    unitp->lyropen = 0;
    mutex_exit(&appm_lock);

    return (DDI_SUCCESS);
}


/*
 * must match ppm.conf
 */
#define APPMIOC         ('A' << 8)
#define APPMIOC_ENTER_S3    (APPMIOC | 1)   /* arg *s3a_t */
#define APPMIOC_EXIT_S3     (APPMIOC | 2)   /* arg *s3a_t */

/* ARGSUSED3 */
static int
appm_ioctl(dev_t dev, int cmd, intptr_t arg, int flag,
    cred_t *cred_p, int *rval_p)
{
    static boolean_t    acpi_initted = B_FALSE;
    char            *str = "appm_ioctl";
    int         ret;
    s3a_t           *s3ap = (s3a_t *)arg;

    PMD(PMD_SX, ("%s: called with %x\n", str, cmd))

    if (drv_priv(cred_p) != 0) {
        PMD(PMD_SX, ("%s: EPERM\n", str))
        return (EPERM);
    }

    if (ddi_get_soft_state(appm_statep, getminor(dev)) == NULL) {
        PMD(PMD_SX, ("%s: no soft state: EIO\n", str))
        return (EIO);
    }

    if (!acpi_initted) {
        PMD(PMD_SX, ("%s: !acpi_initted\n", str))
        if (acpica_init() == 0) {
            acpi_initted = B_TRUE;
        } else {
            if (rval_p != NULL) {
                *rval_p = EINVAL;
            }
            PMD(PMD_SX, ("%s: EINVAL\n", str))
            return (EINVAL);
        }
    }

    PMD(PMD_SX, ("%s: looking for cmd %x\n", str, cmd))
    switch (cmd) {
    case APPMIOC_ENTER_S3:
        /*
         * suspend to RAM (ie S3)
         */
        PMD(PMD_SX, ("%s: cmd %x, arg %p\n", str, cmd, (void *)arg))
        acpica_use_safe_delay = 1;
        ret = acpi_enter_sleepstate(s3ap);
        break;

    case APPMIOC_EXIT_S3:
        /*
         * return from S3
         */
        PMD(PMD_SX, ("%s: cmd %x, arg %p\n", str, cmd, (void *)arg))
        ret = acpi_exit_sleepstate(s3ap);
        acpica_use_safe_delay = 0;
        break;

    default:
        PMD(PMD_SX, ("%s: cmd %x unrecognized: ENOTTY\n", str, cmd))
        return (ENOTTY);
    }

    /*
     * upon failure return EINVAL
     */
    if (ret != 0) {
        if (rval_p != NULL) {
            *rval_p = EINVAL;
        }
        return (EINVAL);
    }

    return (0);
}