i2c/clients/lm75.c

	lm75.c revision f47a9c508408507a404eaf38dd597e6ac41f92e6
/*
 * 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"

#include <sys/stat.h>       /* ddi_create_minor_node S_IFCHR */
#include <sys/modctl.h>     /* for modldrv */
#include <sys/open.h>       /* for open params.  */
#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/sunddi.h>
#include <sys/conf.h>       /* req. by dev_ops flags MTSAFE etc. */
#include <sys/ddi.h>
#include <sys/file.h>
#include <sys/note.h>
#include <sys/i2c/clients/lm75.h>
#include <sys/i2c/clients/lm75_impl.h>

static void *lm75soft_statep;

static int lm75_do_attach(dev_info_t *);
static int lm75_do_detach(dev_info_t *);
static int lm75_do_resume(void);
static int lm75_do_suspend(void);
static int lm75_get16(intptr_t, int, struct lm75_unit *, int);
static int lm75_set16(intptr_t, int, struct lm75_unit *, int);

/*
 * cb ops (only need ioctl)
 */
static int lm75_open(dev_t *, int, int, cred_t *);
static int lm75_close(dev_t, int, int, cred_t *);
static int lm75_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

static struct cb_ops lm75_cbops = {
    lm75_open,          /* open  */
    lm75_close,         /* close */
    nodev,              /* strategy */
    nodev,              /* print */
    nodev,              /* dump */
    nodev,              /* read */
    nodev,              /* write */
    lm75_ioctl,         /* ioctl */
    nodev,              /* devmap */
    nodev,              /* mmap */
    nodev,              /* segmap */
    nochpoll,           /* poll */
    ddi_prop_op,            /* cb_prop_op */
    NULL,               /* streamtab */
    D_NEW | D_MP | D_HOTPLUG,   /* Driver compatibility flag */
    CB_REV,             /* rev */
    nodev,              /* int (*cb_aread)() */
    nodev               /* int (*cb_awrite)() */
};

/*
 * dev ops
 */
static int lm75_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int lm75_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

static struct dev_ops lm75_ops = {
    DEVO_REV,
    0,
    ddi_getinfo_1to1,
    nulldev,
    nulldev,
    lm75_attach,
    lm75_detach,
    nodev,
    &lm75_cbops,
    NULL
};

extern struct mod_ops mod_driverops;

static struct modldrv lm75_modldrv = {
    &mod_driverops,         /* type of module - driver */
    "LM75 i2c device driver: v%I%",
    &lm75_ops
};

static struct modlinkage lm75_modlinkage = {
    MODREV_1,
    &lm75_modldrv,
    0
};


int
_init(void)
{
    int error;

    error = mod_install(&lm75_modlinkage);

    if (!error)
        (void) ddi_soft_state_init(&lm75soft_statep,
            sizeof (struct lm75_unit), 1);
    return (error);
}

int
_fini(void)
{
    int error;

    error = mod_remove(&lm75_modlinkage);
    if (!error)
        ddi_soft_state_fini(&lm75soft_statep);

    return (error);
}

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

static int
lm75_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
    _NOTE(ARGUNUSED(credp))

    struct lm75_unit *unitp;
    int instance;
    int error = 0;

    instance = getminor(*devp);

    if (instance < 0) {
        return (ENXIO);
    }

    unitp = (struct lm75_unit *)
        ddi_get_soft_state(lm75soft_statep, instance);

    if (unitp == NULL) {
        return (ENXIO);
    }

    if (otyp != OTYP_CHR) {
        return (EINVAL);
    }

    mutex_enter(&unitp->lm75_mutex);

    if (flags & FEXCL) {
        if (unitp->lm75_oflag != 0) {
            error = EBUSY;
        } else {
            unitp->lm75_oflag = FEXCL;
        }
    } else {
        if (unitp->lm75_oflag == FEXCL) {
            error = EBUSY;
        } else {
            unitp->lm75_oflag = FOPEN;
        }
    }

    mutex_exit(&unitp->lm75_mutex);

    return (error);
}

static int
lm75_close(dev_t dev, int flags, int otyp, cred_t *credp)
{
    _NOTE(ARGUNUSED(flags, otyp, credp))

    struct lm75_unit *unitp;
    int instance;

    instance = getminor(dev);

    if (instance < 0) {
        return (ENXIO);
    }

    unitp = (struct lm75_unit *)
        ddi_get_soft_state(lm75soft_statep, instance);

    if (unitp == NULL) {
        return (ENXIO);
    }

    mutex_enter(&unitp->lm75_mutex);

    unitp->lm75_oflag = 0;

    mutex_exit(&unitp->lm75_mutex);
    return (DDI_SUCCESS);
}

static int
lm75_get16(intptr_t arg, int reg, struct lm75_unit *unitp, int mode) {
    i2c_transfer_t      *i2c_tran_pointer;
    int err = DDI_SUCCESS;
    int16_t         temp16;
    int8_t          holder;

    (void) i2c_transfer_alloc(unitp->lm75_hdl, &i2c_tran_pointer,
                1, 2, I2C_SLEEP);
    if (i2c_tran_pointer == NULL) {
        D2CMN_ERR((CE_WARN, "%s: Failed in I2C_GET_TEMPERATURE "
                "i2c_tran_pointer not allocated\n",
                unitp->lm75_name));
        return (ENOMEM);
    }

    i2c_tran_pointer->i2c_flags = I2C_WR_RD;
    i2c_tran_pointer->i2c_wbuf[0] = (uchar_t)reg;

    err = i2c_transfer(unitp->lm75_hdl, i2c_tran_pointer);
    if (err) {
        D2CMN_ERR((CE_WARN, "%s: Failed in I2C_GET_TEMPERATURE "
                "i2c_transfer routine\n",
                unitp->lm75_name));
        i2c_transfer_free(unitp->lm75_hdl, i2c_tran_pointer);
        return (err);
    }

    D1CMN_ERR((CE_NOTE, "%s: rbuf[0] =  %x rbuf[1] = %x\n",
        unitp->lm75_name, i2c_tran_pointer->i2c_rbuf[0],
        i2c_tran_pointer->i2c_rbuf[0]));
    temp16 = i2c_tran_pointer->i2c_rbuf[0];
    temp16 = (temp16 << 1);
    temp16 = (temp16 | ((i2c_tran_pointer->i2c_rbuf[1] & 0x80) >> 7));


    if (temp16 & LM75_COMP_MASK) {
        holder = (temp16 & LM75_COMP_MASK_UPPER);
        holder = -holder;
        holder = holder/2;
        temp16 = 0 - holder;
    } else {
        temp16 = temp16 / 2;
    }
    if (ddi_copyout((caddr_t)&temp16, (caddr_t)arg,
            sizeof (int16_t), mode) != DDI_SUCCESS) {
        D2CMN_ERR((CE_WARN, "%s: Failed in I2C_GET_TEMPERATURE "
                "ddi_copyout routine\n",
                unitp->lm75_name));
        err = EFAULT;
    }
    i2c_transfer_free(unitp->lm75_hdl, i2c_tran_pointer);
    return (err);
}

static int
lm75_set16(intptr_t arg, int reg, struct lm75_unit *unitp, int mode) {
    i2c_transfer_t      *i2c_tran_pointer;
    int err = DDI_SUCCESS;
    int16_t         temp16;

    if (ddi_copyin((caddr_t)arg, (caddr_t)&temp16,
            sizeof (int16_t), mode) != DDI_SUCCESS) {
        D2CMN_ERR((CE_WARN, "%s: Failed in LM74_SET_HYST "
                "ddi_copyin routine\n",
                unitp->lm75_name));
        return (EFAULT);
    }

    (void) i2c_transfer_alloc(unitp->lm75_hdl, &i2c_tran_pointer,
                3, 0, I2C_SLEEP);
    if (i2c_tran_pointer == NULL) {
        D2CMN_ERR((CE_WARN, "%s: Failed in LM75_SET_HYST "
                "i2c_tran_pointer not allocated\n",
                unitp->lm75_name));
        return (ENOMEM);
    }
    i2c_tran_pointer->i2c_flags = I2C_WR;
    i2c_tran_pointer->i2c_wbuf[0] = (uchar_t)reg;
    i2c_tran_pointer->i2c_wbuf[1] = (temp16 >> 1);
    i2c_tran_pointer->i2c_wbuf[2] = ((temp16 & 0xFE) << 7);

    err = i2c_transfer(unitp->lm75_hdl, i2c_tran_pointer);
    i2c_transfer_free(unitp->lm75_hdl, i2c_tran_pointer);
    return (err);
}

static int
lm75_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
        int *rvalp)
{
    _NOTE(ARGUNUSED(credp, rvalp))

    struct lm75_unit    *unitp;
    int         instance;
    int         err = 0;
    i2c_transfer_t      *i2c_tran_pointer;
    uchar_t         passin_byte;

    if (arg == NULL) {
        D2CMN_ERR((CE_WARN, "LM75: ioctl: arg passed in to ioctl "
                "= NULL\n"));
        err = EINVAL;
        return (err);
    }
    instance = getminor(dev);
    unitp = (struct lm75_unit *)
        ddi_get_soft_state(lm75soft_statep, instance);

    if (unitp == NULL) {
        cmn_err(CE_WARN, "LM75: ioctl: unitp = NULL\n");
        err = ENOMEM;
        return (err);
    }

    mutex_enter(&unitp->lm75_mutex);

    switch (cmd) {
    case I2C_GET_TEMPERATURE:
        err = lm75_get16(arg, LM75_TEMPERATURE_REG, unitp, mode);
        break;

    case LM75_GET_HYST:
        err = lm75_get16(arg, LM75_HYST_REG, unitp, mode);
        break;

    case LM75_SET_HYST:
        err = lm75_set16(arg, LM75_HYST_REG, unitp, mode);
        break;

    case LM75_GET_OVERTEMP_SHUTDOWN:
        err = lm75_get16(arg, LM75_OVERTEMP_REG, unitp, mode);
        break;

    case LM75_SET_OVERTEMP_SHUTDOWN:
        err = lm75_set16(arg, LM75_OVERTEMP_REG, unitp, mode);
        break;

    case LM75_GET_CONFIG:
        (void) i2c_transfer_alloc(unitp->lm75_hdl, &i2c_tran_pointer,
                    1, 1, I2C_SLEEP);
        if (i2c_tran_pointer == NULL) {
            D2CMN_ERR((CE_WARN, "%s: Failed in LM75_GET_CONFIG "
                    "i2c_tran_pointer not allocated\n",
                    unitp->lm75_name));
            err = ENOMEM;
            break;
        }
        i2c_tran_pointer->i2c_flags = I2C_WR_RD;
        i2c_tran_pointer->i2c_wbuf[0] = LM75_CONFIGURATION_REG;

        err = i2c_transfer(unitp->lm75_hdl, i2c_tran_pointer);
        if (err) {
            D2CMN_ERR((CE_WARN, "%s: Failed in LM75_GET_CONFIG "
                    "i2c_transfer routine\n",
                    unitp->lm75_name));
            i2c_transfer_free(unitp->lm75_hdl, i2c_tran_pointer);
            break;
        }
        if (ddi_copyout((caddr_t)i2c_tran_pointer->i2c_rbuf,
                (caddr_t)arg,
                sizeof (uint8_t), mode) != DDI_SUCCESS) {
            D2CMN_ERR((CE_WARN, "%s: Failed in LM75_GET_CONFIG "
                    "ddi_copyout routine\n",
                    unitp->lm75_name));
            err = EFAULT;
        }
        i2c_transfer_free(unitp->lm75_hdl, i2c_tran_pointer);
        break;

    case LM75_SET_CONFIG:
        if (ddi_copyin((caddr_t)arg, (caddr_t)&passin_byte,
                sizeof (uint8_t), mode) != DDI_SUCCESS) {
            D2CMN_ERR((CE_WARN, "%s: Failed in LM75_SET_CONFIG "
                    "ddi_copyin routine\n",
                    unitp->lm75_name));
            err = EFAULT;
            break;
        }
        (void) i2c_transfer_alloc(unitp->lm75_hdl, &i2c_tran_pointer,
                    2, 0, I2C_SLEEP);
        if (i2c_tran_pointer == NULL) {
            D2CMN_ERR((CE_WARN, "%s: Failed in LM75_SET_CONFIG "
                    "i2c_tran_pointer not allocated\n",
                    unitp->lm75_name));
            err = ENOMEM;
            break;
        }
        i2c_tran_pointer->i2c_flags = I2C_WR;
        i2c_tran_pointer->i2c_wbuf[0] = LM75_CONFIGURATION_REG;
        i2c_tran_pointer->i2c_wbuf[1] = passin_byte;

        err = i2c_transfer(unitp->lm75_hdl, i2c_tran_pointer);
        i2c_transfer_free(unitp->lm75_hdl, i2c_tran_pointer);
        break;

    default:
        D2CMN_ERR((CE_WARN, "%s: Invalid IOCTL cmd %x\n",
                unitp->lm75_name, cmd));
        err = EINVAL;
    }

    mutex_exit(&unitp->lm75_mutex);
    return (err);
}

static int
lm75_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    switch (cmd) {
    case DDI_ATTACH:
        return (lm75_do_attach(dip));
    case DDI_RESUME:
        return (lm75_do_resume());
    default:
        return (DDI_FAILURE);
    }
}

static int
lm75_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    switch (cmd) {
    case DDI_DETACH:
        return (lm75_do_detach(dip));
    case DDI_SUSPEND:
        return (lm75_do_suspend());
    default:
        return (DDI_FAILURE);
    }
}

static int
lm75_do_attach(dev_info_t *dip)
{
    struct lm75_unit *unitp;
    int instance;

    instance = ddi_get_instance(dip);

    if (ddi_soft_state_zalloc(lm75soft_statep, instance) != 0) {
        cmn_err(CE_WARN, "%s%d: failed to zalloc softstate\n",
                ddi_get_name(dip), instance);
        return (DDI_FAILURE);
    }

    unitp = ddi_get_soft_state(lm75soft_statep, instance);

    if (unitp == NULL) {
        cmn_err(CE_WARN, "LM75: ioctl: unitp = NULL\n");
        return (ENOMEM);
    }

    (void) snprintf(unitp->lm75_name, sizeof (unitp->lm75_name),
            "%s%d", ddi_node_name(dip), instance);

    if (ddi_create_minor_node(dip, "lm75", S_IFCHR, instance,
            "ddi_i2c:temperature_sensor", NULL) == DDI_FAILURE) {
        cmn_err(CE_WARN, "%s ddi_create_minor_node failed for "
            "%s\n", unitp->lm75_name, "lm75");
        ddi_soft_state_free(lm75soft_statep, instance);

        return (DDI_FAILURE);
    }

    if (i2c_client_register(dip, &unitp->lm75_hdl) != I2C_SUCCESS) {
        ddi_remove_minor_node(dip, NULL);
        ddi_soft_state_free(lm75soft_statep, instance);

        return (DDI_FAILURE);
    }

    mutex_init(&unitp->lm75_mutex, NULL, MUTEX_DRIVER, NULL);

    return (DDI_SUCCESS);
}

static int
lm75_do_resume(void)
{
    int ret = DDI_SUCCESS;

    return (ret);
}

static int
lm75_do_suspend()
{
    int ret = DDI_SUCCESS;

    return (ret);
}

static int
lm75_do_detach(dev_info_t *dip)
{
    struct lm75_unit *unitp;
    int instance;

    instance = ddi_get_instance(dip);

    unitp = ddi_get_soft_state(lm75soft_statep, instance);

    if (unitp == NULL) {
        cmn_err(CE_WARN, "LM75: ioctl: unitp = NULL\n");
        return (ENOMEM);
    }

    i2c_client_unregister(unitp->lm75_hdl);

    ddi_remove_minor_node(dip, NULL);

    mutex_destroy(&unitp->lm75_mutex);
    ddi_soft_state_free(lm75soft_statep, instance);

    return (DDI_SUCCESS);
}