[linux-block.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 <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 semaphore lock;

	struct semaphore 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);

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

	if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
		up(&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]);
	up(&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 suprise; 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;

	down(&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:
		up(&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]);
	up(&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;

	down(&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]);
	up(&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;

	down(&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]);
	up(&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;
	init_MUTEX(&data->lock);
	new_client->adapter = adapter;
	new_client->driver = &smsc47m1_driver;
	new_client->flags = 0;

	strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
	init_MUTEX(&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;

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

static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
{
	down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
	outb_p(value, client->addr + reg);
	up(&((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);

	down(&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;
	}

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