io/oplpanel/oplpanel.c

	oplpanel.c revision a1bf6e2eba3dc9acc46299eac9c6ef1bc1e15c2b
/*
 * 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
 */

/*
 * All Rights Reserved, Copyright (c) FUJITSU LIMITED 2006
 */

/*
 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 */


#include <sys/types.h>
#include <sys/time.h>
#include <sys/errno.h>
#include <sys/cmn_err.h>
#include <sys/param.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/file.h>
#include <sys/intr.h>
#include <sys/machsystm.h>

#define PNLIE_MASK  0x010   /* interrupt enable/disable */
#define PNLINT_MASK 0x001   /* interrupted flag */

#ifdef DEBUG
int panel_debug = 0;
static void panel_ddi_put8(ddi_acc_handle_t, uint8_t *, uint8_t);
#define DCMN_ERR(x) if (panel_debug) cmn_err x

#else

#define DCMN_ERR(x)
#define panel_ddi_put8(x, y, z) ddi_put8(x, y, z)

#endif

static int  panel_getinfo(dev_info_t *, ddi_info_cmd_t, void *,  void **);
static int  panel_attach(dev_info_t *, ddi_attach_cmd_t);
static int  panel_detach(dev_info_t *, ddi_detach_cmd_t);
static uint_t   panel_intr(caddr_t);
static int  panel_open(dev_t *, int, int, cred_t *);
static int  panel_close(dev_t, int, int, cred_t *);

static char *panel_name = "oplpanel";
int     panel_enable = 1;   /* enable or disable */

extern uint64_t cpc_level15_inum;   /* in cpc_subr.c */

struct panel_state {
    dev_info_t      *dip;
    ddi_iblock_cookie_t iblock_cookie;
    ddi_acc_handle_t    panel_regs_handle;
    uint8_t         *panelregs;     /* mapping address */
    uint8_t         panelregs_state;    /* keeping regs. */
};

struct cb_ops panel_cb_ops = {
    nodev,      /* open */
    nodev,      /* close */
    nodev,      /* strategy */
    nodev,      /* print */
    nodev,      /* dump */
    nodev,      /* read */
    nodev,      /* write */
    nodev,      /* ioctl */
    nodev,      /* devmap */
    nodev,      /* mmap */
    nodev,      /* segmap */
    nochpoll,   /* poll */
    nodev,      /* prop_op */
    NULL,       /* streamtab */
    D_NEW | D_MP | D_HOTPLUG,   /* flag */
    CB_REV,     /* cb_rev */
    nodev,      /* async I/O read entry point */
    nodev       /* async I/O write entry point */
};

static struct dev_ops panel_dev_ops = {
    DEVO_REV,       /* driver build version */
    0,          /* device reference count */
    panel_getinfo,      /* getinfo */
    nulldev,        /* identify */
    nulldev,        /* probe */
    panel_attach,       /* attach */
    panel_detach,       /* detach */
    nulldev,        /* reset */
    &panel_cb_ops,      /* cb_ops */
    NULL,           /* bus_ops */
    nulldev,        /* power */
    ddi_quiesce_not_supported,  /* devo_quiesce */
};

/* module configuration stuff */
static void     *panelstates;
extern struct mod_ops   mod_driverops;

static struct modldrv modldrv = {
    &mod_driverops,
    "OPL panel driver",
    &panel_dev_ops
};

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


int
_init(void)
{
    int status;

    DCMN_ERR((CE_CONT, "%s: _init\n", panel_name));

    status = ddi_soft_state_init(&panelstates,
        sizeof (struct panel_state), 0);
    if (status != 0) {
        cmn_err(CE_WARN, "%s: ddi_soft_state_init failed.",
            panel_name);
        return (status);
    }

    status = mod_install(&modlinkage);
    if (status != 0) {
        ddi_soft_state_fini(&panelstates);
    }

    return (status);
}

int
_fini(void)
{
    /*
     * Can't unload to make sure the panel switch always works.
     */
    return (EBUSY);
}

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

static int
panel_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{

    int instance;
    struct panel_state *statep = NULL;

    ddi_device_acc_attr_t access_attr = {
        DDI_DEVICE_ATTR_V0,
        DDI_STRUCTURE_BE_ACC,
        DDI_STRICTORDER_ACC
    };

    instance = ddi_get_instance(dip);

    DCMN_ERR((CE_CONT, "%s%d: attach\n", panel_name, instance));

    switch (cmd) {
    case DDI_ATTACH:
        DCMN_ERR((CE_CONT, "%s%d: DDI_ATTACH\n",
            panel_name, instance));
        break;

    case DDI_RESUME:
        DCMN_ERR((CE_CONT, "%s%d: DDI_RESUME\n",
            panel_name, instance));

        if ((statep = (struct panel_state *)
            ddi_get_soft_state(panelstates, instance)) == NULL) {
            cmn_err(CE_WARN, "%s%d: ddi_get_soft_state failed.",
                panel_name, instance);
            return (DDI_FAILURE);
        }

        /* enable the interrupt just in case */
        panel_ddi_put8(statep->panel_regs_handle, statep->panelregs,
            statep->panelregs_state);
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);
    }

    /*
     * Attach routine
     */

    /* alloc and get soft state */
    if (ddi_soft_state_zalloc(panelstates, instance) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "%s%d: ddi_soft_state_zalloc failed.",
            panel_name, instance);
        goto attach_failed2;
    }
    if ((statep = (struct panel_state *)
        ddi_get_soft_state(panelstates, instance)) == NULL) {
        cmn_err(CE_WARN, "%s%d: ddi_get_soft_state failed.",
            panel_name, instance);
        goto attach_failed1;
    }

    /* set the dip in the soft state */
    statep->dip = dip;

    /* mapping register */
    if (ddi_regs_map_setup(dip, 0, (caddr_t *)&statep->panelregs,
        0, 0, /* the entire space is mapped */
        &access_attr, &statep->panel_regs_handle) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "%s%d: ddi_regs_map_setup failed.",
            panel_name, instance);
        goto attach_failed1;
    }

    /* setup the interrupt handler */
    (void) ddi_get_iblock_cookie(dip, 0, &statep->iblock_cookie);
    if (ddi_add_intr(dip, 0, &statep->iblock_cookie, 0, &panel_intr,
        (caddr_t)statep) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "%s%d: cannot add interrupt handler.",
            panel_name, instance);
        goto attach_failed0;
    }

    /* ATTACH SUCCESS */

    /* announce the device */
    ddi_report_dev(dip);

    /* turn on interrupt */
    statep->panelregs_state = 0 | PNLIE_MASK;
    panel_ddi_put8(statep->panel_regs_handle, statep->panelregs,
        statep->panelregs_state);

    return (DDI_SUCCESS);

attach_failed0:
    ddi_regs_map_free(&statep->panel_regs_handle);
attach_failed1:
    ddi_soft_state_free(panelstates, instance);
attach_failed2:
    DCMN_ERR((CE_NOTE, "%s%d: attach failed", panel_name, instance));
    return (DDI_FAILURE);
}

static int
panel_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    int instance;
    struct panel_state *statep;

    instance = ddi_get_instance(dip);

    DCMN_ERR((CE_CONT, "%s%d: detach\n", panel_name, instance));

    if ((statep = (struct panel_state *)
        ddi_get_soft_state(panelstates, instance)) == NULL) {
        cmn_err(CE_WARN, "%s%d: ddi_get_soft_state failed.",
            panel_name, instance);
        return (DDI_FAILURE);
    }

    switch (cmd) {
    case DDI_DETACH:
        DCMN_ERR((CE_CONT, "%s%d: DDI_DETACH\n",
            panel_name, instance));

        /* turn off interrupt */
        statep->panelregs_state &= ~PNLIE_MASK;
        panel_ddi_put8(statep->panel_regs_handle, statep->panelregs,
            statep->panelregs_state);

        /* free all resources for the dip */
        ddi_remove_intr(dip, 0, statep->iblock_cookie);

        /* need not free iblock_cookie */
        ddi_regs_map_free(&statep->panel_regs_handle);
        ddi_soft_state_free(panelstates, instance);

        return (DDI_SUCCESS);

    case DDI_SUSPEND:
        DCMN_ERR((CE_CONT, "%s%d: DDI_SUSPEND\n",
            panel_name, instance));
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);

    }
    /* Not reached */
}

/*ARGSUSED*/
static int
panel_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,  void **resultp)
{
    struct panel_state *statep;
    int instance;
    dev_t   dev = (dev_t)arg;

    instance = getminor(dev);

    DCMN_ERR((CE_CONT, "%s%d: getinfo\n", panel_name, instance));

    switch (cmd) {
    case DDI_INFO_DEVT2DEVINFO:
        if ((statep = (struct panel_state *)
            ddi_get_soft_state(panelstates, instance)) == NULL) {
            cmn_err(CE_WARN, "%s%d: ddi_get_soft_state failed.",
                panel_name, instance);
            *resultp = NULL;
            return (DDI_FAILURE);
        }
        *resultp = statep->dip;
        break;
    case DDI_INFO_DEVT2INSTANCE:
        *resultp = (void *)(uintptr_t)instance;
        break;
    default:
        return (DDI_FAILURE);
    }

    return (DDI_SUCCESS);
}

static  uint_t
panel_intr(caddr_t arg)
{
    struct panel_state *statep = (struct panel_state *)arg;

    /* to confirm the validity of the interrupt */
    if (!(ddi_get8(statep->panel_regs_handle, statep->panelregs) &
        PNLINT_MASK)) {
        return (DDI_INTR_UNCLAIMED);
    }

    /*
     * Clear the PNLINT bit
     * HW reported that there might be a delay in the PNLINT bit
     * clearing. We force synchronization by attempting to read
     * back the reg after clearing the bit.
     */
    panel_ddi_put8(statep->panel_regs_handle, statep->panelregs,
        statep->panelregs_state | PNLINT_MASK);
    (void) ddi_get8(statep->panel_regs_handle, statep->panelregs);

    if (panel_enable) {
        /* avoid double panic */
        panel_enable    = 0;

        cmn_err(CE_PANIC,
            "System Panel Driver: Emergency panic request "
            "detected!");
        /* Not reached */
    }

    return (DDI_INTR_CLAIMED);
}

#ifdef DEBUG
static void
panel_ddi_put8(ddi_acc_handle_t handle, uint8_t *dev_addr, uint8_t value)
{
    if (panel_debug) {
        cmn_err(CE_CONT, "%s: old value = 0x%x\n",
            panel_name, ddi_get8(handle, dev_addr));
        cmn_err(CE_CONT, "%s: writing value = 0x%x\n",
            panel_name, value);
        ddi_put8(handle, dev_addr, value);
        cmn_err(CE_CONT, "%s: new value = 0x%x\n",
            panel_name, ddi_get8(handle, dev_addr));
    } else {
        ddi_put8(handle, dev_addr, value);
    }
}
#endif