hwmon: tegra: tsensor: lp0 save/restore configuration
[linux-2.6.git] / drivers / hwmon / sis5595.c
index 8610bce..47d7ce9 100644 (file)
@@ -3,7 +3,7 @@
                for hardware monitoring
 
     Copyright (C) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
-                       Kyösti Mälkki <kmalkki@cc.hut.fi>, and
+                       Kyösti Mälkki <kmalkki@cc.hut.fi>, and
                        Mark D. Studebaker <mdsxyz123@yahoo.com>
     Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
     the help of Jean Delvare <khali@linux-fr.org>
         735            0008            0735
 */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
-#include <asm/io.h>
+#include <linux/mutex.h>
+#include <linux/sysfs.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
 
 
 /* If force_addr is set to anything different from 0, we forcibly enable
@@ -70,17 +75,13 @@ module_param(force_addr, ushort, 0);
 MODULE_PARM_DESC(force_addr,
                 "Initialize the base address of the sensors");
 
-/* Device address
-   Note that we can't determine the ISA address until we have initialized
-   our module */
-static unsigned short address;
+static struct platform_device *pdev;
 
 /* Many SIS5595 constants specified below */
 
 /* Length of ISA address segment */
 #define SIS5595_EXTENT 8
 /* PCI Config Registers */
-#define SIS5595_REVISION_REG 0x08
 #define SIS5595_BASE_REG 0x68
 #define SIS5595_PIN_REG 0x7A
 #define SIS5595_ENABLE_REG 0x7B
@@ -160,16 +161,15 @@ static inline u8 DIV_TO_REG(int val)
 }
 #define DIV_FROM_REG(val) (1 << (val))
 
-/* For the SIS5595, we need to keep some data in memory. That
-   data is pointed to by sis5595_list[NR]->data. The structure itself is
-   dynamically allocated, at the time when the new sis5595 client is
-   allocated. */
+/* For each registered chip, we need to keep some data in memory.
+   The structure is dynamically allocated. */
 struct sis5595_data {
-       struct i2c_client client;
-       struct class_device *class_dev;
-       struct semaphore lock;
+       unsigned short addr;
+       const char *name;
+       struct device *hwmon_dev;
+       struct mutex lock;
 
-       struct semaphore update_lock;
+       struct mutex update_lock;
        char valid;             /* !=0 if following fields are valid */
        unsigned long last_updated;     /* In jiffies */
        char maxins;            /* == 3 if temp enabled, otherwise == 4 */
@@ -189,100 +189,88 @@ struct sis5595_data {
 
 static struct pci_dev *s_bridge;       /* pointer to the (only) sis5595 */
 
-static int sis5595_detect(struct i2c_adapter *adapter);
-static int sis5595_detach_client(struct i2c_client *client);
+static int sis5595_probe(struct platform_device *pdev);
+static int __devexit sis5595_remove(struct platform_device *pdev);
 
-static int sis5595_read_value(struct i2c_client *client, u8 register);
-static int sis5595_write_value(struct i2c_client *client, u8 register, u8 value);
+static int sis5595_read_value(struct sis5595_data *data, u8 reg);
+static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value);
 static struct sis5595_data *sis5595_update_device(struct device *dev);
-static void sis5595_init_client(struct i2c_client *client);
-
-static struct i2c_driver sis5595_driver = {
-       .owner          = THIS_MODULE,
-       .name           = "sis5595",
-       .attach_adapter = sis5595_detect,
-       .detach_client  = sis5595_detach_client,
+static void sis5595_init_device(struct sis5595_data *data);
+
+static struct platform_driver sis5595_driver = {
+       .driver = {
+               .owner  = THIS_MODULE,
+               .name   = "sis5595",
+       },
+       .probe          = sis5595_probe,
+       .remove         = __devexit_p(sis5595_remove),
 };
 
 /* 4 Voltages */
-static ssize_t show_in(struct device *dev, char *buf, int nr)
+static ssize_t show_in(struct device *dev, struct device_attribute *da,
+                      char *buf)
 {
        struct sis5595_data *data = sis5595_update_device(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
 }
 
-static ssize_t show_in_min(struct device *dev, char *buf, int nr)
+static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
+                          char *buf)
 {
        struct sis5595_data *data = sis5595_update_device(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
 }
 
-static ssize_t show_in_max(struct device *dev, char *buf, int nr)
+static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
+                          char *buf)
 {
        struct sis5595_data *data = sis5595_update_device(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
 }
 
-static ssize_t set_in_min(struct device *dev, const char *buf,
-              size_t count, int nr)
+static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
+                         const char *buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        unsigned long val = simple_strtoul(buf, NULL, 10);
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
        data->in_min[nr] = IN_TO_REG(val);
-       sis5595_write_value(client, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
-       up(&data->update_lock);
+       sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
+       mutex_unlock(&data->update_lock);
        return count;
 }
 
-static ssize_t set_in_max(struct device *dev, const char *buf,
-              size_t count, int nr)
+static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
+                         const char *buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        unsigned long val = simple_strtoul(buf, NULL, 10);
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
        data->in_max[nr] = IN_TO_REG(val);
-       sis5595_write_value(client, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
-       up(&data->update_lock);
+       sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
+       mutex_unlock(&data->update_lock);
        return count;
 }
 
 #define show_in_offset(offset)                                 \
-static ssize_t                                                 \
-       show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
-{                                                              \
-       return show_in(dev, buf, offset);                       \
-}                                                              \
-static DEVICE_ATTR(in##offset##_input, S_IRUGO,                \
-               show_in##offset, NULL);                         \
-static ssize_t                                                 \
-       show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)    \
-{                                                              \
-       return show_in_min(dev, buf, offset);                   \
-}                                                              \
-static ssize_t                                                 \
-       show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)    \
-{                                                              \
-       return show_in_max(dev, buf, offset);                   \
-}                                                              \
-static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr,        \
-               const char *buf, size_t count)                  \
-{                                                              \
-       return set_in_min(dev, buf, count, offset);             \
-}                                                              \
-static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr,        \
-               const char *buf, size_t count)                  \
-{                                                              \
-       return set_in_max(dev, buf, count, offset);             \
-}                                                              \
-static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,                \
-               show_in##offset##_min, set_in##offset##_min);   \
-static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,                \
-               show_in##offset##_max, set_in##offset##_max);
+static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,         \
+               show_in, NULL, offset);                         \
+static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
+               show_in_min, set_in_min, offset);               \
+static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
+               show_in_max, set_in_max, offset);
 
 show_in_offset(0);
 show_in_offset(1);
@@ -305,14 +293,13 @@ static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr,
 
 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
        long val = simple_strtol(buf, NULL, 10);
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
        data->temp_over = TEMP_TO_REG(val);
-       sis5595_write_value(client, SIS5595_REG_TEMP_OVER, data->temp_over);
-       up(&data->update_lock);
+       sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
+       mutex_unlock(&data->update_lock);
        return count;
 }
 
@@ -324,14 +311,13 @@ static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr,
 
 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
        long val = simple_strtol(buf, NULL, 10);
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
        data->temp_hyst = TEMP_TO_REG(val);
-       sis5595_write_value(client, SIS5595_REG_TEMP_HYST, data->temp_hyst);
-       up(&data->update_lock);
+       sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
+       mutex_unlock(&data->update_lock);
        return count;
 }
 
@@ -342,57 +328,68 @@ static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
                show_temp_hyst, set_temp_hyst);
 
 /* 2 Fans */
-static ssize_t show_fan(struct device *dev, char *buf, int nr)
+static ssize_t show_fan(struct device *dev, struct device_attribute *da,
+                       char *buf)
 {
        struct sis5595_data *data = sis5595_update_device(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
                DIV_FROM_REG(data->fan_div[nr])) );
 }
 
-static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
+static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
+                           char *buf)
 {
        struct sis5595_data *data = sis5595_update_device(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
                DIV_FROM_REG(data->fan_div[nr])) );
 }
 
-static ssize_t set_fan_min(struct device *dev, const char *buf,
-               size_t count, int nr)
+static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
+                          const char *buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        unsigned long val = simple_strtoul(buf, NULL, 10);
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
        data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
-       sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
-       up(&data->update_lock);
+       sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
+       mutex_unlock(&data->update_lock);
        return count;
 }
 
-static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
+static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
+                           char *buf)
 {
        struct sis5595_data *data = sis5595_update_device(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
 }
 
 /* Note: we save and restore the fan minimum here, because its value is
    determined in part by the fan divisor.  This follows the principle of
-   least suprise; the user doesn't expect the fan minimum to change just
+   least surprise; the user doesn't expect the fan minimum to change just
    because the divisor changed. */
-static ssize_t set_fan_div(struct device *dev, const char *buf,
-       size_t count, int nr)
+static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
+                          const char *buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
+       struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+       int nr = attr->index;
        unsigned long min;
        unsigned long val = simple_strtoul(buf, NULL, 10);
        int reg;
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
        min = FAN_FROM_REG(data->fan_min[nr],
                        DIV_FROM_REG(data->fan_div[nr]));
-       reg = sis5595_read_value(client, SIS5595_REG_FANDIV);
+       reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
 
        switch (val) {
        case 1: data->fan_div[nr] = 0; break;
@@ -400,9 +397,9 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
        case 4: data->fan_div[nr] = 2; break;
        case 8: data->fan_div[nr] = 3; break;
        default:
-               dev_err(&client->dev, "fan_div value %ld not "
+               dev_err(dev, "fan_div value %ld not "
                        "supported. Choose one of 1, 2, 4 or 8!\n", val);
-               up(&data->update_lock);
+               mutex_unlock(&data->update_lock);
                return -EINVAL;
        }
        
@@ -414,55 +411,25 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
                reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
                break;
        }
-       sis5595_write_value(client, SIS5595_REG_FANDIV, reg);
+       sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
        data->fan_min[nr] =
                FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
-       sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
-       up(&data->update_lock);
+       sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
+       mutex_unlock(&data->update_lock);
        return count;
 }
 
 #define show_fan_offset(offset)                                                \
-static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf)        \
-{                                                                      \
-       return show_fan(dev, buf, offset - 1);                  \
-}                                                                      \
-static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)  \
-{                                                                      \
-       return show_fan_min(dev, buf, offset - 1);                      \
-}                                                                      \
-static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)  \
-{                                                                      \
-       return show_fan_div(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 DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
-static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,               \
-               show_fan_##offset##_min, set_fan_##offset##_min);
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                        \
+               show_fan, NULL, offset - 1);                            \
+static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
+               show_fan_min, set_fan_min, offset - 1);                 \
+static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,                \
+               show_fan_div, set_fan_div, offset - 1);
 
 show_fan_offset(1);
 show_fan_offset(2);
 
-static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
-               size_t count)
-{
-       return set_fan_div(dev, buf, count, 0) ;
-}
-
-static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
-               size_t count)
-{
-       return set_fan_div(dev, buf, count, 1) ;
-}
-static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
-               show_fan_1_div, set_fan_1_div);
-static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
-               show_fan_2_div, set_fan_2_div);
-
 /* Alarms */
 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -470,70 +437,121 @@ static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, ch
        return sprintf(buf, "%d\n", data->alarms);
 }
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
+
+static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
+                         char *buf)
+{
+       struct sis5595_data *data = sis5595_update_device(dev);
+       int nr = to_sensor_dev_attr(da)->index;
+       return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
+}
+static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 15);
+static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
+static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
+static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 15);
+
+static ssize_t show_name(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+       struct sis5595_data *data = dev_get_drvdata(dev);
+       return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
+static struct attribute *sis5595_attributes[] = {
+       &sensor_dev_attr_in0_input.dev_attr.attr,
+       &sensor_dev_attr_in0_min.dev_attr.attr,
+       &sensor_dev_attr_in0_max.dev_attr.attr,
+       &sensor_dev_attr_in0_alarm.dev_attr.attr,
+       &sensor_dev_attr_in1_input.dev_attr.attr,
+       &sensor_dev_attr_in1_min.dev_attr.attr,
+       &sensor_dev_attr_in1_max.dev_attr.attr,
+       &sensor_dev_attr_in1_alarm.dev_attr.attr,
+       &sensor_dev_attr_in2_input.dev_attr.attr,
+       &sensor_dev_attr_in2_min.dev_attr.attr,
+       &sensor_dev_attr_in2_max.dev_attr.attr,
+       &sensor_dev_attr_in2_alarm.dev_attr.attr,
+       &sensor_dev_attr_in3_input.dev_attr.attr,
+       &sensor_dev_attr_in3_min.dev_attr.attr,
+       &sensor_dev_attr_in3_max.dev_attr.attr,
+       &sensor_dev_attr_in3_alarm.dev_attr.attr,
+
+       &sensor_dev_attr_fan1_input.dev_attr.attr,
+       &sensor_dev_attr_fan1_min.dev_attr.attr,
+       &sensor_dev_attr_fan1_div.dev_attr.attr,
+       &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan2_input.dev_attr.attr,
+       &sensor_dev_attr_fan2_min.dev_attr.attr,
+       &sensor_dev_attr_fan2_div.dev_attr.attr,
+       &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+
+       &dev_attr_alarms.attr,
+       &dev_attr_name.attr,
+       NULL
+};
+
+static const struct attribute_group sis5595_group = {
+       .attrs = sis5595_attributes,
+};
+
+static struct attribute *sis5595_attributes_in4[] = {
+       &sensor_dev_attr_in4_input.dev_attr.attr,
+       &sensor_dev_attr_in4_min.dev_attr.attr,
+       &sensor_dev_attr_in4_max.dev_attr.attr,
+       &sensor_dev_attr_in4_alarm.dev_attr.attr,
+       NULL
+};
+
+static const struct attribute_group sis5595_group_in4 = {
+       .attrs = sis5595_attributes_in4,
+};
+
+static struct attribute *sis5595_attributes_temp1[] = {
+       &dev_attr_temp1_input.attr,
+       &dev_attr_temp1_max.attr,
+       &dev_attr_temp1_max_hyst.attr,
+       &sensor_dev_attr_temp1_alarm.dev_attr.attr,
+       NULL
+};
+
+static const struct attribute_group sis5595_group_temp1 = {
+       .attrs = sis5595_attributes_temp1,
+};
  
 /* This is called when the module is loaded */
-static int sis5595_detect(struct i2c_adapter *adapter)
+static int __devinit sis5595_probe(struct platform_device *pdev)
 {
        int err = 0;
        int i;
-       struct i2c_client *new_client;
        struct sis5595_data *data;
+       struct resource *res;
        char val;
-       u16 a;
 
-       if (force_addr)
-               address = force_addr & ~(SIS5595_EXTENT - 1);
        /* Reserve the ISA region */
-       if (!request_region(address, SIS5595_EXTENT, sis5595_driver.name)) {
+       res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+       if (!request_region(res->start, SIS5595_EXTENT,
+                           sis5595_driver.driver.name)) {
                err = -EBUSY;
                goto exit;
        }
-       if (force_addr) {
-               dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n", address);
-               if (PCIBIOS_SUCCESSFUL !=
-                   pci_write_config_word(s_bridge, SIS5595_BASE_REG, address))
-                       goto exit_release;
-               if (PCIBIOS_SUCCESSFUL !=
-                   pci_read_config_word(s_bridge, SIS5595_BASE_REG, &a))
-                       goto exit_release;
-               if ((a & ~(SIS5595_EXTENT - 1)) != address)
-                       /* doesn't work for some chips? */
-                       goto exit_release;
-       }
 
-       if (PCIBIOS_SUCCESSFUL !=
-           pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val)) {
-               goto exit_release;
-       }
-       if ((val & 0x80) == 0) {
-               if (PCIBIOS_SUCCESSFUL !=
-                   pci_write_config_byte(s_bridge, SIS5595_ENABLE_REG,
-                                         val | 0x80))
-                       goto exit_release;
-               if (PCIBIOS_SUCCESSFUL !=
-                   pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val))
-                       goto exit_release;
-               if ((val & 0x80) == 0) 
-                       /* doesn't work for some chips! */
-                       goto exit_release;
-       }
-
-       if (!(data = kmalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit_release;
        }
-       memset(data, 0, sizeof(struct sis5595_data));
 
-       new_client = &data->client;
-       new_client->addr = address;
-       init_MUTEX(&data->lock);
-       i2c_set_clientdata(new_client, data);
-       new_client->adapter = adapter;
-       new_client->driver = &sis5595_driver;
-       new_client->flags = 0;
+       mutex_init(&data->lock);
+       mutex_init(&data->update_lock);
+       data->addr = res->start;
+       data->name = "sis5595";
+       platform_set_drvdata(pdev, data);
 
        /* Check revision and pin registers to determine whether 4 or 5 voltages */
-       pci_read_config_byte(s_bridge, SIS5595_REVISION_REG, &(data->revision));
+       data->revision = s_bridge->revision;
        /* 4 voltages, 1 temp */
        data->maxins = 3;
        if (data->revision >= REV2MIN) {
@@ -543,85 +561,59 @@ static int sis5595_detect(struct i2c_adapter *adapter)
                        data->maxins = 4;
        }
        
-       /* Fill in the remaining client fields and put it into the global list */
-       strlcpy(new_client->name, "sis5595", I2C_NAME_SIZE);
-
-       data->valid = 0;
-       init_MUTEX(&data->update_lock);
-
-       /* Tell the I2C layer a new client has arrived */
-       if ((err = i2c_attach_client(new_client)))
-               goto exit_free;
-       
        /* Initialize the SIS5595 chip */
-       sis5595_init_client(new_client);
+       sis5595_init_device(data);
 
        /* A few vars need to be filled upon startup */
        for (i = 0; i < 2; i++) {
-               data->fan_min[i] = sis5595_read_value(new_client,
+               data->fan_min[i] = sis5595_read_value(data,
                                        SIS5595_REG_FAN_MIN(i));
        }
 
        /* 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 exit_detach;
-       }
-
-       device_create_file(&new_client->dev, &dev_attr_in0_input);
-       device_create_file(&new_client->dev, &dev_attr_in0_min);
-       device_create_file(&new_client->dev, &dev_attr_in0_max);
-       device_create_file(&new_client->dev, &dev_attr_in1_input);
-       device_create_file(&new_client->dev, &dev_attr_in1_min);
-       device_create_file(&new_client->dev, &dev_attr_in1_max);
-       device_create_file(&new_client->dev, &dev_attr_in2_input);
-       device_create_file(&new_client->dev, &dev_attr_in2_min);
-       device_create_file(&new_client->dev, &dev_attr_in2_max);
-       device_create_file(&new_client->dev, &dev_attr_in3_input);
-       device_create_file(&new_client->dev, &dev_attr_in3_min);
-       device_create_file(&new_client->dev, &dev_attr_in3_max);
+       if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group)))
+               goto exit_free;
        if (data->maxins == 4) {
-               device_create_file(&new_client->dev, &dev_attr_in4_input);
-               device_create_file(&new_client->dev, &dev_attr_in4_min);
-               device_create_file(&new_client->dev, &dev_attr_in4_max);
+               if ((err = sysfs_create_group(&pdev->dev.kobj,
+                                             &sis5595_group_in4)))
+                       goto exit_remove_files;
+       } else {
+               if ((err = sysfs_create_group(&pdev->dev.kobj,
+                                             &sis5595_group_temp1)))
+                       goto exit_remove_files;
        }
-       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);
-       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);
-       device_create_file(&new_client->dev, &dev_attr_alarms);
-       if (data->maxins == 3) {
-               device_create_file(&new_client->dev, &dev_attr_temp1_input);
-               device_create_file(&new_client->dev, &dev_attr_temp1_max);
-               device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
+
+       data->hwmon_dev = hwmon_device_register(&pdev->dev);
+       if (IS_ERR(data->hwmon_dev)) {
+               err = PTR_ERR(data->hwmon_dev);
+               goto exit_remove_files;
        }
+
        return 0;
 
-exit_detach:
-       i2c_detach_client(new_client);
+exit_remove_files:
+       sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
+       sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
+       sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
 exit_free:
        kfree(data);
 exit_release:
-       release_region(address, SIS5595_EXTENT);
+       release_region(res->start, SIS5595_EXTENT);
 exit:
        return err;
 }
 
-static int sis5595_detach_client(struct i2c_client *client)
+static int __devexit sis5595_remove(struct platform_device *pdev)
 {
-       struct sis5595_data *data = i2c_get_clientdata(client);
-       int err;
-
-       hwmon_device_unregister(data->class_dev);
-
-       if ((err = i2c_detach_client(client)))
-               return err;
+       struct sis5595_data *data = platform_get_drvdata(pdev);
 
-       release_region(client->addr, SIS5595_EXTENT);
+       hwmon_device_unregister(data->hwmon_dev);
+       sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
+       sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
+       sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
 
+       release_region(data->addr, SIS5595_EXTENT);
+       platform_set_drvdata(pdev, NULL);
        kfree(data);
 
        return 0;
@@ -629,89 +621,85 @@ static int sis5595_detach_client(struct i2c_client *client)
 
 
 /* ISA access must be locked explicitly. */
-static int sis5595_read_value(struct i2c_client *client, u8 reg)
+static int sis5595_read_value(struct sis5595_data *data, u8 reg)
 {
        int res;
 
-       struct sis5595_data *data = i2c_get_clientdata(client);
-       down(&data->lock);
-       outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
-       res = inb_p(client->addr + SIS5595_DATA_REG_OFFSET);
-       up(&data->lock);
+       mutex_lock(&data->lock);
+       outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
+       res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
+       mutex_unlock(&data->lock);
        return res;
 }
 
-static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
+static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
 {
-       struct sis5595_data *data = i2c_get_clientdata(client);
-       down(&data->lock);
-       outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
-       outb_p(value, client->addr + SIS5595_DATA_REG_OFFSET);
-       up(&data->lock);
-       return 0;
+       mutex_lock(&data->lock);
+       outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
+       outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
+       mutex_unlock(&data->lock);
 }
 
 /* Called when we have found a new SIS5595. */
-static void sis5595_init_client(struct i2c_client *client)
+static void __devinit sis5595_init_device(struct sis5595_data *data)
 {
-       u8 config = sis5595_read_value(client, SIS5595_REG_CONFIG);
+       u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
        if (!(config & 0x01))
-               sis5595_write_value(client, SIS5595_REG_CONFIG,
+               sis5595_write_value(data, SIS5595_REG_CONFIG,
                                (config & 0xf7) | 0x01);
 }
 
 static struct sis5595_data *sis5595_update_device(struct device *dev)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct sis5595_data *data = i2c_get_clientdata(client);
+       struct sis5595_data *data = dev_get_drvdata(dev);
        int i;
 
-       down(&data->update_lock);
+       mutex_lock(&data->update_lock);
 
        if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
            || !data->valid) {
 
                for (i = 0; i <= data->maxins; i++) {
                        data->in[i] =
-                           sis5595_read_value(client, SIS5595_REG_IN(i));
+                           sis5595_read_value(data, SIS5595_REG_IN(i));
                        data->in_min[i] =
-                           sis5595_read_value(client,
+                           sis5595_read_value(data,
                                               SIS5595_REG_IN_MIN(i));
                        data->in_max[i] =
-                           sis5595_read_value(client,
+                           sis5595_read_value(data,
                                               SIS5595_REG_IN_MAX(i));
                }
                for (i = 0; i < 2; i++) {
                        data->fan[i] =
-                           sis5595_read_value(client, SIS5595_REG_FAN(i));
+                           sis5595_read_value(data, SIS5595_REG_FAN(i));
                        data->fan_min[i] =
-                           sis5595_read_value(client,
+                           sis5595_read_value(data,
                                               SIS5595_REG_FAN_MIN(i));
                }
                if (data->maxins == 3) {
                        data->temp =
-                           sis5595_read_value(client, SIS5595_REG_TEMP);
+                           sis5595_read_value(data, SIS5595_REG_TEMP);
                        data->temp_over =
-                           sis5595_read_value(client, SIS5595_REG_TEMP_OVER);
+                           sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
                        data->temp_hyst =
-                           sis5595_read_value(client, SIS5595_REG_TEMP_HYST);
+                           sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
                }
-               i = sis5595_read_value(client, SIS5595_REG_FANDIV);
+               i = sis5595_read_value(data, SIS5595_REG_FANDIV);
                data->fan_div[0] = (i >> 4) & 0x03;
                data->fan_div[1] = i >> 6;
                data->alarms =
-                   sis5595_read_value(client, SIS5595_REG_ALARM1) |
-                   (sis5595_read_value(client, SIS5595_REG_ALARM2) << 8);
+                   sis5595_read_value(data, SIS5595_REG_ALARM1) |
+                   (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
                data->last_updated = jiffies;
                data->valid = 1;
        }
 
-       up(&data->update_lock);
+       mutex_unlock(&data->update_lock);
 
        return data;
 }
 
-static struct pci_device_id sis5595_pci_ids[] = {
+static const struct pci_device_id sis5595_pci_ids[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
        { 0, }
 };
@@ -732,48 +720,125 @@ static int blacklist[] __devinitdata = {
        PCI_DEVICE_ID_SI_5598,
        0 };
 
+static int __devinit sis5595_device_add(unsigned short address)
+{
+       struct resource res = {
+               .start  = address,
+               .end    = address + SIS5595_EXTENT - 1,
+               .name   = "sis5595",
+               .flags  = IORESOURCE_IO,
+       };
+       int err;
+
+       err = acpi_check_resource_conflict(&res);
+       if (err)
+               goto exit;
+
+       pdev = platform_device_alloc("sis5595", address);
+       if (!pdev) {
+               err = -ENOMEM;
+               pr_err("Device allocation failed\n");
+               goto exit;
+       }
+
+       err = platform_device_add_resources(pdev, &res, 1);
+       if (err) {
+               pr_err("Device resource addition failed (%d)\n", err);
+               goto exit_device_put;
+       }
+
+       err = platform_device_add(pdev);
+       if (err) {
+               pr_err("Device addition failed (%d)\n", err);
+               goto exit_device_put;
+       }
+
+       return 0;
+
+exit_device_put:
+       platform_device_put(pdev);
+exit:
+       return err;
+}
+
 static int __devinit sis5595_pci_probe(struct pci_dev *dev,
                                       const struct pci_device_id *id)
 {
-       u16 val;
+       u16 address;
+       u8 enable;
        int *i;
 
        for (i = blacklist; *i != 0; i++) {
-               struct pci_dev *dev;
-               dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
-               if (dev) {
-                       dev_err(&dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
-                       pci_dev_put(dev);
+               struct pci_dev *d;
+               if ((d = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL))) {
+                       dev_err(&d->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
+                       pci_dev_put(d);
                        return -ENODEV;
                }
        }
        
+       force_addr &= ~(SIS5595_EXTENT - 1);
+       if (force_addr) {
+               dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
+               pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
+       }
+
        if (PCIBIOS_SUCCESSFUL !=
-           pci_read_config_word(dev, SIS5595_BASE_REG, &val))
+           pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
+               dev_err(&dev->dev, "Failed to read ISA address\n");
                return -ENODEV;
+       }
        
-       address = val & ~(SIS5595_EXTENT - 1);
-       if (address == 0 && force_addr == 0) {
+       address &= ~(SIS5595_EXTENT - 1);
+       if (!address) {
                dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
                return -ENODEV;
        }
+       if (force_addr && address != force_addr) {
+               /* doesn't work for some chips? */
+               dev_err(&dev->dev, "Failed to force ISA address\n");
+               return -ENODEV;
+       }
 
-       if (!address) {
-               dev_err(&dev->dev,"No SiS 5595 sensors found.\n");
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) {
+               dev_err(&dev->dev, "Failed to read enable register\n");
                return -ENODEV;
        }
+       if (!(enable & 0x80)) {
+               if ((PCIBIOS_SUCCESSFUL !=
+                    pci_write_config_byte(dev, SIS5595_ENABLE_REG,
+                                          enable | 0x80))
+                || (PCIBIOS_SUCCESSFUL !=
+                    pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable))
+                || (!(enable & 0x80))) {
+                       /* doesn't work for some chips! */
+                       dev_err(&dev->dev, "Failed to enable HWM device\n");
+                       return -ENODEV;
+               }
+       }
 
-       s_bridge = pci_dev_get(dev);
-       if (i2c_isa_add_driver(&sis5595_driver)) {
-               pci_dev_put(s_bridge);
-               s_bridge = NULL;
+       if (platform_driver_register(&sis5595_driver)) {
+               dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
+               goto exit;
        }
 
+       s_bridge = pci_dev_get(dev);
+       /* Sets global pdev as a side effect */
+       if (sis5595_device_add(address))
+               goto exit_unregister;
+
        /* Always return failure here.  This is to allow other drivers to bind
         * to this pci device.  We don't really want to have control over the
         * pci device, we only wanted to read as few register values from it.
         */
        return -ENODEV;
+
+exit_unregister:
+       pci_dev_put(dev);
+       platform_driver_unregister(&sis5595_driver);
+exit:
+       return -ENODEV;
 }
 
 static struct pci_driver sis5595_pci_driver = {
@@ -791,7 +856,8 @@ static void __exit sm_sis5595_exit(void)
 {
        pci_unregister_driver(&sis5595_pci_driver);
        if (s_bridge != NULL) {
-               i2c_isa_del_driver(&sis5595_driver);
+               platform_device_unregister(pdev);
+               platform_driver_unregister(&sis5595_driver);
                pci_dev_put(s_bridge);
                s_bridge = NULL;
        }