sun4u/io/pic16f747.c

	pic16f747.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Driver to map the PIC for the chicago platform.
 */
#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/clock.h>
#include <sys/pic.h>
#include <sys/pic16f747.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/file.h>

/* dev_ops and cb_ops entry point function declarations */
static int  pic_attach(dev_info_t *, ddi_attach_cmd_t);
static int  pic_detach(dev_info_t *, ddi_detach_cmd_t);
static int  pic_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int  pic_open(dev_t *, int, int, cred_t *);
static int  pic_close(dev_t, int, int, cred_t *);
static int  pic_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

struct cb_ops pic_cb_ops = {
    pic_open,
    pic_close,
    nodev,
    nodev,
    nodev,          /* dump */
    nodev,
    nodev,
    pic_ioctl,
    nodev,          /* devmap */
    nodev,
    ddi_segmap,     /* segmap */
    nochpoll,
    ddi_prop_op,
    NULL,           /* for STREAMS drivers */
    D_NEW | D_MP        /* driver compatibility flag */
};

static struct dev_ops pic_dev_ops = {
    DEVO_REV,       /* driver build version */
    0,          /* device reference count */
    pic_getinfo,
    nulldev,
    nulldev,        /* probe */
    pic_attach,
    pic_detach,
    nulldev,        /* reset */
    &pic_cb_ops,
    (struct bus_ops *)NULL,
    nulldev         /* power */
};

/*
 * Fans' and sensors' node names and register offsets
 */
static struct minor_node_info pic_nodes[N_PIC_NODES] = {
    {NULL, 0, 0},               /* Reserved */
    {"fan_0", RF_FAN0_PERIOD, 0},       /* System Fan 0 */
    {"fan_1", RF_FAN1_PERIOD, 1},       /* System Fan 1 */
    {"fan_2", RF_FAN2_PERIOD, 2},       /* System Fan 2 */
    {"fan_3", RF_FAN3_PERIOD, 3},       /* System Fan 3 */
    {"fan_4", RF_FAN4_PERIOD, 4},       /* System Fan 4 in P0.1 */
    {"adt7462", RF_LOCAL_TEMP, 0},      /* ADT7462 Local Temperature */
    {"cpu_0", RF_REMOTE1_TEMP, 0},      /* CPU 0 temp */
    {"cpu_1", RF_REMOTE2_TEMP, 0},      /* CPU 1 temp */
    {"mb", RF_REMOTE3_TEMP, 0},     /* Motherboard temp */
    {"lm95221", RF_LM95221_TEMP, 0},    /* LM95221 Local Temperature */
    {"fire", RF_FIRE_TEMP, 0},      /* FIRE Temp */
    {"lsi1064", RF_LSI1064_TEMP, 0},    /* LSI1064 Temp */
    {"front_panel", RF_FRONT_TEMP, 0}   /* Front Panel Temperature */
};

/*
 * Soft state
 */
struct pic_softc {
    dev_info_t  *dip;
    kmutex_t    mutex;
    uint8_t     *cmd_reg;
    ddi_acc_handle_t cmd_handle;
};
#define getsoftc(inst)  ((struct pic_softc *)ddi_get_soft_state(statep, (inst)))

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

static struct modldrv modldrv = {
    &mod_driverops,
    "pic_client driver (v.%I%) ",
    &pic_dev_ops
};

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

int
_init(void)
{
    int e;

    if (e = ddi_soft_state_init(&statep, sizeof (struct pic_softc),
        MAX_PIC_INSTANCES)) {
        return (e);
    }

    if ((e = mod_install(&modlinkage)) != 0)
        ddi_soft_state_fini(&statep);

    return (e);
}

int
_fini(void)
{
    int e;

    if ((e = mod_remove(&modlinkage)) != 0)
        return (e);

    ddi_soft_state_fini(&statep);

    return (DDI_SUCCESS);
}

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

/*ARGSUSED*/
static int
pic_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
    int inst;
    int retval = DDI_SUCCESS;
    struct pic_softc *softc;

    inst = PIC_MINOR_TO_INST(getminor((dev_t)arg));

    switch (cmd) {
    case DDI_INFO_DEVT2DEVINFO:
        if ((softc = getsoftc(inst)) == NULL) {
            *result = (void *)NULL;
            retval = DDI_FAILURE;
        } else
            *result = (void *)softc->dip;
        break;

    case DDI_INFO_DEVT2INSTANCE:
        *result = (void *)inst;
        break;

    default:
        retval = DDI_FAILURE;
    }

    return (retval);
}

static int
pic_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    int inst;
    int i;
    struct pic_softc *softc = NULL;
    char        *minor_name;
    int minor;
    char name[80];
    ddi_device_acc_attr_t dev_attr;
    int res;

    switch (cmd) {
    case DDI_ATTACH:
        inst = ddi_get_instance(dip);
        if (inst >= MAX_PIC_INSTANCES) {
            cmn_err(CE_WARN, "attach failed, too many instances\n");
            return (DDI_FAILURE);
        }

        (void) sprintf(name, "env-monitor%d", inst);
        minor = PIC_INST_TO_MINOR(inst) | PIC_UNIT_TO_MINOR(0);
        if (ddi_create_minor_node(dip, name, S_IFCHR, minor,
            DDI_PSEUDO, NULL) == DDI_FAILURE) {
            cmn_err(CE_WARN,
                "ddi_create_minor_node() failed for inst %d\n",
                inst);
            return (DDI_FAILURE);
        }

        /* Allocate a soft state structure for this instance */
        if (ddi_soft_state_zalloc(statep, inst) != DDI_SUCCESS) {
            cmn_err(CE_WARN, " ddi_soft_state_zalloc() failed "
                "for inst %d\n", inst);
            goto attach_failed;
        }

        /* Setup soft state */
        softc = getsoftc(inst);
        softc->dip = dip;
        mutex_init(&softc->mutex, NULL, MUTEX_DRIVER, NULL);

        /* Setup device attributes */
        dev_attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
        dev_attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
        dev_attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

        /*
         * The RF_COMMAND/RF_STATUS and RF_IND_DATA/RF_IND_ADDR
         * register pairs are mapped as one register set starting
         * from 0x0 and length 0x42.
         */
        res = ddi_regs_map_setup(dip, 0, (caddr_t *)&softc->cmd_reg,
            0, 0x42, &dev_attr, &softc->cmd_handle);
        if (res != DDI_SUCCESS) {
            cmn_err(CE_WARN, "ddi_regs_map_setup() failed\n");
            goto attach_failed;
        }

        /* Set up fans' and sensors' device minor nodes */
        for (i = 1; i < N_PIC_NODES; i++) {
            minor_name = pic_nodes[i].minor_name;
            minor = PIC_INST_TO_MINOR(inst) | PIC_UNIT_TO_MINOR(i);
            if (ddi_create_minor_node(dip, minor_name, S_IFCHR,
                minor, PICDEV_NODE_TYPE, NULL) == DDI_FAILURE) {
                cmn_err(CE_WARN,
                    "%s:%d ddi_create_minor_node failed",
                    ddi_driver_name(dip), inst);
                (void) pic_detach(dip, DDI_DETACH);
                return (DDI_FAILURE);
            }
        }

        /* Create main environmental node */
        ddi_report_dev(dip);

        return (DDI_SUCCESS);

    case DDI_RESUME:
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);
    }

attach_failed:

    /* Free soft state, if allocated. remove minor node if added earlier */
    if (softc)
        ddi_soft_state_free(statep, inst);

    ddi_remove_minor_node(dip, NULL);

    return (DDI_FAILURE);
}

static int
pic_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    int inst;
    struct pic_softc *softc;

    switch (cmd) {
    case DDI_DETACH:
        inst = ddi_get_instance(dip);
        if ((softc = getsoftc(inst)) == NULL)
            return (ENXIO);

        (void) ddi_regs_map_free(&softc->cmd_handle);
        /* Free the soft state and remove minor node added earlier */
        mutex_destroy(&softc->mutex);
        ddi_soft_state_free(statep, inst);
        ddi_remove_minor_node(dip, NULL);
        return (DDI_SUCCESS);

    case DDI_SUSPEND:
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);
    }
}

/*ARGSUSED*/
static int
pic_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
    int inst = PIC_MINOR_TO_INST(getminor(*devp));

    return (getsoftc(inst) == NULL ? ENXIO : 0);
}

/*ARGSUSED*/
static int
pic_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
    int inst = PIC_MINOR_TO_INST(getminor(dev));

    return (getsoftc(inst) == NULL ? ENXIO : 0);
}

/*ARGSUSED*/
static int
pic_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
{
    int inst;
    int node;
    int ntries;
    struct pic_softc *softc;
    uint8_t in_command;
    uint8_t status;
    int16_t tempr;

    inst = PIC_MINOR_TO_INST(getminor(dev));
    if ((softc = getsoftc(inst)) == NULL)
        return (ENXIO);

    mutex_enter(&softc->mutex);

    if (ddi_copyin((caddr_t)arg, &in_command, sizeof (in_command),
        mode) != DDI_SUCCESS) {
        mutex_exit(&softc->mutex);
        return (EFAULT);
    }

    node = PIC_MINOR_TO_UNIT(getminor(dev));
    if ((node >= N_PIC_NODES) || (node < 1)) {
        mutex_exit(&softc->mutex);
        return (ENXIO);
    }

    /* Check status register */
    ntries = 0;
    do {
        if (++ntries > MAX_RETRIES) {
            mutex_exit(&softc->mutex);
            return (EBUSY);
        }

        status = ddi_get8(softc->cmd_handle,
            (uint8_t *)softc->cmd_reg + RF_STATUS);
        /*
         * We need 5us delay between 2 register reads
         * this give enough time for the pic to be updated.
         * we are waiting 10us to give us some breathing room.
         */
        drv_usecwait(10);

        /*
         * If we're asked to return status, we simply
         * return it as is.
         */
        if (cmd == PIC_GET_STATUS)
            break;

    } while ((status & ST_ENV_BUSY) || (status & ST_STALE_ADT_DATA) ||
        (status & ST_STALE_LM_DATA));

    switch (cmd) {
    case PIC_GET_TEMPERATURE:

        /* select the temp sensor */
        (void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
            RF_IND_ADDR, pic_nodes[node].reg_offset);

        /* retrieve temperature data */
        tempr =  (int16_t)ddi_get8(softc->cmd_handle,
            (uint8_t *)softc->cmd_reg + RF_IND_DATA);

        drv_usecwait(10);

        if (tempr == 0xff) {
            mutex_exit(&softc->mutex);
            return (EIO);
        }

        /*
         * The temp is passed in as a uint8 value, we need to convert
         * it to a signed 16 bit value to be able to handle the range
         * of -64 to 190 degrees.
         */
        tempr -= 64;

        /* In this case we need to return a signed int value */
        mutex_exit(&softc->mutex);
        (void) ddi_copyout(&tempr, (caddr_t)arg, sizeof (tempr), mode);

        return (0);

    case PIC_GET_FAN_SPEED:
        /* select fan */
        (void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
            RF_IND_ADDR, pic_nodes[node].reg_offset);

        /* retrieve fan data */
        in_command =  ddi_get8(softc->cmd_handle,
            (uint8_t *)softc->cmd_reg + RF_IND_DATA);

        drv_usecwait(10);
        break;

    case PIC_SET_FAN_SPEED:
        /* select fan */
        (void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
            RF_IND_ADDR, pic_nodes[node].reg_offset);

        /* send the fan data */
        (void) ddi_put8(softc->cmd_handle,
            (uint8_t *)softc->cmd_reg + RF_IND_DATA, in_command);

        drv_usecwait(10);

        break;

    case PIC_GET_STATUS:
        in_command = status;
        break;

    case PIC_GET_FAN_STATUS:
        /* read ffault register */
        (void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
            RF_IND_ADDR, RF_FAN_STATUS);

        /* retrieve fan failure status */
        in_command = ddi_get8(softc->cmd_handle,
            (uint8_t *)softc->cmd_reg + RF_IND_DATA);
        in_command = (in_command >> pic_nodes[node].ff_shift) & 0x1;

        drv_usecwait(10);

        break;

    case PIC_SET_ESTAR_MODE:
        (void) ddi_put8(softc->cmd_handle,
            (uint8_t *)softc->cmd_reg + RF_COMMAND, CMD_TO_ESTAR);
        break;

    default:
        mutex_exit(&softc->mutex);
        cmn_err(CE_NOTE, "cmd %d isnt valid", cmd);
        return (EINVAL);
    }

    mutex_exit(&softc->mutex);
    (void) ddi_copyout(&in_command, (caddr_t)arg, 1, mode);

    /*
     * 0xFF indicates an error when trying to read from the device,
     * ie. it can be busy, or being updated.
     * This will force picl to retry the read at another time.
     */
    if (in_command == 0xff) {
        return (EIO);
    } else {
        return (0);
    }
}