xref: /onnv-gate/usr/src/uts/sun4u/io/i2c/clients/adm1031.c (revision 7656:2621e50fdf4a)

/*
 * 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.
 */


#include <sys/stat.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/conf.h>
#include <sys/mode.h>
#include <sys/promif.h>
#include <sys/note.h>
#include <sys/i2c/misc/i2c_svc.h>
#include <sys/i2c/clients/i2c_client.h>
#include <sys/i2c/clients/adm1031.h>
#include <sys/i2c/clients/adm1031_impl.h>

/*
 * ADM1031 is an Intelligent Temperature Monitor and Dual PWM Fan Controller.
 * The functions supported by the driver are:
 * 	Reading sensed temperatures.
 * 	Setting temperature limits which control fan speeds.
 * 	Reading fan speeds.
 * 	Setting fan outputs.
 *	Reading internal registers.
 *	Setting internal registers.
 */

/*
 * A pointer to an int16_t is expected as an ioctl argument for all temperature
 * related commands and a pointer to a uint8_t is expected for all other
 * commands.  If the  parameter is to be read the value is copied into it and
 * if it is to be written, the integer referred to should have the appropriate
 * value.
 *
 * For all temperature related commands, a temperature minor node should be
 * passed as the argument to open(2) and correspondingly, a fan minor node
 * should be used for all fan related commands. Commands which do not fall in
 * either of the two categories are control commands and involve
 * reading/writing to the internal registers of the device or switching from
 * automatic monitoring mode to manual mode and vice-versa. A control minor
 * node is created by the driver which has to be used for control commands.
 *
 * Fan Speed in RPM = (frequency * 60)/Count * N, where Count is the value
 * received in the fan speed register and N is Speed Range.
 */

/*
 * cb ops
 */
static int adm1031_open(dev_t *, int, int, cred_t *);
static int adm1031_close(dev_t, int, int, cred_t *);
static int adm1031_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/*
 * dev ops
 */
static int adm1031_s_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int adm1031_s_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

static struct cb_ops adm1031_cb_ops = {
	adm1031_open,			/* open */
	adm1031_close,			/* close */
	nodev,				/* strategy */
	nodev,				/* print */
	nodev,				/* dump */
	nodev,				/* read */
	nodev,				/* write */
	adm1031_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 */
};

static struct dev_ops adm1031_dev_ops = {
	DEVO_REV,
	0,
	ddi_no_info,
	nulldev,
	nulldev,
	adm1031_s_attach,
	adm1031_s_detach,
	nodev,
	&adm1031_cb_ops,
	NULL,
	NULL,
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

static uint8_t adm1031_control_regs[] = {
	0x00,
	ADM1031_STAT_1_REG,
	ADM1031_STAT_2_REG,
	ADM1031_DEVICE_ID_REG,
	ADM1031_CONFIG_REG_1,
	ADM1031_CONFIG_REG_2,
	ADM1031_FAN_CHAR_1_REG,
	ADM1031_FAN_CHAR_2_REG,
	ADM1031_FAN_SPEED_CONFIG_REG,
	ADM1031_FAN_HIGH_LIMIT_1_REG,
	ADM1031_FAN_HIGH_LIMIT_2_REG,
	ADM1031_LOCAL_TEMP_RANGE_REG,
	ADM1031_REMOTE_TEMP_RANGE_1_REG,
	ADM1031_REMOTE_TEMP_RANGE_2_REG,
	ADM1031_EXTD_TEMP_RESL_REG,
	ADM1031_LOCAL_TEMP_OFFSET_REG,
	ADM1031_REMOTE_TEMP_OFFSET_1_REG,
	ADM1031_REMOTE_TEMP_OFFSET_2_REG,
	ADM1031_LOCAL_TEMP_HIGH_LIMIT_REG,
	ADM1031_REMOTE_TEMP_HIGH_LIMIT_1_REG,
	ADM1031_REMOTE_TEMP_HIGH_LIMIT_2_REG,
	ADM1031_LOCAL_TEMP_LOW_LIMIT_REG,
	ADM1031_REMOTE_TEMP_LOW_LIMIT_1_REG,
	ADM1031_REMOTE_TEMP_LOW_LIMIT_2_REG,
	ADM1031_LOCAL_TEMP_THERM_LIMIT_REG,
	ADM1031_REMOTE_TEMP_THERM_LIMIT_1_REG,
	ADM1031_REMOTE_TEMP_THERM_LIMIT_2_REG
};

static  minor_info	temperatures[ADM1031_TEMP_CHANS] = {
	{"local", ADM1031_LOCAL_TEMP_INST_REG }, /* Local Temperature */
	{"remote_1", ADM1031_REMOTE_TEMP_INST_REG_1 }, /* Remote 1 */
	{"remote_2", ADM1031_REMOTE_TEMP_INST_REG_2 }  /* Remote 2 */
};

static	minor_info	fans[ADM1031_FAN_SPEED_CHANS] = {
	{"fan_1", ADM1031_FAN_SPEED_INST_REG_1},
	{"fan_2", ADM1031_FAN_SPEED_INST_REG_2}
};

static struct modldrv adm1031_modldrv = {
	&mod_driverops,		/* type of module - driver */
	"adm1031 device driver",
	&adm1031_dev_ops,
};

static struct modlinkage adm1031_modlinkage = {
	MODREV_1,
	&adm1031_modldrv,
	0
};

static void *adm1031_soft_statep;
int	adm1031_pil = ADM1031_PIL;


int
_init(void)
{
	int    err;

	err = mod_install(&adm1031_modlinkage);
	if (err == 0) {
		(void) ddi_soft_state_init(&adm1031_soft_statep,
		    sizeof (adm1031_unit_t), 1);
	}
	return (err);
}

int
_fini(void)
{
	int    err;

	err = mod_remove(&adm1031_modlinkage);
	if (err == 0) {
		ddi_soft_state_fini(&adm1031_soft_statep);
	}
	return (err);
}

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

static int
adm1031_resume(dev_info_t *dip)
{
	int 		instance = ddi_get_instance(dip);
	adm1031_unit_t	*admp;
	int 		err = DDI_SUCCESS;

	admp = (adm1031_unit_t *)
	    ddi_get_soft_state(adm1031_soft_statep, instance);

	if (admp == NULL) {
		return (DDI_FAILURE);
	}

	/*
	 * Restore registers to state existing before cpr
	 */
	admp->adm1031_transfer->i2c_flags = I2C_WR;
	admp->adm1031_transfer->i2c_wlen = 2;
	admp->adm1031_transfer->i2c_rlen = 0;

	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_CONFIG_REG_1;
	admp->adm1031_transfer->i2c_wbuf[1] =
	    admp->adm1031_cpr_state.config_reg_1;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    DDI_SUCCESS) {
		err = DDI_FAILURE;
		goto done;
	}
	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_CONFIG_REG_2;
	admp->adm1031_transfer->i2c_wbuf[1] =
	    admp->adm1031_cpr_state.config_reg_2;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    DDI_SUCCESS) {
		err = DDI_FAILURE;
		goto done;
	}
	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_FAN_SPEED_CONFIG_REG;
	admp->adm1031_transfer->i2c_wbuf[1] =
	    admp->adm1031_cpr_state.fan_speed_reg;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    DDI_SUCCESS) {
		err = DDI_FAILURE;
		goto done;
	}

	/*
	 * Clear busy flag so that transactions may continue
	 */
	mutex_enter(&admp->adm1031_mutex);
	admp->adm1031_flags = admp->adm1031_flags & ~ADM1031_BUSYFLAG;
	cv_signal(&admp->adm1031_cv);
	mutex_exit(&admp->adm1031_mutex);

done:
	if (err != DDI_SUCCESS) {
		cmn_err(CE_WARN, "%s:%d Registers not restored correctly",
		    admp->adm1031_name, instance);
	}
	return (err);
}

static void
adm1031_detach(dev_info_t *dip)
{
	adm1031_unit_t 	*admp;
	int 		instance = ddi_get_instance(dip);

	admp = ddi_get_soft_state(adm1031_soft_statep, instance);

	if (admp->adm1031_flags & ADM1031_REGFLAG) {
		i2c_client_unregister(admp->adm1031_hdl);
	}
	if (admp->adm1031_flags & ADM1031_TBUFFLAG) {
		i2c_transfer_free(admp->adm1031_hdl, admp->adm1031_transfer);
	}
	if (admp->adm1031_flags & ADM1031_INTRFLAG) {
		ddi_remove_intr(dip, 0, admp->adm1031_icookie);
		cv_destroy(&admp->adm1031_icv);
		mutex_destroy(&admp->adm1031_imutex);
	}

	(void) ddi_prop_remove_all(dip);
	ddi_remove_minor_node(dip, NULL);
	cv_destroy(&admp->adm1031_cv);
	mutex_destroy(&admp->adm1031_mutex);
	ddi_soft_state_free(adm1031_soft_statep, instance);

}

static uint_t
adm1031_intr(caddr_t arg)
{
	adm1031_unit_t	*admp = (adm1031_unit_t *)arg;


	if (admp->adm1031_cvwaiting == 0)
		return (DDI_INTR_CLAIMED);

	mutex_enter(&admp->adm1031_imutex);
	cv_broadcast(&admp->adm1031_icv);
	admp->adm1031_cvwaiting = 0;
	mutex_exit(&admp->adm1031_imutex);

	return (DDI_INTR_CLAIMED);
}

static int
adm1031_attach(dev_info_t *dip)
{
	adm1031_unit_t 		*admp;
	int 			instance = ddi_get_instance(dip);
	minor_t 		minor;
	int 			i;
	char			*minor_name;
	int			err = 0;

	if (ddi_soft_state_zalloc(adm1031_soft_statep, instance) != 0) {
		cmn_err(CE_WARN, "%s:%d failed to zalloc softstate",
		    ddi_get_name(dip), instance);
		return (DDI_FAILURE);
	}
	admp = ddi_get_soft_state(adm1031_soft_statep, instance);
	if (admp == NULL) {
		return (DDI_FAILURE);
	}
	admp->adm1031_dip = dip;
	mutex_init(&admp->adm1031_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&admp->adm1031_cv, NULL, CV_DRIVER, NULL);

	(void) snprintf(admp->adm1031_name, sizeof (admp->adm1031_name),
	    "%s_%d", ddi_driver_name(dip), instance);

	/*
	 * Create minor node for all temperature functions.
	 */
	for (i = 0; i < ADM1031_TEMP_CHANS; i++) {

		minor_name = temperatures[i].minor_name;
		minor = ADM1031_INST_TO_MINOR(instance) |
		    ADM1031_FCN_TO_MINOR(ADM1031_TEMPERATURES) |
		    ADM1031_FCNINST_TO_MINOR(i);

		if (ddi_create_minor_node(dip, minor_name, S_IFCHR, minor,
		    ADM1031_NODE_TYPE, NULL) == DDI_FAILURE) {
			cmn_err(CE_WARN, "%s:%d ddi_create_minor_node failed",
			    admp->adm1031_name, instance);
			adm1031_detach(dip);
			return (DDI_FAILURE);
		}
	}

	/*
	 * Create minor node for all fan functions.
	 */
	for (i = 0; i < ADM1031_FAN_SPEED_CHANS; i++) {

		minor_name = fans[i].minor_name;
		minor = ADM1031_INST_TO_MINOR(instance) |
		    ADM1031_FCN_TO_MINOR(ADM1031_FANS) |
		    ADM1031_FCNINST_TO_MINOR(i);

		if (ddi_create_minor_node(dip, minor_name, S_IFCHR, minor,
		    ADM1031_NODE_TYPE, NULL) == DDI_FAILURE) {
			cmn_err(CE_WARN, "%s:%d ddi_create_minor_node failed",
			    admp->adm1031_name, instance);
			adm1031_detach(dip);
			return (DDI_FAILURE);
		}
	}

	/*
	 * Create minor node for all control functions.
	 */
	minor = ADM1031_INST_TO_MINOR(instance) |
	    ADM1031_FCN_TO_MINOR(ADM1031_CONTROL) |
	    ADM1031_FCNINST_TO_MINOR(0);

	if (ddi_create_minor_node(dip, "control", S_IFCHR, minor,
	    ADM1031_NODE_TYPE, NULL) == DDI_FAILURE) {
		cmn_err(CE_WARN, "%s:%d ddi_create_minor_node failed",
		    admp->adm1031_name, instance);
		adm1031_detach(dip);
		return (DDI_FAILURE);
	}

	/*
	 * preallocate a single buffer for all reads and writes
	 */
	if (i2c_transfer_alloc(admp->adm1031_hdl, &admp->adm1031_transfer,
	    ADM1031_MAX_XFER, ADM1031_MAX_XFER, I2C_SLEEP) != I2C_SUCCESS) {
		cmn_err(CE_WARN, "%s:%d i2c_transfer_alloc failed",
		    admp->adm1031_name, instance);
		adm1031_detach(dip);
		return (DDI_FAILURE);
	}
	admp->adm1031_flags |= ADM1031_TBUFFLAG;
	admp->adm1031_transfer->i2c_version = I2C_XFER_REV;

	if (i2c_client_register(dip, &admp->adm1031_hdl) != I2C_SUCCESS) {
		cmn_err(CE_WARN, "%s:%d i2c_client_register failed",
		    admp->adm1031_name, instance);
		adm1031_detach(dip);
		return (DDI_FAILURE);
	}
	admp->adm1031_flags |= ADM1031_REGFLAG;

	if (ddi_prop_exists(DDI_DEV_T_ANY, dip,
	    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
	    "interrupt-priorities") != 1) {
		(void) ddi_prop_create(DDI_DEV_T_NONE, dip,
		    DDI_PROP_CANSLEEP, "interrupt-priorities",
		    (void *)&adm1031_pil, sizeof (adm1031_pil));
	}
	err = ddi_get_iblock_cookie(dip, 0, &admp->adm1031_icookie);
	if (err == DDI_SUCCESS) {
		mutex_init(&admp->adm1031_imutex, NULL, MUTEX_DRIVER,
		    (void *)admp->adm1031_icookie);
		cv_init(&admp->adm1031_icv, NULL, CV_DRIVER, NULL);
		if (ddi_add_intr(dip, 0, NULL, NULL, adm1031_intr,
		    (caddr_t)admp) == DDI_SUCCESS) {
			admp->adm1031_flags |= ADM1031_INTRFLAG;
		} else {
			cmn_err(CE_WARN, "%s:%d failed to add interrupt",
			    admp->adm1031_name, instance);
		}
	}

	/*
	 * The system comes up in Automatic Monitor Mode.
	 */
	admp->adm1031_flags |= ADM1031_AUTOFLAG;

	return (DDI_SUCCESS);
}

static int
adm1031_s_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_ATTACH:
		return (adm1031_attach(dip));
	case DDI_RESUME:
		return (adm1031_resume(dip));
	default:
		return (DDI_FAILURE);
	}
}

static int
adm1031_suspend(dev_info_t *dip)
{
	adm1031_unit_t 	*admp;
	int 		instance = ddi_get_instance(dip);
	int		err = DDI_SUCCESS;

	admp = ddi_get_soft_state(adm1031_soft_statep, instance);

	/*
	 * Set the busy flag so that future transactions block
	 * until resume.
	 */
	mutex_enter(&admp->adm1031_mutex);
	while (admp->adm1031_flags & ADM1031_BUSYFLAG) {
		if (cv_wait_sig(&admp->adm1031_cv,
		    &admp->adm1031_mutex) <= 0) {
			mutex_exit(&admp->adm1031_mutex);
			return (DDI_FAILURE);
		}
	}
	admp->adm1031_flags |= ADM1031_BUSYFLAG;
	mutex_exit(&admp->adm1031_mutex);

	/*
	 * Save the state of the threshold registers.
	 */
	admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
	admp->adm1031_transfer->i2c_wlen = 1;
	admp->adm1031_transfer->i2c_rlen = 1;

	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_CONFIG_REG_1;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    DDI_SUCCESS) {
		err = DDI_FAILURE;
		goto done;
	}
	admp->adm1031_cpr_state.config_reg_1 =
	    admp->adm1031_transfer->i2c_rbuf[0];

	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_CONFIG_REG_2;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    DDI_SUCCESS) {
		err = DDI_FAILURE;
		goto done;
	}
	admp->adm1031_cpr_state.config_reg_2 =
	    admp->adm1031_transfer->i2c_rbuf[0];

	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_FAN_SPEED_CONFIG_REG;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    DDI_SUCCESS) {
		err = DDI_FAILURE;
		goto done;
	}
	admp->adm1031_cpr_state.fan_speed_reg =
	    admp->adm1031_transfer->i2c_rbuf[0];
done:
	if (err != DDI_SUCCESS) {
		mutex_enter(&admp->adm1031_mutex);
		admp->adm1031_flags = admp->adm1031_flags & ~ADM1031_BUSYFLAG;
		cv_broadcast(&admp->adm1031_cv);
		mutex_exit(&admp->adm1031_mutex);
		cmn_err(CE_WARN, "%s:%d Suspend failed,\
		    unable to save registers", admp->adm1031_name, instance);
	}
	return (err);

}

static int
adm1031_s_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		adm1031_detach(dip);
		return (DDI_SUCCESS);
	case DDI_SUSPEND:
		return (adm1031_suspend(dip));
	default:
		return (DDI_FAILURE);
	}
}

static int
adm1031_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
	int			instance;
	adm1031_unit_t		*admp;
	int			err = EBUSY;

	/* must be root to access this device */
	if (drv_priv(credp) != 0) {
		return (EPERM);
	}

	/*
	 * Make sure the open is for the right file type
	 */
	if (otyp != OTYP_CHR) {
		return (EINVAL);
	}
	instance = ADM1031_MINOR_TO_INST(getminor(*devp));
	admp = (adm1031_unit_t *)
	    ddi_get_soft_state(adm1031_soft_statep, instance);
	if (admp == NULL) {
		return (ENXIO);
	}

	/*
	 * Enforce exclusive access if required.
	 */
	mutex_enter(&admp->adm1031_mutex);
	if (flags & FEXCL) {
		if (admp->adm1031_oflag == 0) {
			admp->adm1031_oflag = FEXCL;
			err = 0;
		}
	} else if (admp->adm1031_oflag != FEXCL) {
		admp->adm1031_oflag = FOPEN;
		err = 0;
	}
	mutex_exit(&admp->adm1031_mutex);
	return (err);
}

static int
adm1031_close(dev_t dev, int flags, int otyp, cred_t *credp)
{
	int		instance;
	adm1031_unit_t 	*admp;

	_NOTE(ARGUNUSED(flags, otyp, credp))

	instance = ADM1031_MINOR_TO_INST(getminor(dev));
	admp = (adm1031_unit_t *)
	    ddi_get_soft_state(adm1031_soft_statep, instance);
	if (admp == NULL) {
		return (ENXIO);
	}

	mutex_enter(&admp->adm1031_mutex);
	admp->adm1031_oflag = 0;
	mutex_exit(&admp->adm1031_mutex);
	return (0);
}

static int
adm1031_s_ioctl(dev_t dev, int cmd, intptr_t arg, int mode)
{
	adm1031_unit_t	*admp;
	int		err = 0, cmd_c = 0;
	uint8_t		speed = 0, f_set = 0, temp = 0, write_value = 0;
	int16_t		temp16 = 0, write_value16 = 0;
	minor_t		minor = getminor(dev);
	int		instance = ADM1031_MINOR_TO_INST(minor);
	int		fcn = ADM1031_MINOR_TO_FCN(minor);
	int		fcn_inst = ADM1031_MINOR_TO_FCNINST(minor);

	admp = (adm1031_unit_t *)
	    ddi_get_soft_state(adm1031_soft_statep, instance);

	/*
	 * We serialize here and block pending transactions.
	 */
	mutex_enter(&admp->adm1031_mutex);
	while (admp->adm1031_flags & ADM1031_BUSYFLAG) {
		if (cv_wait_sig(&admp->adm1031_cv,
		    &admp->adm1031_mutex) <= 0) {
			mutex_exit(&admp->adm1031_mutex);
			return (EINTR);
		}
	}
	admp->adm1031_flags |= ADM1031_BUSYFLAG;
	mutex_exit(&admp->adm1031_mutex);

	switch (fcn) {
	case ADM1031_TEMPERATURES:
		if (cmd == I2C_GET_TEMPERATURE) {
			admp->adm1031_transfer->i2c_wbuf[0] =
			    temperatures[fcn_inst].reg;
			goto copyout;
		} else {
			cmd = cmd - ADM1031_PVT_BASE_IOCTL;
			cmd_c = ADM1031_CHECK_FOR_WRITES(cmd) ?
			    (cmd - ADM1031_WRITE_COMMAND_BASE) + fcn_inst :
			    cmd + fcn_inst;
			if (!ADM1031_CHECK_TEMPERATURE_CMD(cmd_c)) {
				err = EINVAL;
				goto done;
			}
			admp->adm1031_transfer->i2c_wbuf[0] =
			    adm1031_control_regs[cmd_c];
			if (ADM1031_CHECK_FOR_WRITES(cmd))
				goto writes;
			else
				goto copyout;
		}
	case ADM1031_FANS:
		if (cmd == I2C_GET_FAN_SPEED) {
			admp->adm1031_transfer->i2c_wbuf[0] =
			    fans[fcn_inst].reg;
			goto copyout;
		} else if (cmd == ADM1031_GET_FAN_CONFIG) {
			admp->adm1031_transfer->i2c_wbuf[0] =
			    ADM1031_FAN_SPEED_CONFIG_REG;
			goto copyout;
		} else if (cmd == I2C_SET_FAN_SPEED) {
			if (ddi_copyin((void *)arg, &write_value,
			    sizeof (write_value), mode) != DDI_SUCCESS) {

				err = EFAULT;
				goto done;
			}
			speed = write_value;
			if ((admp->adm1031_flags & ADM1031_AUTOFLAG)) {
				err = EBUSY;
				goto done;
			}
			if (ADM1031_CHECK_INVALID_SPEED(speed)) {
				err = EINVAL;
				goto done;
			}
			admp->adm1031_transfer->i2c_wbuf[0] =
			    ADM1031_FAN_SPEED_CONFIG_REG;
			admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
			admp->adm1031_transfer->i2c_wlen = 1;
			admp->adm1031_transfer->i2c_rlen = 1;
			if (i2c_transfer(admp->adm1031_hdl,
			    admp->adm1031_transfer) != I2C_SUCCESS) {
				err = EIO;
				goto done;
			}
			f_set = admp->adm1031_transfer->i2c_rbuf[0];
			f_set = (fcn_inst == 0) ? (MLSN(f_set) | speed):
			    (MMSN(f_set) | (speed << 4));

			admp->adm1031_transfer->i2c_wbuf[1] = f_set;
			admp->adm1031_transfer->i2c_flags = I2C_WR;
			admp->adm1031_transfer->i2c_wlen = 2;
			if (i2c_transfer(admp->adm1031_hdl,
			    admp->adm1031_transfer) != I2C_SUCCESS) {
				err = EIO;
			}
			goto done;
		}
		cmd = cmd - ADM1031_PVT_BASE_IOCTL;
		cmd_c = ADM1031_CHECK_FOR_WRITES(cmd) ?
		    (cmd - ADM1031_WRITE_COMMAND_BASE) + fcn_inst :
		    cmd + fcn_inst;
		if (!ADM1031_CHECK_FAN_CMD(cmd_c)) {
			err = EINVAL;
			goto done;
		}
		admp->adm1031_transfer->i2c_wbuf[0] =
		    adm1031_control_regs[cmd_c];
		if (ADM1031_CHECK_FOR_WRITES(cmd))
			goto writes;
		else
			goto copyout;
	case ADM1031_CONTROL:

		/*
		 * Read the primary configuration register in advance.
		 */
		admp->adm1031_transfer->i2c_wbuf[0] =
		    ADM1031_CONFIG_REG_1;
		admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
		admp->adm1031_transfer->i2c_wlen = 1;
		admp->adm1031_transfer->i2c_rlen = 1;
		if (i2c_transfer(admp->adm1031_hdl,
		    admp->adm1031_transfer) != I2C_SUCCESS) {
			err = EIO;
			goto done;
		}
		switch (cmd) {
		case ADM1031_GET_MONITOR_MODE:
			temp = ADM1031_AUTOFLAG &
			    admp->adm1031_transfer->i2c_rbuf[0];
			temp = temp >> 7;
			if (ddi_copyout((void *)&temp, (void *)arg,
			    sizeof (temp), mode) != DDI_SUCCESS) {
				err = EFAULT;
			}
			goto done;
		case ADM1031_SET_MONITOR_MODE:
			if (ddi_copyin((void *)arg, &write_value,
			    sizeof (write_value), mode) != DDI_SUCCESS) {
				err = EFAULT;
				goto done;
			}
			if (write_value == ADM1031_AUTO_MODE) {
				temp = ADM1031_AUTOFLAG |
				    admp->adm1031_transfer->i2c_rbuf[0];
				admp->adm1031_flags |= ADM1031_AUTOFLAG;
			} else if (write_value == ADM1031_MANUAL_MODE) {
				temp = admp->adm1031_transfer->i2c_rbuf[0] &
				    (~ADM1031_AUTOFLAG);
				admp->adm1031_flags &= ~ADM1031_AUTOFLAG;
			} else {
				err = EINVAL;
				goto done;
			}
			admp->adm1031_transfer->i2c_wbuf[1] = temp;
			admp->adm1031_transfer->i2c_flags = I2C_WR;
			admp->adm1031_transfer->i2c_wlen = 2;
			if (i2c_transfer(admp->adm1031_hdl,
			    admp->adm1031_transfer) != I2C_SUCCESS) {
				err = EIO;
			}
			goto done;
		default:
			goto control;
		}
	default:
		err = EINVAL;
		goto done;
	}

control:
	cmd = cmd - ADM1031_PVT_BASE_IOCTL;

	if (ADM1031_CHECK_FOR_WRITES(cmd)) {
		cmd_c = (cmd - ADM1031_WRITE_COMMAND_BASE) + fcn_inst;
		admp->adm1031_transfer->i2c_wbuf[0] =
		    adm1031_control_regs[cmd_c];

		goto writes;
	}
	cmd_c = cmd  + fcn_inst;
	admp->adm1031_transfer->i2c_wbuf[0] = adm1031_control_regs[cmd_c];
	goto copyout;

writes:
	if (fcn == ADM1031_TEMPERATURES) {
		if (ddi_copyin((void *)arg, &write_value16,
		    sizeof (write_value16), mode) != DDI_SUCCESS) {

			err = EFAULT;
			goto done;
		}
		write_value = (uint8_t)((int8_t)(write_value16));
	} else {
		if (ddi_copyin((void *)arg, &write_value,
		    sizeof (write_value), mode) != DDI_SUCCESS) {

			err = EFAULT;
			goto done;
		}
	}
	admp->adm1031_transfer->i2c_flags = I2C_WR;
	admp->adm1031_transfer->i2c_wlen = 2;
	admp->adm1031_transfer->i2c_rlen = 0;
	admp->adm1031_transfer->i2c_wbuf[1] = write_value;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {

		err = EIO;
	}
	goto done;

copyout:
	admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
	admp->adm1031_transfer->i2c_wlen = 1;
	admp->adm1031_transfer->i2c_rlen = 1;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {

		err = EIO;
		goto done;
	}
	temp = admp->adm1031_transfer->i2c_rbuf[0];
	if (fcn == ADM1031_TEMPERATURES) {
		/*
		 * Workaround for bug in ADM1031 which reports -128 (0x80)
		 * when the temperature transitions from 0C to -1C.
		 * All other -ve temperatures are not affected. We map
		 * 0x80 to 0xFF(-1) since we don't ever expect to see -128C on a
		 * sensor.
		 */
		if (temp == 0x80) {
			temp = 0xFF;
		}
		temp16 = (int16_t)((int8_t)temp);
		if (ddi_copyout((void *)&temp16, (void *)arg, sizeof (temp16),
		    mode) != DDI_SUCCESS)
			err = EFAULT;
	} else {
		if (ddi_copyout((void *)&temp, (void *)arg, sizeof (temp),
		    mode) != DDI_SUCCESS)
			err = EFAULT;
	}

done:
	mutex_enter(&admp->adm1031_mutex);
	admp->adm1031_flags = admp->adm1031_flags & (~ADM1031_BUSYFLAG);
	cv_signal(&admp->adm1031_cv);
	mutex_exit(&admp->adm1031_mutex);
	return (err);
}

/*
 * The interrupt ioctl is a private handshake between the user and the driver
 * and is a mechanism to asynchronously inform the user of a system event such
 * as a fan fault or a temperature limit being exceeded.
 *
 * Step 1):
 *	User(or environmental monitoring software) calls the ioctl routine
 *	which blocks as it waits on a condition. The open(2) call has to be
 *	called with the _control minor node. The ioctl routine requires
 *	ADM1031_INTERRUPT_WAIT as the command and a pointer to an array of
 *	uint8_t as the third argument.
 * Step 2):
 *	A system event occurs which unblocks the ioctl and returns the call
 *	to the user.
 * Step 3):
 *	User reads the contents of the array (which actually contains the values
 *	of the devices' status registers) to determine the exact nature of the
 * 	event.
 */
static int
adm1031_i_ioctl(dev_t dev, int cmd, intptr_t arg, int mode)
{
	_NOTE(ARGUNUSED(cmd))
	adm1031_unit_t	*admp;
	uint8_t		i = 0;
	minor_t		minor = getminor(dev);
	int		fcn = ADM1031_MINOR_TO_FCN(minor);
	int		instance = ADM1031_MINOR_TO_INST(minor);
	int		err = 0;
	uint8_t		temp[2];
	uint8_t		temp1;


	if (fcn != ADM1031_CONTROL)
		return (EINVAL);

	admp = (adm1031_unit_t *)
	    ddi_get_soft_state(adm1031_soft_statep, instance);

	if (!(admp->adm1031_flags & ADM1031_INTRFLAG)) {
		cmn_err(CE_WARN, "%s:%d No interrupt handler registered\n",
		    admp->adm1031_name, instance);
		return (EBUSY);
	}

	admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
	admp->adm1031_transfer->i2c_wlen = 1;
	admp->adm1031_transfer->i2c_rlen = 1;

	/*
	 * The register has to be read to clear the previous status.
	 */

	for (i = 0; i < 2; i++) {
		admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_STAT_1_REG;
		if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer)
		    != I2C_SUCCESS) {
			return (EIO);
		}
		temp[0] = admp->adm1031_transfer->i2c_rbuf[0];
		admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_STAT_2_REG;
		if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer)
		    != I2C_SUCCESS) {
			return (EIO);
		}
	}
	temp[1] = admp->adm1031_transfer->i2c_rbuf[0];

	if ((temp[0] != 0) || (temp[1] != 0)) {
		goto copyout;
	}

	/*
	 * Enable the interrupt and fan fault alert.
	 */
	mutex_enter(&admp->adm1031_mutex);
	while (admp->adm1031_flags & ADM1031_BUSYFLAG) {
		if (cv_wait_sig(&admp->adm1031_cv,
		    &admp->adm1031_mutex) <= 0) {
			mutex_exit(&admp->adm1031_mutex);
			return (EINTR);
		}
	}
	admp->adm1031_flags |= ADM1031_BUSYFLAG;

	mutex_exit(&admp->adm1031_mutex);

	admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
	admp->adm1031_transfer->i2c_wlen = 1;
	admp->adm1031_transfer->i2c_rlen = 1;
	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_CONFIG_REG_1;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {
		err = EIO;
		goto err;
	}

	temp1 = admp->adm1031_transfer->i2c_rbuf[0];

	admp->adm1031_transfer->i2c_flags = I2C_WR;
	admp->adm1031_transfer->i2c_wlen = 2;
	admp->adm1031_transfer->i2c_wbuf[1] = (temp1 | 0x12);

	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {
		err = EIO;
		goto err;
	}


	mutex_enter(&admp->adm1031_mutex);
	admp->adm1031_flags = admp->adm1031_flags & (~ADM1031_BUSYFLAG);
	cv_signal(&admp->adm1031_cv);
	mutex_exit(&admp->adm1031_mutex);



	mutex_enter(&admp->adm1031_imutex);
	admp->adm1031_cvwaiting = 1;
	(void) cv_wait_sig(&admp->adm1031_icv, &admp->adm1031_imutex);
	mutex_exit(&admp->adm1031_imutex);


	/*
	 * Disable the interrupt and fan fault alert.
	 */
	mutex_enter(&admp->adm1031_mutex);

	while (admp->adm1031_flags & ADM1031_BUSYFLAG) {
		if (cv_wait_sig(&admp->adm1031_cv,
		    &admp->adm1031_mutex) <= 0) {
			mutex_exit(&admp->adm1031_mutex);
			return (EINTR);
		}
	}
	admp->adm1031_flags |= ADM1031_BUSYFLAG;

	admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
	admp->adm1031_transfer->i2c_wlen = 1;
	admp->adm1031_transfer->i2c_rlen = 1;
	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_CONFIG_REG_1;

	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {
		err = EIO;
		goto err;
	}


	temp1 = admp->adm1031_transfer->i2c_rbuf[0];
	admp->adm1031_transfer->i2c_flags = I2C_WR;
	admp->adm1031_transfer->i2c_wlen = 2;
	admp->adm1031_transfer->i2c_wbuf[1] = (temp1 & (~0x12));

	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {
		err = (EIO);
		goto err;
	}

	admp->adm1031_flags = admp->adm1031_flags & (~ADM1031_BUSYFLAG);
	cv_signal(&admp->adm1031_cv);
	mutex_exit(&admp->adm1031_mutex);

	admp->adm1031_transfer->i2c_flags = I2C_WR_RD;
	admp->adm1031_transfer->i2c_wlen = 1;
	admp->adm1031_transfer->i2c_rlen = 1;
	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_STAT_1_REG;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {

		return (EIO);
	}
	temp[0] = admp->adm1031_transfer->i2c_rbuf[0];

	admp->adm1031_transfer->i2c_wbuf[0] = ADM1031_STAT_2_REG;
	if (i2c_transfer(admp->adm1031_hdl, admp->adm1031_transfer) !=
	    I2C_SUCCESS) {

		return (EIO);
	}
	temp[1] = admp->adm1031_transfer->i2c_rbuf[0];

copyout:
	if (ddi_copyout((void *)&temp, (void *)arg, sizeof (temp),
	    mode) != DDI_SUCCESS) {

		return (EFAULT);
	}

	return (0);

err:
	mutex_enter(&admp->adm1031_mutex);
	admp->adm1031_flags = admp->adm1031_flags & (~ADM1031_BUSYFLAG);
	cv_signal(&admp->adm1031_cv);
	mutex_exit(&admp->adm1031_mutex);

	return (err);
}

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

	if (cmd == ADM1031_INTERRUPT_WAIT) {

		return (adm1031_i_ioctl(dev, cmd, arg, mode));
	} else {
		return (adm1031_s_ioctl(dev, cmd, arg, mode));
	}
}