Added I2C support for the Loft

3 files changed, 394 insertions, 1 deletions

diff --git a/packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch b/packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch
new file mode 100644
index 0000000000..9d0a35b3fa
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch
@@ -0,0 +1,378 @@
+---
+ drivers/hwmon/Kconfig  |   10 +
+ drivers/hwmon/Makefile |    1 
+ drivers/hwmon/ad741x.c |  340 +++++++++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 351 insertions(+)
+
+--- linux-ixp4xx.orig/drivers/hwmon/Makefile	2006-02-19 17:45:45.000000000 +0100
++++ linux-ixp4xx/drivers/hwmon/Makefile	2006-02-19 17:46:12.000000000 +0100
+@@ -44,6 +44,7 @@ obj-$(CONFIG_SENSORS_VIA686A)	+= via686a
+ obj-$(CONFIG_SENSORS_VT8231)	+= vt8231.o
+ obj-$(CONFIG_SENSORS_W83627EHF)	+= w83627ehf.o
+ obj-$(CONFIG_SENSORS_W83L785TS)	+= w83l785ts.o
++obj-$(CONFIG_SENSORS_AD741X)	+= ad741x.o
+ 
+ ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
+ EXTRA_CFLAGS += -DDEBUG
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-ixp4xx/drivers/hwmon/ad741x.c	2006-02-19 17:45:59.000000000 +0100
+@@ -0,0 +1,340 @@
++/*
++ * An hwmon driver for the Analog Devices AD7417/18
++ * Copyright 2006 Tower Technologies
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * Based on lm75.c
++ * Copyright 1998-99 Frodo Looijaard <frodol@dds.nl>
++ *
++ * 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.
++ */
++
++#include <linux/module.h>
++#include <linux/jiffies.h>
++#include <linux/i2c.h>
++#include <linux/hwmon.h>
++#include <linux/err.h>
++#include <linux/mutex.h>
++
++#define DRV_VERSION "0.1"
++
++/* straight from the datasheet */
++#define AD741X_TEMP_MIN (-55000)
++#define AD741X_TEMP_MAX 125000
++
++/* Addresses to scan */
++static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2A, 0x2B, 0x2C,
++					0x2D, 0x2E, 0x2F, I2C_CLIENT_END };
++
++/* Insmod parameters */
++I2C_CLIENT_INSMOD;
++
++/* AD741X registers */
++#define AD741X_REG_TEMP		0x00
++#define AD741X_REG_CONF		0x01
++#define AD741X_REG_TEMP_HYST	0x02
++#define AD741X_REG_TEMP_OS	0x03
++#define AD741X_REG_ADC		0x04
++#define AD741X_REG_CONF2	0x05
++
++#define AD741X_REG_ADC_CH(x)	(x << 5)
++
++#define AD741X_CH_TEMP		AD741X_REG_ADC_CH(0)
++#define AD741X_CH_AIN1		AD741X_REG_ADC_CH(1)
++#define AD741X_CH_AIN2		AD741X_REG_ADC_CH(2)
++#define AD741X_CH_AIN3		AD741X_REG_ADC_CH(3)
++#define AD741X_CH_AIN4		AD741X_REG_ADC_CH(4)
++
++struct ad741x_data {
++	struct i2c_client	client;
++	struct class_device	*class_dev;
++	struct mutex		lock;
++	char			valid;		/* !=0 if following fields are valid */
++	unsigned long		last_updated;	/* In jiffies */
++	u16			temp_input;	/* Register values */
++	u16			temp_max;
++	u16			temp_hyst;
++	u16			in1;
++	u16			in2;
++	u16			in3;
++	u16			in4;
++};
++
++static int ad741x_attach_adapter(struct i2c_adapter *adapter);
++static int ad741x_detect(struct i2c_adapter *adapter, int address, int kind);
++static int ad741x_detach_client(struct i2c_client *client);
++
++static struct i2c_driver ad741x_driver = {
++	.driver = {
++		.name	= "ad741x",
++	},
++	.attach_adapter	= ad741x_attach_adapter,
++	.detach_client	= ad741x_detach_client,
++};
++
++/* TEMP: 0.001C/bit (-55C to +125C)
++ * REG: (0.5C/bit, two's complement) << 7
++ */
++static inline u16 AD741X_TEMP_TO_REG(int temp)
++{
++	int ntemp = SENSORS_LIMIT(temp, AD741X_TEMP_MIN, AD741X_TEMP_MAX);
++	ntemp += (ntemp < 0 ? -250 : 250);
++	return (u16)((ntemp / 500) << 7);
++}
++
++static inline int AD741X_TEMP_FROM_REG(u16 reg)
++{
++	/* use integer division instead of equivalent right shift to
++	 * guarantee arithmetic shift and preserve the sign
++	 */
++	return ((s16)reg / 128) * 500;
++}
++
++/* All registers are word-sized, except for the configuration registers.
++ * AD741X uses a high-byte first convention, which is exactly opposite to
++ * the usual practice.
++ */
++static int ad741x_read(struct i2c_client *client, u8 reg)
++{
++	if (reg == AD741X_REG_CONF || reg == AD741X_REG_CONF2)
++		return i2c_smbus_read_byte_data(client, reg);
++	else
++		return swab16(i2c_smbus_read_word_data(client, reg));
++}
++
++static int ad741x_write(struct i2c_client *client, u8 reg, u16 value)
++{
++	if (reg == AD741X_REG_CONF || reg == AD741X_REG_CONF2)
++		return i2c_smbus_write_byte_data(client, reg, value);
++	else
++		return i2c_smbus_write_word_data(client, reg, swab16(value));
++}
++
++static void ad741x_init_client(struct i2c_client *client)
++{
++	/* Enable if in shutdown mode */
++	int reg = ad741x_read(client, AD741X_REG_CONF);
++	if (reg >= 0 && (reg & 0x01))
++		ad741x_write(client, AD741X_REG_CONF, reg & 0xfe);
++}
++
++static struct ad741x_data *ad741x_update_device(struct device *dev)
++{
++	struct i2c_client *client = to_i2c_client(dev);
++	struct ad741x_data *data = i2c_get_clientdata(client);
++
++	mutex_lock(&data->lock);
++
++	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
++		|| !data->valid) {
++		u8 cfg;
++		dev_dbg(&client->dev, "starting ad741x update\n");
++
++		data->temp_input = ad741x_read(client, AD741X_REG_TEMP);
++		data->temp_max = ad741x_read(client, AD741X_REG_TEMP_OS);
++		data->temp_hyst = ad741x_read(client, AD741X_REG_TEMP_HYST);
++
++		/* read config register and clear channel bits */
++		cfg = ad741x_read(client, AD741X_REG_CONF);
++		cfg &= 0x1F;
++
++		ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN1);
++		data->in1 = ad741x_read(client, AD741X_REG_ADC);
++
++		ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN2);
++		data->in2 = ad741x_read(client, AD741X_REG_ADC);
++
++		ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN3);
++		data->in3 = ad741x_read(client, AD741X_REG_ADC);
++
++		ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN4);
++		data->in4 = ad741x_read(client, AD741X_REG_ADC);
++
++		/* restore old configuration value */
++		ad741x_write(client, AD741X_REG_CONF, cfg);
++
++		data->last_updated = jiffies;
++		data->valid = 1;
++	}
++
++	mutex_unlock(&data->lock);
++
++	return data;
++}
++
++#define show(value) \
++static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf)		\
++{									\
++	struct ad741x_data *data = ad741x_update_device(dev);		\
++	return sprintf(buf, "%d\n", AD741X_TEMP_FROM_REG(data->value));	\
++}
++show(temp_max);
++show(temp_hyst);
++show(temp_input);
++
++#define show_adc(value)	\
++static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf)		\
++{								\
++	struct ad741x_data *data = ad741x_update_device(dev);	\
++	return sprintf(buf, "%d\n", data->value >> 6);		\
++}
++
++show_adc(in1);
++show_adc(in2);
++show_adc(in3);
++show_adc(in4);
++
++#define set(value, reg)	\
++static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)	\
++{								\
++	struct i2c_client *client = to_i2c_client(dev);		\
++	struct ad741x_data *data = i2c_get_clientdata(client);	\
++	int temp = simple_strtoul(buf, NULL, 10);		\
++								\
++	mutex_lock(&data->lock);				\
++	data->value = AD741X_TEMP_TO_REG(temp);			\
++	ad741x_write(client, reg, data->value);		\
++	mutex_unlock(&data->lock);					\
++	return count;						\
++}
++set(temp_max, AD741X_REG_TEMP_OS);
++set(temp_hyst, AD741X_REG_TEMP_HYST);
++
++static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, set_temp_max);
++static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hyst, set_temp_hyst);
++static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL);
++
++static DEVICE_ATTR(in1, S_IRUGO, show_in1, NULL);
++static DEVICE_ATTR(in2, S_IRUGO, show_in2, NULL);
++static DEVICE_ATTR(in3, S_IRUGO, show_in3, NULL);
++static DEVICE_ATTR(in4, S_IRUGO, show_in4, NULL);
++
++static int ad741x_attach_adapter(struct i2c_adapter *adapter)
++{
++	if (!(adapter->class & I2C_CLASS_HWMON))
++		return 0;
++	return i2c_probe(adapter, &addr_data, ad741x_detect);
++}
++
++static int ad741x_detect(struct i2c_adapter *adapter, int address, int kind)
++{
++	struct i2c_client *client;
++	struct ad741x_data *data;
++	int err = 0;
++
++	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
++					I2C_FUNC_SMBUS_WORD_DATA))
++		goto exit;
++
++	if (!(data = kzalloc(sizeof(struct ad741x_data), GFP_KERNEL))) {
++		err = -ENOMEM;
++		goto exit;
++	}
++
++	client = &data->client;
++	client->addr = address;
++	client->adapter = adapter;
++	client->driver = &ad741x_driver;
++	client->flags = 0;
++
++	i2c_set_clientdata(client, data);
++
++	mutex_init(&data->lock);
++
++	/* AD7418 has a curious behaviour on registers 6 and 7. They
++	 * both always read 0xC071 and are not documented on the datasheet.
++	 * We use them to detect the chip.
++	 */
++	if (kind < 0) {
++		int reg;
++
++		reg = i2c_smbus_read_word_data(client, 0x06);
++		if (reg != 0xC071) {
++			dev_dbg(&adapter->dev, "failed detection at %d: %x\n", 6, reg);
++			err = -ENODEV;
++			goto exit_free;
++		}
++
++		reg = i2c_smbus_read_word_data(client, 0x07);
++		if (reg != 0xC071) {
++			dev_dbg(&adapter->dev, "failed detection at %d: %x\n", 7, reg);
++			err = -ENODEV;
++			goto exit_free;
++		}
++
++		reg = i2c_smbus_read_byte_data(client, AD741X_REG_CONF2);
++
++		/* bits 0-5 must be at 0 */
++		if (reg & 0x3F) {
++			dev_dbg(&adapter->dev, "failed detection at %d: %x\n",
++				AD741X_REG_CONF2, reg);
++			err = -ENODEV;
++		 	goto exit_free;
++		}
++	}
++
++	strlcpy(client->name, ad741x_driver.driver.name, I2C_NAME_SIZE);
++
++	if ((err = i2c_attach_client(client)))
++		goto exit_free;
++
++	dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
++
++	/* Initialize the AD741X chip */
++	ad741x_init_client(client);
++
++	/* Register sysfs hooks */
++	data->class_dev = hwmon_device_register(&client->dev);
++	if (IS_ERR(data->class_dev)) {
++		err = PTR_ERR(data->class_dev);
++		goto exit_detach;
++	}
++
++	device_create_file(&client->dev, &dev_attr_temp1_max);
++	device_create_file(&client->dev, &dev_attr_temp1_max_hyst);
++	device_create_file(&client->dev, &dev_attr_temp1_input);
++	device_create_file(&client->dev, &dev_attr_in1);
++	device_create_file(&client->dev, &dev_attr_in2);
++	device_create_file(&client->dev, &dev_attr_in3);
++	device_create_file(&client->dev, &dev_attr_in4);
++
++	return 0;
++
++exit_detach:
++	i2c_detach_client(client);
++exit_free:
++	kfree(data);
++exit:
++	return err;
++}
++
++static int ad741x_detach_client(struct i2c_client *client)
++{
++	struct ad741x_data *data = i2c_get_clientdata(client);
++	hwmon_device_unregister(data->class_dev);
++	i2c_detach_client(client);
++	kfree(data);
++	return 0;
++}
++
++static int __init ad741x_init(void)
++{
++	return i2c_add_driver(&ad741x_driver);
++}
++
++static void __exit ad741x_exit(void)
++{
++	i2c_del_driver(&ad741x_driver);
++}
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("AD741X driver");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(ad741x_init);
++module_exit(ad741x_exit);
+--- linux-ixp4xx.orig/drivers/hwmon/Kconfig	2006-02-19 17:45:45.000000000 +0100
++++ linux-ixp4xx/drivers/hwmon/Kconfig	2006-02-19 17:47:07.000000000 +0100
+@@ -433,6 +433,16 @@ config SENSORS_W83627EHF
+ 	  This driver can also be built as a module.  If so, the module
+ 	  will be called w83627ehf.
+ 
++config SENSORS_AD741X
++	tristate "Analog Devices AD7417/18"
++	depends on HWMON && I2C && EXPERIMENTAL
++	help
++	  If you say yes here you get support for the Analog Devices AD7417
++	  and AD7418 chips.
++
++	  This driver can also be built as a module.  If so, the module
++	  will be called ad741x.
++
+ config SENSORS_HDAPS
+ 	tristate "IBM Hard Drive Active Protection System (hdaps)"
+ 	depends on HWMON && INPUT && X86
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch b/packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch
new file mode 100644
index 0000000000..d7fb8e55dc
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch
@@ -0,0 +1,14 @@
+---
+ drivers/i2c/busses/i2c-ixp4xx.c |    1 +
+ 1 file changed, 1 insertion(+)
+
+--- linux-ixp4xx.orig/drivers/i2c/busses/i2c-ixp4xx.c	2006-02-11 15:18:29.000000000 +0100
++++ linux-ixp4xx/drivers/i2c/busses/i2c-ixp4xx.c	2006-02-18 16:20:12.000000000 +0100
+@@ -126,6 +126,7 @@ static int ixp4xx_i2c_probe(struct platf
+ 	drv_data->algo_data.timeout = 100;
+ 
+ 	drv_data->adapter.id = I2C_HW_B_IXP4XX;
++	drv_data->adapter.class = I2C_CLASS_HWMON;
+ 	strlcpy(drv_data->adapter.name, plat_dev->dev.driver->name,
+ 		I2C_NAME_SIZE);
+ 	drv_data->adapter.algo_data = &drv_data->algo_data;
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/defconfig b/packages/linux/ixp4xx-kernel/2.6.16/defconfig
index 0862199528..472a692a32 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/defconfig
+++ b/packages/linux/ixp4xx-kernel/2.6.16/defconfig
@@ -1469,6 +1469,7 @@ CONFIG_RTC_INTF_DEV=y
 CONFIG_RTC_DRV_X1205=y
 CONFIG_RTC_DRV_DS1672=y
 CONFIG_RTC_DRV_PCF8563=y
+CONFIG_RTC_DRV_RS5C372=y
 # CONFIG_RTC_DRV_TEST is not set
 
 #
@@ -1596,7 +1597,7 @@ CONFIG_CIFS_XATTR=y
 CONFIG_CIFS_POSIX=y
 # CONFIG_CIFS_EXPERIMENTAL is not set
 # CONFIG_NCP_FS is not set
-CONFIG_CODA_FS=m
+# CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
 # CONFIG_9P_FS is not set