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