[deliverable/linux.git] / drivers / hwmon / smsc47m1.c

/*
    smsc47m1.c - Part of lm_sensors, Linux kernel modules
                 for hardware monitoring

    Supports the SMSC LPC47B27x, LPC47M10x, LPC47M13x, LPC47M14x,
    LPC47M15x, LPC47M192 and LPC47M997 Super-I/O chips.

    Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
    Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
    Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
                        and Jean Delvare

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/i2c-isa.h>
#include <linux/hwmon.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/mutex.h>
#include <asm/io.h>

/* Address is autodetected, there is no default value */
static unsigned short address;

/* Super-I/0 registers and commands */

#define	REG	0x2e	/* The register to read/write */
#define	VAL	0x2f	/* The value to read/write */

static inline void
superio_outb(int reg, int val)
{
	outb(reg, REG);
	outb(val, VAL);
}

static inline int
superio_inb(int reg)
{
	outb(reg, REG);
	return inb(VAL);
}

/* logical device for fans is 0x0A */
#define superio_select() superio_outb(0x07, 0x0A)

static inline void
superio_enter(void)
{
	outb(0x55, REG);
}

static inline void
superio_exit(void)
{
	outb(0xAA, REG);
}

#define SUPERIO_REG_ACT		0x30
#define SUPERIO_REG_BASE	0x60
#define SUPERIO_REG_DEVID	0x20

/* Logical device registers */

#define SMSC_EXTENT		0x80

/* nr is 0 or 1 in the macros below */
#define SMSC47M1_REG_ALARM		0x04
#define SMSC47M1_REG_TPIN(nr)		(0x34 - (nr))
#define SMSC47M1_REG_PPIN(nr)		(0x36 - (nr))
#define SMSC47M1_REG_PWM(nr)		(0x56 + (nr))
#define SMSC47M1_REG_FANDIV		0x58
#define SMSC47M1_REG_FAN(nr)		(0x59 + (nr))
#define SMSC47M1_REG_FAN_PRELOAD(nr)	(0x5B + (nr))

#define MIN_FROM_REG(reg,div)		((reg)>=192 ? 0 : \
					 983040/((192-(reg))*(div)))
#define FAN_FROM_REG(reg,div,preload)	((reg)<=(preload) || (reg)==255 ? 0 : \
					 983040/(((reg)-(preload))*(div)))
#define DIV_FROM_REG(reg)		(1 << (reg))
#define PWM_FROM_REG(reg)		(((reg) & 0x7E) << 1)
#define PWM_EN_FROM_REG(reg)		((~(reg)) & 0x01)
#define PWM_TO_REG(reg)			(((reg) >> 1) & 0x7E)

struct smsc47m1_data {
	struct i2c_client client;
	struct class_device *class_dev;
	struct mutex lock;

	struct mutex update_lock;
	unsigned long last_updated;	/* In jiffies */

	u8 fan[2];		/* Register value */
	u8 fan_preload[2];	/* Register value */
	u8 fan_div[2];		/* Register encoding, shifted right */
	u8 alarms;		/* Register encoding */
	u8 pwm[2];		/* Register value (bit 7 is enable) */
};


static int smsc47m1_detect(struct i2c_adapter *adapter);
static int smsc47m1_detach_client(struct i2c_client *client);

static int smsc47m1_read_value(struct i2c_client *client, u8 reg);
static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value);

static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
		int init);


static struct i2c_driver smsc47m1_driver = {
	.driver = {
		.name	= "smsc47m1",
	},
	.attach_adapter	= smsc47m1_detect,
	.detach_client	= smsc47m1_detach_client,
};

/* nr is 0 or 1 in the callback functions below */

static ssize_t get_fan(struct device *dev, char *buf, int nr)
{
	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	/* This chip (stupidly) stops monitoring fan speed if PWM is
	   enabled and duty cycle is 0%. This is fine if the monitoring
	   and control concern the same fan, but troublesome if they are
	   not (which could as well happen). */
	int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
		  FAN_FROM_REG(data->fan[nr],
			       DIV_FROM_REG(data->fan_div[nr]),
			       data->fan_preload[nr]);
	return sprintf(buf, "%d\n", rpm);
}

static ssize_t get_fan_min(struct device *dev, char *buf, int nr)
{
	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	int rpm = MIN_FROM_REG(data->fan_preload[nr],
			       DIV_FROM_REG(data->fan_div[nr]));
	return sprintf(buf, "%d\n", rpm);
}

static ssize_t get_fan_div(struct device *dev, char *buf, int nr)
{
	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
}

static ssize_t get_pwm(struct device *dev, char *buf, int nr)
{
	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
}

static ssize_t get_pwm_en(struct device *dev, char *buf, int nr)
{
	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr]));
}

static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	return sprintf(buf, "%d\n", data->alarms);
}

static ssize_t set_fan_min(struct device *dev, const char *buf,
		size_t count, int nr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct smsc47m1_data *data = i2c_get_clientdata(client);
	long rpmdiv, val = simple_strtol(buf, NULL, 10);

	mutex_lock(&data->update_lock);
	rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);

	if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
		mutex_unlock(&data->update_lock);
		return -EINVAL;
	}

	data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
	smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
			     data->fan_preload[nr]);
	mutex_unlock(&data->update_lock);

	return count;
}

/* Note: we save and restore the fan minimum here, because its value is
   determined in part by the fan clock divider.  This follows the principle
   of least surprise; the user doesn't expect the fan minimum to change just
   because the divider changed. */
static ssize_t set_fan_div(struct device *dev, const char *buf,
		size_t count, int nr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct smsc47m1_data *data = i2c_get_clientdata(client);

	long new_div = simple_strtol(buf, NULL, 10), tmp;
	u8 old_div = DIV_FROM_REG(data->fan_div[nr]);

	if (new_div == old_div) /* No change */
		return count;

	mutex_lock(&data->update_lock);
	switch (new_div) {
	case 1: data->fan_div[nr] = 0; break;
	case 2: data->fan_div[nr] = 1; break;
	case 4: data->fan_div[nr] = 2; break;
	case 8: data->fan_div[nr] = 3; break;
	default:
		mutex_unlock(&data->update_lock);
		return -EINVAL;
	}

	tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F;
	tmp |= (data->fan_div[0] << 4) | (data->fan_div[1] << 6);
	smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp);

	/* Preserve fan min */
	tmp = 192 - (old_div * (192 - data->fan_preload[nr])
		     + new_div / 2) / new_div;
	data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
	smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
			     data->fan_preload[nr]);
	mutex_unlock(&data->update_lock);

	return count;
}

static ssize_t set_pwm(struct device *dev, const char *buf,
		size_t count, int nr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct smsc47m1_data *data = i2c_get_clientdata(client);

	long val = simple_strtol(buf, NULL, 10);

	if (val < 0 || val > 255)
		return -EINVAL;

	mutex_lock(&data->update_lock);
	data->pwm[nr] &= 0x81; /* Preserve additional bits */
	data->pwm[nr] |= PWM_TO_REG(val);
	smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
			     data->pwm[nr]);
	mutex_unlock(&data->update_lock);

	return count;
}

static ssize_t set_pwm_en(struct device *dev, const char *buf,
		size_t count, int nr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct smsc47m1_data *data = i2c_get_clientdata(client);

	long val = simple_strtol(buf, NULL, 10);
	
	if (val != 0 && val != 1)
		return -EINVAL;

	mutex_lock(&data->update_lock);
	data->pwm[nr] &= 0xFE; /* preserve the other bits */
	data->pwm[nr] |= !val;
	smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
			     data->pwm[nr]);
	mutex_unlock(&data->update_lock);

	return count;
}

#define fan_present(offset)						\
static ssize_t get_fan##offset (struct device *dev, struct device_attribute *attr, char *buf)		\
{									\
	return get_fan(dev, buf, offset - 1);				\
}									\
static ssize_t get_fan##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)	\
{									\
	return get_fan_min(dev, buf, offset - 1);			\
}									\
static ssize_t set_fan##offset##_min (struct device *dev, struct device_attribute *attr,		\
		const char *buf, size_t count)				\
{									\
	return set_fan_min(dev, buf, count, offset - 1);		\
}									\
static ssize_t get_fan##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)	\
{									\
	return get_fan_div(dev, buf, offset - 1);			\
}									\
static ssize_t set_fan##offset##_div (struct device *dev, struct device_attribute *attr,		\
		const char *buf, size_t count)				\
{									\
	return set_fan_div(dev, buf, count, offset - 1);		\
}									\
static ssize_t get_pwm##offset (struct device *dev, struct device_attribute *attr, char *buf)		\
{									\
	return get_pwm(dev, buf, offset - 1);				\
}									\
static ssize_t set_pwm##offset (struct device *dev, struct device_attribute *attr,			\
		const char *buf, size_t count)				\
{									\
	return set_pwm(dev, buf, count, offset - 1);			\
}									\
static ssize_t get_pwm##offset##_en (struct device *dev, struct device_attribute *attr, char *buf)	\
{									\
	return get_pwm_en(dev, buf, offset - 1);			\
}									\
static ssize_t set_pwm##offset##_en (struct device *dev, struct device_attribute *attr,		\
		const char *buf, size_t count)				\
{									\
	return set_pwm_en(dev, buf, count, offset - 1);			\
}									\
static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset,	\
		NULL);							\
static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,		\
		get_fan##offset##_min, set_fan##offset##_min);		\
static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,		\
		get_fan##offset##_div, set_fan##offset##_div);		\
static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,			\
		get_pwm##offset, set_pwm##offset);			\
static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,		\
		get_pwm##offset##_en, set_pwm##offset##_en);

fan_present(1);
fan_present(2);

static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);

static int __init smsc47m1_find(unsigned short *addr)
{
	u8 val;

	superio_enter();
	val = superio_inb(SUPERIO_REG_DEVID);

	/*
	 * SMSC LPC47M10x/LPC47M13x (device id 0x59), LPC47M14x (device id
	 * 0x5F) and LPC47B27x (device id 0x51) have fan control.
	 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
	 * can do much more besides (device id 0x60).
	 * The LPC47M997 is undocumented, but seems to be compatible with
	 * the LPC47M192, and has the same device id.
	 */
	if (val == 0x51)
		printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n");
	else if (val == 0x59)
		printk(KERN_INFO "smsc47m1: Found SMSC LPC47M10x/LPC47M13x\n");
	else if (val == 0x5F)
		printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n");
	else if (val == 0x60)
		printk(KERN_INFO "smsc47m1: Found SMSC "
		       "LPC47M15x/LPC47M192/LPC47M997\n");
	else {
		superio_exit();
		return -ENODEV;
	}

	superio_select();
	*addr = (superio_inb(SUPERIO_REG_BASE) << 8)
	      |  superio_inb(SUPERIO_REG_BASE + 1);
	val = superio_inb(SUPERIO_REG_ACT);
	if (*addr == 0 || (val & 0x01) == 0) {
		printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n");
		superio_exit();
		return -ENODEV;
	}

	superio_exit();
	return 0;
}

static int smsc47m1_detect(struct i2c_adapter *adapter)
{
	struct i2c_client *new_client;
	struct smsc47m1_data *data;
	int err = 0;
	int fan1, fan2, pwm1, pwm2;

	if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.driver.name)) {
		dev_err(&adapter->dev, "Region 0x%x already in use!\n", address);
		return -EBUSY;
	}

	if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
		err = -ENOMEM;
		goto error_release;
	}

	new_client = &data->client;
	i2c_set_clientdata(new_client, data);
	new_client->addr = address;
	mutex_init(&data->lock);
	new_client->adapter = adapter;
	new_client->driver = &smsc47m1_driver;
	new_client->flags = 0;

	strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
	mutex_init(&data->update_lock);

	/* If no function is properly configured, there's no point in
	   actually registering the chip. */
	fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05)
	       == 0x05;
	fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05)
	       == 0x05;
	pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05)
	       == 0x04;
	pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05)
	       == 0x04;
	if (!(fan1 || fan2 || pwm1 || pwm2)) {
		dev_warn(&new_client->dev, "Device is not configured, will not use\n");
		err = -ENODEV;
		goto error_free;
	}

	if ((err = i2c_attach_client(new_client)))
		goto error_free;

	/* Some values (fan min, clock dividers, pwm registers) may be
	   needed before any update is triggered, so we better read them
	   at least once here. We don't usually do it that way, but in
	   this particular case, manually reading 5 registers out of 8
	   doesn't make much sense and we're better using the existing
	   function. */
	smsc47m1_update_device(&new_client->dev, 1);

	/* Register sysfs hooks */
	data->class_dev = hwmon_device_register(&new_client->dev);
	if (IS_ERR(data->class_dev)) {
		err = PTR_ERR(data->class_dev);
		goto error_detach;
	}

	if (fan1) {
		device_create_file(&new_client->dev, &dev_attr_fan1_input);
		device_create_file(&new_client->dev, &dev_attr_fan1_min);
		device_create_file(&new_client->dev, &dev_attr_fan1_div);
	} else
		dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, "
			"skipping\n");

	if (fan2) {
		device_create_file(&new_client->dev, &dev_attr_fan2_input);
		device_create_file(&new_client->dev, &dev_attr_fan2_min);
		device_create_file(&new_client->dev, &dev_attr_fan2_div);
	} else
		dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, "
			"skipping\n");

	if (pwm1) {
		device_create_file(&new_client->dev, &dev_attr_pwm1);
		device_create_file(&new_client->dev, &dev_attr_pwm1_enable);
	} else
		dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, "
			"skipping\n");
	if (pwm2) {
		device_create_file(&new_client->dev, &dev_attr_pwm2);
		device_create_file(&new_client->dev, &dev_attr_pwm2_enable);
	} else
		dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, "
			"skipping\n");

	device_create_file(&new_client->dev, &dev_attr_alarms);

	return 0;

error_detach:
	i2c_detach_client(new_client);
error_free:
	kfree(data);
error_release:
	release_region(address, SMSC_EXTENT);
	return err;
}

static int smsc47m1_detach_client(struct i2c_client *client)
{
	struct smsc47m1_data *data = i2c_get_clientdata(client);
	int err;

	hwmon_device_unregister(data->class_dev);

	if ((err = i2c_detach_client(client)))
		return err;

	release_region(client->addr, SMSC_EXTENT);
	kfree(data);

	return 0;
}

static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
{
	int res;

	mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
	res = inb_p(client->addr + reg);
	mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
	return res;
}

static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
{
	mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
	outb_p(value, client->addr + reg);
	mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
}

static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
		int init)
{
 	struct i2c_client *client = to_i2c_client(dev);
	struct smsc47m1_data *data = i2c_get_clientdata(client);

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
		int i;

		for (i = 0; i < 2; i++) {
			data->fan[i] = smsc47m1_read_value(client,
				       SMSC47M1_REG_FAN(i));
			data->fan_preload[i] = smsc47m1_read_value(client,
					       SMSC47M1_REG_FAN_PRELOAD(i));
			data->pwm[i] = smsc47m1_read_value(client,
				       SMSC47M1_REG_PWM(i));
		}

		i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
		data->fan_div[0] = (i >> 4) & 0x03;
		data->fan_div[1] = i >> 6;

		data->alarms = smsc47m1_read_value(client,
			       SMSC47M1_REG_ALARM) >> 6;
		/* Clear alarms if needed */
		if (data->alarms)
			smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0);

		data->last_updated = jiffies;
	}

	mutex_unlock(&data->update_lock);
	return data;
}

static int __init sm_smsc47m1_init(void)
{
	if (smsc47m1_find(&address)) {
		return -ENODEV;
	}

	return i2c_isa_add_driver(&smsc47m1_driver);
}

static void __exit sm_smsc47m1_exit(void)
{
	i2c_isa_del_driver(&smsc47m1_driver);
}

MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
MODULE_LICENSE("GPL");

module_init(sm_smsc47m1_init);
module_exit(sm_smsc47m1_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	smsc47m1.c - Part of lm_sensors, Linux kernel modules
	3	for hardware monitoring
	4
0db9714a	5	Supports the SMSC LPC47B27x, LPC47M10x, LPC47M13x, LPC47M14x,
b890a07f	6	LPC47M15x, LPC47M192 and LPC47M997 Super-I/O chips.
1da177e4 LT	7
	8	Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
	9	Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
	10	Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
	11	and Jean Delvare
	12
	13	This program is free software; you can redistribute it and/or modify
	14	it under the terms of the GNU General Public License as published by
	15	the Free Software Foundation; either version 2 of the License, or
	16	(at your option) any later version.
	17
	18	This program is distributed in the hope that it will be useful,
	19	but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	GNU General Public License for more details.
	22
	23	You should have received a copy of the GNU General Public License
	24	along with this program; if not, write to the Free Software
	25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	26	*/
	27
	28	#include <linux/module.h>
	29	#include <linux/slab.h>
	30	#include <linux/ioport.h>
	31	#include <linux/jiffies.h>
	32	#include <linux/i2c.h>
fde09509	33	#include <linux/i2c-isa.h>
943b0830 MH	34	#include <linux/hwmon.h>
943b0830 MH	35	#include <linux/err.h>
1da177e4	36	#include <linux/init.h>
9a61bf63	37	#include <linux/mutex.h>
1da177e4 LT	38	#include <asm/io.h>
1da177e4 LT	39
1da177e4	40	/* Address is autodetected, there is no default value */
2d8672c5	41	static unsigned short address;
1da177e4 LT	42
	43	/* Super-I/0 registers and commands */
	44
	45	#define REG 0x2e /* The register to read/write */
	46	#define VAL 0x2f /* The value to read/write */
	47
	48	static inline void
	49	superio_outb(int reg, int val)
	50	{
	51	outb(reg, REG);
	52	outb(val, VAL);
	53	}
	54
	55	static inline int
	56	superio_inb(int reg)
	57	{
	58	outb(reg, REG);
	59	return inb(VAL);
	60	}
	61
	62	/* logical device for fans is 0x0A */
	63	#define superio_select() superio_outb(0x07, 0x0A)
	64
	65	static inline void
	66	superio_enter(void)
	67	{
	68	outb(0x55, REG);
	69	}
	70
	71	static inline void
	72	superio_exit(void)
	73	{
	74	outb(0xAA, REG);
	75	}
	76
	77	#define SUPERIO_REG_ACT 0x30
	78	#define SUPERIO_REG_BASE 0x60
	79	#define SUPERIO_REG_DEVID 0x20
	80
	81	/* Logical device registers */
	82
	83	#define SMSC_EXTENT 0x80
	84
	85	/* nr is 0 or 1 in the macros below */
	86	#define SMSC47M1_REG_ALARM 0x04
	87	#define SMSC47M1_REG_TPIN(nr) (0x34 - (nr))
	88	#define SMSC47M1_REG_PPIN(nr) (0x36 - (nr))
	89	#define SMSC47M1_REG_PWM(nr) (0x56 + (nr))
	90	#define SMSC47M1_REG_FANDIV 0x58
	91	#define SMSC47M1_REG_FAN(nr) (0x59 + (nr))
	92	#define SMSC47M1_REG_FAN_PRELOAD(nr) (0x5B + (nr))
	93
	94	#define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \
	95	983040/((192-(reg))*(div)))
	96	#define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) \|\| (reg)==255 ? 0 : \
	97	983040/(((reg)-(preload))*(div)))
	98	#define DIV_FROM_REG(reg) (1 << (reg))
	99	#define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1)
	100	#define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01)
	101	#define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E)
	102
	103	struct smsc47m1_data {
	104	struct i2c_client client;
943b0830	105	struct class_device *class_dev;
9a61bf63	106	struct mutex lock;
1da177e4	107
9a61bf63	108	struct mutex update_lock;
1da177e4 LT	109	unsigned long last_updated; /* In jiffies */
	110
	111	u8 fan[2]; /* Register value */
	112	u8 fan_preload[2]; /* Register value */
	113	u8 fan_div[2]; /* Register encoding, shifted right */
	114	u8 alarms; /* Register encoding */
	115	u8 pwm[2]; /* Register value (bit 7 is enable) */
	116	};
	117
	118
2d8672c5	119	static int smsc47m1_detect(struct i2c_adapter *adapter);
1da177e4 LT	120	static int smsc47m1_detach_client(struct i2c_client *client);
	121
	122	static int smsc47m1_read_value(struct i2c_client *client, u8 reg);
	123	static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value);
	124
	125	static struct smsc47m1_data smsc47m1_update_device(struct device dev,
	126	int init);
	127
	128
	129	static struct i2c_driver smsc47m1_driver = {
cdaf7934	130	.driver = {
cdaf7934 LR	131	.name = "smsc47m1",
cdaf7934 LR	132	},
2d8672c5	133	.attach_adapter = smsc47m1_detect,
1da177e4 LT	134	.detach_client = smsc47m1_detach_client,
	135	};
	136
	137	/* nr is 0 or 1 in the callback functions below */
	138
	139	static ssize_t get_fan(struct device dev, char buf, int nr)
	140	{
	141	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	142	/* This chip (stupidly) stops monitoring fan speed if PWM is
	143	enabled and duty cycle is 0%. This is fine if the monitoring
	144	and control concern the same fan, but troublesome if they are
	145	not (which could as well happen). */
	146	int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
	147	FAN_FROM_REG(data->fan[nr],
	148	DIV_FROM_REG(data->fan_div[nr]),
	149	data->fan_preload[nr]);
	150	return sprintf(buf, "%d\n", rpm);
	151	}
	152
	153	static ssize_t get_fan_min(struct device dev, char buf, int nr)
	154	{
	155	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	156	int rpm = MIN_FROM_REG(data->fan_preload[nr],
	157	DIV_FROM_REG(data->fan_div[nr]));
	158	return sprintf(buf, "%d\n", rpm);
	159	}
	160
	161	static ssize_t get_fan_div(struct device dev, char buf, int nr)
	162	{
	163	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	164	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
	165	}
	166
	167	static ssize_t get_pwm(struct device dev, char buf, int nr)
	168	{
	169	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	170	return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
	171	}
	172
	173	static ssize_t get_pwm_en(struct device dev, char buf, int nr)
	174	{
	175	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	176	return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr]));
	177	}
	178
a5099cfc	179	static ssize_t get_alarms(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	180	{
	181	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
	182	return sprintf(buf, "%d\n", data->alarms);
	183	}
	184
	185	static ssize_t set_fan_min(struct device dev, const char buf,
	186	size_t count, int nr)
	187	{
	188	struct i2c_client *client = to_i2c_client(dev);
	189	struct smsc47m1_data *data = i2c_get_clientdata(client);
	190	long rpmdiv, val = simple_strtol(buf, NULL, 10);
	191
9a61bf63	192	mutex_lock(&data->update_lock);
1da177e4 LT	193	rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
	194
	195	if (983040 > 192 * rpmdiv \|\| 2 * rpmdiv > 983040) {
9a61bf63	196	mutex_unlock(&data->update_lock);
1da177e4 LT	197	return -EINVAL;
	198	}
	199
	200	data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
	201	smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
	202	data->fan_preload[nr]);
9a61bf63	203	mutex_unlock(&data->update_lock);
1da177e4 LT	204
	205	return count;
	206	}
	207
	208	/* Note: we save and restore the fan minimum here, because its value is
	209	determined in part by the fan clock divider. This follows the principle
d6e05edc	210	of least surprise; the user doesn't expect the fan minimum to change just
1da177e4 LT	211	because the divider changed. */
	212	static ssize_t set_fan_div(struct device dev, const char buf,
	213	size_t count, int nr)
	214	{
	215	struct i2c_client *client = to_i2c_client(dev);
	216	struct smsc47m1_data *data = i2c_get_clientdata(client);
	217
	218	long new_div = simple_strtol(buf, NULL, 10), tmp;
	219	u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
	220
	221	if (new_div == old_div) /* No change */
	222	return count;
	223
9a61bf63	224	mutex_lock(&data->update_lock);
1da177e4 LT	225	switch (new_div) {
	226	case 1: data->fan_div[nr] = 0; break;
	227	case 2: data->fan_div[nr] = 1; break;
	228	case 4: data->fan_div[nr] = 2; break;
	229	case 8: data->fan_div[nr] = 3; break;
	230	default:
9a61bf63	231	mutex_unlock(&data->update_lock);
1da177e4 LT	232	return -EINVAL;
	233	}
	234
	235	tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F;
	236	tmp \|= (data->fan_div[0] << 4) \| (data->fan_div[1] << 6);
	237	smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp);
	238
	239	/* Preserve fan min */
	240	tmp = 192 - (old_div * (192 - data->fan_preload[nr])
	241	+ new_div / 2) / new_div;
	242	data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
	243	smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
	244	data->fan_preload[nr]);
9a61bf63	245	mutex_unlock(&data->update_lock);
1da177e4 LT	246
	247	return count;
	248	}
	249
	250	static ssize_t set_pwm(struct device dev, const char buf,
	251	size_t count, int nr)
	252	{
	253	struct i2c_client *client = to_i2c_client(dev);
	254	struct smsc47m1_data *data = i2c_get_clientdata(client);
	255
	256	long val = simple_strtol(buf, NULL, 10);
	257
	258	if (val < 0 \|\| val > 255)
	259	return -EINVAL;
	260
9a61bf63	261	mutex_lock(&data->update_lock);
1da177e4 LT	262	data->pwm[nr] &= 0x81; /* Preserve additional bits */
	263	data->pwm[nr] \|= PWM_TO_REG(val);
	264	smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
	265	data->pwm[nr]);
9a61bf63	266	mutex_unlock(&data->update_lock);
1da177e4 LT	267
	268	return count;
	269	}
	270
	271	static ssize_t set_pwm_en(struct device dev, const char buf,
	272	size_t count, int nr)
	273	{
	274	struct i2c_client *client = to_i2c_client(dev);
	275	struct smsc47m1_data *data = i2c_get_clientdata(client);
	276
	277	long val = simple_strtol(buf, NULL, 10);
	278
	279	if (val != 0 && val != 1)
	280	return -EINVAL;
	281
9a61bf63	282	mutex_lock(&data->update_lock);
1da177e4 LT	283	data->pwm[nr] &= 0xFE; /* preserve the other bits */
	284	data->pwm[nr] \|= !val;
	285	smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
	286	data->pwm[nr]);
9a61bf63	287	mutex_unlock(&data->update_lock);
1da177e4 LT	288
	289	return count;
	290	}
	291
	292	#define fan_present(offset) \
a5099cfc	293	static ssize_t get_fan##offset (struct device dev, struct device_attribute attr, char *buf) \
1da177e4 LT	294	{ \
	295	return get_fan(dev, buf, offset - 1); \
	296	} \
a5099cfc	297	static ssize_t get_fan##offset##_min (struct device dev, struct device_attribute attr, char *buf) \
1da177e4 LT	298	{ \
	299	return get_fan_min(dev, buf, offset - 1); \
	300	} \
a5099cfc	301	static ssize_t set_fan##offset##_min (struct device dev, struct device_attribute attr, \
1da177e4 LT	302	const char *buf, size_t count) \
	303	{ \
	304	return set_fan_min(dev, buf, count, offset - 1); \
	305	} \
a5099cfc	306	static ssize_t get_fan##offset##_div (struct device dev, struct device_attribute attr, char *buf) \
1da177e4 LT	307	{ \
	308	return get_fan_div(dev, buf, offset - 1); \
	309	} \
a5099cfc	310	static ssize_t set_fan##offset##_div (struct device dev, struct device_attribute attr, \
1da177e4 LT	311	const char *buf, size_t count) \
	312	{ \
	313	return set_fan_div(dev, buf, count, offset - 1); \
	314	} \
a5099cfc	315	static ssize_t get_pwm##offset (struct device dev, struct device_attribute attr, char *buf) \
1da177e4 LT	316	{ \
	317	return get_pwm(dev, buf, offset - 1); \
	318	} \
a5099cfc	319	static ssize_t set_pwm##offset (struct device dev, struct device_attribute attr, \
1da177e4 LT	320	const char *buf, size_t count) \
	321	{ \
	322	return set_pwm(dev, buf, count, offset - 1); \
	323	} \
a5099cfc	324	static ssize_t get_pwm##offset##_en (struct device dev, struct device_attribute attr, char *buf) \
1da177e4 LT	325	{ \
	326	return get_pwm_en(dev, buf, offset - 1); \
	327	} \
a5099cfc	328	static ssize_t set_pwm##offset##_en (struct device dev, struct device_attribute attr, \
1da177e4 LT	329	const char *buf, size_t count) \
	330	{ \
	331	return set_pwm_en(dev, buf, count, offset - 1); \
	332	} \
	333	static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset, \
	334	NULL); \
	335	static DEVICE_ATTR(fan##offset##_min, S_IRUGO \| S_IWUSR, \
	336	get_fan##offset##_min, set_fan##offset##_min); \
	337	static DEVICE_ATTR(fan##offset##_div, S_IRUGO \| S_IWUSR, \
	338	get_fan##offset##_div, set_fan##offset##_div); \
	339	static DEVICE_ATTR(pwm##offset, S_IRUGO \| S_IWUSR, \
	340	get_pwm##offset, set_pwm##offset); \
	341	static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO \| S_IWUSR, \
	342	get_pwm##offset##_en, set_pwm##offset##_en);
	343
	344	fan_present(1);
	345	fan_present(2);
	346
	347	static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
	348
e6cfb3ad	349	static int __init smsc47m1_find(unsigned short *addr)
1da177e4 LT	350	{
	351	u8 val;
	352
	353	superio_enter();
	354	val = superio_inb(SUPERIO_REG_DEVID);
	355
	356	/*
	357	* SMSC LPC47M10x/LPC47M13x (device id 0x59), LPC47M14x (device id
	358	* 0x5F) and LPC47B27x (device id 0x51) have fan control.
	359	* The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
ec5ce552	360	* can do much more besides (device id 0x60).
b890a07f JD	361	* The LPC47M997 is undocumented, but seems to be compatible with
b890a07f JD	362	* the LPC47M192, and has the same device id.
1da177e4 LT	363	*/
1da177e4 LT	364	if (val == 0x51)
ec5ce552	365	printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n");
1da177e4	366	else if (val == 0x59)
ec5ce552	367	printk(KERN_INFO "smsc47m1: Found SMSC LPC47M10x/LPC47M13x\n");
1da177e4	368	else if (val == 0x5F)
ec5ce552 JD	369	printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n");
ec5ce552 JD	370	else if (val == 0x60)
b890a07f JD	371	printk(KERN_INFO "smsc47m1: Found SMSC "
b890a07f JD	372	"LPC47M15x/LPC47M192/LPC47M997\n");
1da177e4 LT	373	else {
	374	superio_exit();
	375	return -ENODEV;
	376	}
	377
	378	superio_select();
2d8672c5 JD	379	*addr = (superio_inb(SUPERIO_REG_BASE) << 8)
2d8672c5 JD	380	\| superio_inb(SUPERIO_REG_BASE + 1);
1da177e4	381	val = superio_inb(SUPERIO_REG_ACT);
2d8672c5	382	if (*addr == 0 \|\| (val & 0x01) == 0) {
1da177e4 LT	383	printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n");
	384	superio_exit();
	385	return -ENODEV;
	386	}
	387
	388	superio_exit();
	389	return 0;
	390	}
	391
2d8672c5	392	static int smsc47m1_detect(struct i2c_adapter *adapter)
1da177e4 LT	393	{
	394	struct i2c_client *new_client;
	395	struct smsc47m1_data *data;
	396	int err = 0;
	397	int fan1, fan2, pwm1, pwm2;
	398
cdaf7934	399	if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.driver.name)) {
1da177e4 LT	400	dev_err(&adapter->dev, "Region 0x%x already in use!\n", address);
	401	return -EBUSY;
	402	}
	403
ba9c2e8d	404	if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
1da177e4 LT	405	err = -ENOMEM;
	406	goto error_release;
	407	}
1da177e4 LT	408
	409	new_client = &data->client;
	410	i2c_set_clientdata(new_client, data);
	411	new_client->addr = address;
9a61bf63	412	mutex_init(&data->lock);
1da177e4 LT	413	new_client->adapter = adapter;
	414	new_client->driver = &smsc47m1_driver;
	415	new_client->flags = 0;
	416
	417	strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
9a61bf63	418	mutex_init(&data->update_lock);
1da177e4 LT	419
	420	/* If no function is properly configured, there's no point in
	421	actually registering the chip. */
	422	fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05)
	423	== 0x05;
	424	fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05)
	425	== 0x05;
	426	pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05)
	427	== 0x04;
	428	pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05)
	429	== 0x04;
	430	if (!(fan1 \|\| fan2 \|\| pwm1 \|\| pwm2)) {
	431	dev_warn(&new_client->dev, "Device is not configured, will not use\n");
	432	err = -ENODEV;
	433	goto error_free;
	434	}
	435
	436	if ((err = i2c_attach_client(new_client)))
	437	goto error_free;
	438
	439	/* Some values (fan min, clock dividers, pwm registers) may be
	440	needed before any update is triggered, so we better read them
	441	at least once here. We don't usually do it that way, but in
	442	this particular case, manually reading 5 registers out of 8
	443	doesn't make much sense and we're better using the existing
	444	function. */
	445	smsc47m1_update_device(&new_client->dev, 1);
	446
943b0830 MH	447	/* Register sysfs hooks */
	448	data->class_dev = hwmon_device_register(&new_client->dev);
	449	if (IS_ERR(data->class_dev)) {
	450	err = PTR_ERR(data->class_dev);
	451	goto error_detach;
	452	}
	453
1da177e4 LT	454	if (fan1) {
	455	device_create_file(&new_client->dev, &dev_attr_fan1_input);
	456	device_create_file(&new_client->dev, &dev_attr_fan1_min);
	457	device_create_file(&new_client->dev, &dev_attr_fan1_div);
	458	} else
	459	dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, "
	460	"skipping\n");
	461
	462	if (fan2) {
	463	device_create_file(&new_client->dev, &dev_attr_fan2_input);
	464	device_create_file(&new_client->dev, &dev_attr_fan2_min);
	465	device_create_file(&new_client->dev, &dev_attr_fan2_div);
	466	} else
	467	dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, "
	468	"skipping\n");
	469
	470	if (pwm1) {
	471	device_create_file(&new_client->dev, &dev_attr_pwm1);
	472	device_create_file(&new_client->dev, &dev_attr_pwm1_enable);
	473	} else
	474	dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, "
	475	"skipping\n");
	476	if (pwm2) {
	477	device_create_file(&new_client->dev, &dev_attr_pwm2);
	478	device_create_file(&new_client->dev, &dev_attr_pwm2_enable);
	479	} else
	480	dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, "
	481	"skipping\n");
	482
	483	device_create_file(&new_client->dev, &dev_attr_alarms);
	484
	485	return 0;
	486
943b0830 MH	487	error_detach:
943b0830 MH	488	i2c_detach_client(new_client);
1da177e4	489	error_free:
1f57ff89	490	kfree(data);
1da177e4 LT	491	error_release:
	492	release_region(address, SMSC_EXTENT);
	493	return err;
	494	}
	495
	496	static int smsc47m1_detach_client(struct i2c_client *client)
	497	{
943b0830	498	struct smsc47m1_data *data = i2c_get_clientdata(client);
1da177e4 LT	499	int err;
1da177e4 LT	500
943b0830 MH	501	hwmon_device_unregister(data->class_dev);
943b0830 MH	502
7bef5594	503	if ((err = i2c_detach_client(client)))
1da177e4	504	return err;
1da177e4 LT	505
1da177e4 LT	506	release_region(client->addr, SMSC_EXTENT);
943b0830	507	kfree(data);
1da177e4 LT	508
	509	return 0;
	510	}
	511
	512	static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
	513	{
	514	int res;
	515
9a61bf63	516	mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4	517	res = inb_p(client->addr + reg);
9a61bf63	518	mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4 LT	519	return res;
	520	}
	521
	522	static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
	523	{
9a61bf63	524	mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4	525	outb_p(value, client->addr + reg);
9a61bf63	526	mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4 LT	527	}
	528
	529	static struct smsc47m1_data smsc47m1_update_device(struct device dev,
	530	int init)
	531	{
	532	struct i2c_client *client = to_i2c_client(dev);
	533	struct smsc47m1_data *data = i2c_get_clientdata(client);
	534
9a61bf63	535	mutex_lock(&data->update_lock);
1da177e4 LT	536
	537	if (time_after(jiffies, data->last_updated + HZ + HZ / 2) \|\| init) {
	538	int i;
	539
	540	for (i = 0; i < 2; i++) {
	541	data->fan[i] = smsc47m1_read_value(client,
	542	SMSC47M1_REG_FAN(i));
	543	data->fan_preload[i] = smsc47m1_read_value(client,
	544	SMSC47M1_REG_FAN_PRELOAD(i));
	545	data->pwm[i] = smsc47m1_read_value(client,
	546	SMSC47M1_REG_PWM(i));
	547	}
	548
	549	i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
	550	data->fan_div[0] = (i >> 4) & 0x03;
	551	data->fan_div[1] = i >> 6;
	552
	553	data->alarms = smsc47m1_read_value(client,
	554	SMSC47M1_REG_ALARM) >> 6;
	555	/* Clear alarms if needed */
	556	if (data->alarms)
	557	smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0);
	558
	559	data->last_updated = jiffies;
	560	}
	561
9a61bf63	562	mutex_unlock(&data->update_lock);
1da177e4 LT	563	return data;
	564	}
	565
	566	static int __init sm_smsc47m1_init(void)
	567	{
2d8672c5	568	if (smsc47m1_find(&address)) {
1da177e4 LT	569	return -ENODEV;
	570	}
	571
fde09509	572	return i2c_isa_add_driver(&smsc47m1_driver);
1da177e4 LT	573	}
	574
	575	static void __exit sm_smsc47m1_exit(void)
	576	{
fde09509	577	i2c_isa_del_driver(&smsc47m1_driver);
1da177e4 LT	578	}
	579
	580	MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
	581	MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
	582	MODULE_LICENSE("GPL");
	583
	584	module_init(sm_smsc47m1_init);
	585	module_exit(sm_smsc47m1_exit);