[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hwmon / smsc47m1.c

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

    Supports the SMSC LPC47B27x, LPC47M10x, LPC47M13x and LPC47M14x
    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-sensor.h>
#include <linux/hwmon.h>
#include <linux/err.h>
#include <linux/init.h>
#include <asm/io.h>

static unsigned short normal_i2c[] = { I2C_CLIENT_END };
/* Address is autodetected, there is no default value */
static unsigned int normal_isa[] = { 0x0000, I2C_CLIENT_ISA_END };
static struct i2c_force_data forces[] = {{NULL}};

enum chips { any_chip, smsc47m1 };
static struct i2c_address_data addr_data = {
	.normal_i2c		= normal_i2c,
	.normal_isa		= normal_isa,
	.forces			= forces,
};

/* 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_attach_adapter(struct i2c_adapter *adapter);
static int smsc47m1_find(int *address);
static int smsc47m1_detect(struct i2c_adapter *adapter, int address, int kind);
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",
	.id		= I2C_DRIVERID_SMSC47M1,
	.flags		= I2C_DF_NOTIFY,
	.attach_adapter	= smsc47m1_attach_adapter,
	.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 smsc47m1_attach_adapter(struct i2c_adapter *adapter)
{
	if (!(adapter->class & I2C_CLASS_HWMON))
		return 0;
	return i2c_detect(adapter, &addr_data, smsc47m1_detect);
}

static int smsc47m1_find(int *address)
{
	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).
	 */
	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\n");
	else {
		superio_exit();
		return -ENODEV;
	}

	superio_select();
	*address = (superio_inb(SUPERIO_REG_BASE) << 8)
		 |  superio_inb(SUPERIO_REG_BASE + 1);
	val = superio_inb(SUPERIO_REG_ACT);
	if (*address == 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, int address, int kind)
{
	struct i2c_client *new_client;
	struct smsc47m1_data *data;
	int err = 0;
	int fan1, fan2, pwm1, pwm2;

	if (!i2c_is_isa_adapter(adapter)) {
		return 0;
	}

	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 = kmalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
		err = -ENOMEM;
		goto error_release;
	}
	memset(data, 0x00, sizeof(struct smsc47m1_data));

	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))) {
		dev_err(&client->dev, "Client deregistration failed, "
			"client not detached.\n");
		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(normal_isa)) {
		return -ENODEV;
	}

	return i2c_add_driver(&smsc47m1_driver);
}

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