Logo Search packages:      
Sourcecode: linux version File versions  Download package

adm1021.c

/*
    adm1021.c - Part of lm_sensors, Linux kernel modules for hardware
            monitoring
    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
    Philip Edelbrock <phil@netroedge.com>

    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/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>


/* Addresses to scan */
static unsigned short normal_i2c[] = { 0x18, 0x19, 0x1a,
                              0x29, 0x2a, 0x2b,
                              0x4c, 0x4d, 0x4e,
                              I2C_CLIENT_END };

/* Insmod parameters */
I2C_CLIENT_INSMOD_8(adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm,
                  mc1066);

/* adm1021 constants specified below */

/* The adm1021 registers */
/* Read-only */
/* For nr in 0-1 */
#define ADM1021_REG_TEMP(nr)        (nr)
#define ADM1021_REG_STATUS          0x02
/* 0x41 = AD, 0x49 = TI, 0x4D = Maxim, 0x23 = Genesys , 0x54 = Onsemi */
#define ADM1021_REG_MAN_ID          0xFE
/* ADM1021 = 0x0X, ADM1023 = 0x3X */
#define ADM1021_REG_DEV_ID          0xFF
/* These use different addresses for reading/writing */
#define ADM1021_REG_CONFIG_R        0x03
#define ADM1021_REG_CONFIG_W        0x09
#define ADM1021_REG_CONV_RATE_R           0x04
#define ADM1021_REG_CONV_RATE_W           0x0A
/* These are for the ADM1023's additional precision on the remote temp sensor */
#define ADM1023_REG_REM_TEMP_PREC   0x10
#define ADM1023_REG_REM_OFFSET            0x11
#define ADM1023_REG_REM_OFFSET_PREC 0x12
#define ADM1023_REG_REM_TOS_PREC    0x13
#define ADM1023_REG_REM_THYST_PREC  0x14
/* limits */
/* For nr in 0-1 */
#define ADM1021_REG_TOS_R(nr)       (0x05 + 2 * (nr))
#define ADM1021_REG_TOS_W(nr)       (0x0B + 2 * (nr))
#define ADM1021_REG_THYST_R(nr)           (0x06 + 2 * (nr))
#define ADM1021_REG_THYST_W(nr)           (0x0C + 2 * (nr))
/* write-only */
#define ADM1021_REG_ONESHOT         0x0F

/* Initial values */

/* Note: Even though I left the low and high limits named os and hyst,
they don't quite work like a thermostat the way the LM75 does.  I.e.,
a lower temp than THYST actually triggers an alarm instead of
clearing it.  Weird, ey?   --Phil  */

/* Each client has this additional data */
struct adm1021_data {
      struct i2c_client client;
      struct device *hwmon_dev;
      enum chips type;

      struct mutex update_lock;
      char valid;       /* !=0 if following fields are valid */
      unsigned long last_updated;   /* In jiffies */

      s8 temp_max[2];         /* Register values */
      s8 temp_min[2];
      s8 temp[2];
      u8 alarms;
      /* Special values for ADM1023 only */
      u8 remote_temp_prec;
      u8 remote_temp_os_prec;
      u8 remote_temp_hyst_prec;
      u8 remote_temp_offset;
      u8 remote_temp_offset_prec;
};

static int adm1021_attach_adapter(struct i2c_adapter *adapter);
static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind);
static void adm1021_init_client(struct i2c_client *client);
static int adm1021_detach_client(struct i2c_client *client);
static struct adm1021_data *adm1021_update_device(struct device *dev);

/* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */
static int read_only;


/* This is the driver that will be inserted */
static struct i2c_driver adm1021_driver = {
      .driver = {
            .name = "adm1021",
      },
      .id         = I2C_DRIVERID_ADM1021,
      .attach_adapter   = adm1021_attach_adapter,
      .detach_client    = adm1021_detach_client,
};

static ssize_t show_temp(struct device *dev,
                   struct device_attribute *devattr, char *buf)
{
      int index = to_sensor_dev_attr(devattr)->index;
      struct adm1021_data *data = adm1021_update_device(dev);

      return sprintf(buf, "%d\n", 1000 * data->temp[index]);
}

static ssize_t show_temp_max(struct device *dev,
                       struct device_attribute *devattr, char *buf)
{
      int index = to_sensor_dev_attr(devattr)->index;
      struct adm1021_data *data = adm1021_update_device(dev);

      return sprintf(buf, "%d\n", 1000 * data->temp_max[index]);
}

static ssize_t show_temp_min(struct device *dev,
                       struct device_attribute *devattr, char *buf)
{
      int index = to_sensor_dev_attr(devattr)->index;
      struct adm1021_data *data = adm1021_update_device(dev);

      return sprintf(buf, "%d\n", 1000 * data->temp_min[index]);
}

static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
                    char *buf)
{
      int index = to_sensor_dev_attr(attr)->index;
      struct adm1021_data *data = adm1021_update_device(dev);
      return sprintf(buf, "%u\n", (data->alarms >> index) & 1);
}

static ssize_t show_alarms(struct device *dev,
                     struct device_attribute *attr,
                     char *buf)
{
      struct adm1021_data *data = adm1021_update_device(dev);
      return sprintf(buf, "%u\n", data->alarms);
}

static ssize_t set_temp_max(struct device *dev,
                      struct device_attribute *devattr,
                      const char *buf, size_t count)
{
      int index = to_sensor_dev_attr(devattr)->index;
      struct i2c_client *client = to_i2c_client(dev);
      struct adm1021_data *data = i2c_get_clientdata(client);
      long temp = simple_strtol(buf, NULL, 10) / 1000;

      mutex_lock(&data->update_lock);
      data->temp_max[index] = SENSORS_LIMIT(temp, -128, 127);
      if (!read_only)
            i2c_smbus_write_byte_data(client, ADM1021_REG_TOS_W(index),
                                data->temp_max[index]);
      mutex_unlock(&data->update_lock);

      return count;
}

static ssize_t set_temp_min(struct device *dev,
                      struct device_attribute *devattr,
                      const char *buf, size_t count)
{
      int index = to_sensor_dev_attr(devattr)->index;
      struct i2c_client *client = to_i2c_client(dev);
      struct adm1021_data *data = i2c_get_clientdata(client);
      long temp = simple_strtol(buf, NULL, 10) / 1000;

      mutex_lock(&data->update_lock);
      data->temp_min[index] = SENSORS_LIMIT(temp, -128, 127);
      if (!read_only)
            i2c_smbus_write_byte_data(client, ADM1021_REG_THYST_W(index),
                                data->temp_min[index]);
      mutex_unlock(&data->update_lock);

      return count;
}

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
                    set_temp_max, 0);
static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
                    set_temp_min, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
                    set_temp_max, 1);
static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
                    set_temp_min, 1);
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);

static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

static int adm1021_attach_adapter(struct i2c_adapter *adapter)
{
      if (!(adapter->class & I2C_CLASS_HWMON))
            return 0;
      return i2c_probe(adapter, &addr_data, adm1021_detect);
}

static struct attribute *adm1021_attributes[] = {
      &sensor_dev_attr_temp1_max.dev_attr.attr,
      &sensor_dev_attr_temp1_min.dev_attr.attr,
      &sensor_dev_attr_temp1_input.dev_attr.attr,
      &sensor_dev_attr_temp2_max.dev_attr.attr,
      &sensor_dev_attr_temp2_min.dev_attr.attr,
      &sensor_dev_attr_temp2_input.dev_attr.attr,
      &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
      &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
      &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
      &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
      &sensor_dev_attr_temp2_fault.dev_attr.attr,
      &dev_attr_alarms.attr,
      NULL
};

static const struct attribute_group adm1021_group = {
      .attrs = adm1021_attributes,
};

static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind)
{
      int i;
      struct i2c_client *client;
      struct adm1021_data *data;
      int err = 0;
      const char *type_name = "";
      int conv_rate, status, config;

      if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
            pr_debug("adm1021: detect failed, "
                   "smbus byte data not supported!\n");
            goto error0;
      }

      /* OK. For now, we presume we have a valid client. We now create the
         client structure, even though we cannot fill it completely yet.
         But it allows us to access adm1021 register values. */

      if (!(data = kzalloc(sizeof(struct adm1021_data), GFP_KERNEL))) {
            pr_debug("adm1021: detect failed, kzalloc failed!\n");
            err = -ENOMEM;
            goto error0;
      }

      client = &data->client;
      i2c_set_clientdata(client, data);
      client->addr = address;
      client->adapter = adapter;
      client->driver = &adm1021_driver;
      status = i2c_smbus_read_byte_data(client, ADM1021_REG_STATUS);
      conv_rate = i2c_smbus_read_byte_data(client,
                                   ADM1021_REG_CONV_RATE_R);
      config = i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R);

      /* Now, we do the remaining detection. */
      if (kind < 0) {
            if ((status & 0x03) != 0x00 || (config & 0x3F) != 0x00
                || (conv_rate & 0xF8) != 0x00) {
                  pr_debug("adm1021: detect failed, "
                         "chip not detected!\n");
                  err = -ENODEV;
                  goto error1;
            }
      }

      /* Determine the chip type. */
      if (kind <= 0) {
            i = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID);
            if (i == 0x41)
                  if ((i2c_smbus_read_byte_data(client,
                              ADM1021_REG_DEV_ID) & 0xF0) == 0x30)
                        kind = adm1023;
                  else
                        kind = adm1021;
            else if (i == 0x49)
                  kind = thmc10;
            else if (i == 0x23)
                  kind = gl523sm;
            else if ((i == 0x4d) &&
                   (i2c_smbus_read_byte_data(client,
                                       ADM1021_REG_DEV_ID) == 0x01))
                  kind = max1617a;
            else if (i == 0x54)
                  kind = mc1066;
            /* LM84 Mfr ID in a different place, and it has more unused bits */
            else if (conv_rate == 0x00
                   && (kind == 0 /* skip extra detection */
                       || ((config & 0x7F) == 0x00
                         && (status & 0xAB) == 0x00)))
                  kind = lm84;
            else
                  kind = max1617;
      }

      if (kind == max1617) {
            type_name = "max1617";
      } else if (kind == max1617a) {
            type_name = "max1617a";
      } else if (kind == adm1021) {
            type_name = "adm1021";
      } else if (kind == adm1023) {
            type_name = "adm1023";
      } else if (kind == thmc10) {
            type_name = "thmc10";
      } else if (kind == lm84) {
            type_name = "lm84";
      } else if (kind == gl523sm) {
            type_name = "gl523sm";
      } else if (kind == mc1066) {
            type_name = "mc1066";
      }
      pr_debug("adm1021: Detected chip %s at adapter %d, address 0x%02x.\n",
             type_name, i2c_adapter_id(adapter), address);

      /* Fill in the remaining client fields */
      strlcpy(client->name, type_name, I2C_NAME_SIZE);
      data->type = kind;
      mutex_init(&data->update_lock);

      /* Tell the I2C layer a new client has arrived */
      if ((err = i2c_attach_client(client)))
            goto error1;

      /* Initialize the ADM1021 chip */
      if (kind != lm84 && !read_only)
            adm1021_init_client(client);

      /* Register sysfs hooks */
      if ((err = sysfs_create_group(&client->dev.kobj, &adm1021_group)))
            goto error2;

      data->hwmon_dev = hwmon_device_register(&client->dev);
      if (IS_ERR(data->hwmon_dev)) {
            err = PTR_ERR(data->hwmon_dev);
            goto error3;
      }

      return 0;

error3:
      sysfs_remove_group(&client->dev.kobj, &adm1021_group);
error2:
      i2c_detach_client(client);
error1:
      kfree(data);
error0:
      return err;
}

static void adm1021_init_client(struct i2c_client *client)
{
      /* Enable ADC and disable suspend mode */
      i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W,
            i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R) & 0xBF);
      /* Set Conversion rate to 1/sec (this can be tinkered with) */
      i2c_smbus_write_byte_data(client, ADM1021_REG_CONV_RATE_W, 0x04);
}

static int adm1021_detach_client(struct i2c_client *client)
{
      struct adm1021_data *data = i2c_get_clientdata(client);
      int err;

      hwmon_device_unregister(data->hwmon_dev);
      sysfs_remove_group(&client->dev.kobj, &adm1021_group);

      if ((err = i2c_detach_client(client)))
            return err;

      kfree(data);
      return 0;
}

static struct adm1021_data *adm1021_update_device(struct device *dev)
{
      struct i2c_client *client = to_i2c_client(dev);
      struct adm1021_data *data = i2c_get_clientdata(client);

      mutex_lock(&data->update_lock);

      if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
          || !data->valid) {
            int i;

            dev_dbg(&client->dev, "Starting adm1021 update\n");

            for (i = 0; i < 2; i++) {
                  data->temp[i] = i2c_smbus_read_byte_data(client,
                                    ADM1021_REG_TEMP(i));
                  data->temp_max[i] = i2c_smbus_read_byte_data(client,
                                    ADM1021_REG_TOS_R(i));
                  data->temp_min[i] = i2c_smbus_read_byte_data(client,
                                    ADM1021_REG_THYST_R(i));
            }
            data->alarms = i2c_smbus_read_byte_data(client,
                                    ADM1021_REG_STATUS) & 0x7c;
            if (data->type == adm1023) {
                  data->remote_temp_prec =
                        i2c_smbus_read_byte_data(client,
                                    ADM1023_REG_REM_TEMP_PREC);
                  data->remote_temp_os_prec =
                        i2c_smbus_read_byte_data(client,
                                    ADM1023_REG_REM_TOS_PREC);
                  data->remote_temp_hyst_prec =
                        i2c_smbus_read_byte_data(client,
                                    ADM1023_REG_REM_THYST_PREC);
                  data->remote_temp_offset =
                        i2c_smbus_read_byte_data(client,
                                    ADM1023_REG_REM_OFFSET);
                  data->remote_temp_offset_prec =
                        i2c_smbus_read_byte_data(client,
                                    ADM1023_REG_REM_OFFSET_PREC);
            }
            data->last_updated = jiffies;
            data->valid = 1;
      }

      mutex_unlock(&data->update_lock);

      return data;
}

static int __init sensors_adm1021_init(void)
{
      return i2c_add_driver(&adm1021_driver);
}

static void __exit sensors_adm1021_exit(void)
{
      i2c_del_driver(&adm1021_driver);
}

MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl> and "
            "Philip Edelbrock <phil@netroedge.com>");
MODULE_DESCRIPTION("adm1021 driver");
MODULE_LICENSE("GPL");

module_param(read_only, bool, 0);
MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");

module_init(sensors_adm1021_init)
module_exit(sensors_adm1021_exit)

Generated by  Doxygen 1.6.0   Back to index