drivers/hwmon/lm75.c

   1 /*
   2  * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
   3  *       monitoring
   4  * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/i2c.h>
  26 #include <linux/hwmon.h>
  27 #include <linux/hwmon-sysfs.h>
  28 #include <linux/err.h>
  29 #include <linux/mutex.h>
  30 #include "lm75.h"
  31
  32
  33 /*
  34  * This driver handles the LM75 and compatible digital temperature sensors.
  35  */
  36
  37 enum lm75_type {                /* keep sorted in alphabetical order */
  38         ds1775,
  39         ds75,
  40         lm75,
  41         lm75a,
  42         max6625,
  43         max6626,
  44         mcp980x,
  45         stds75,
  46         tcn75,
  47         tmp100,
  48         tmp101,
  49         tmp105,
  50         tmp175,
  51         tmp275,
  52         tmp75,
  53 };
  54
  55 /* Addresses scanned */
  56 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
  57                                         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
  58
  59
  60 /* The LM75 registers */
  61 #define LM75_REG_CONF           0x01
  62 static const u8 LM75_REG_TEMP[3] = {
  63         0x00,           /* input */
  64         0x03,           /* max */
  65         0x02,           /* hyst */
  66 };
  67
  68 /* Each client has this additional data */
  69 struct lm75_data {
  70         struct device           *hwmon_dev;
  71         struct mutex            update_lock;
  72         u8                      orig_conf;
  73         char                    valid;          /* !=0 if registers are valid */
  74         unsigned long           last_updated;   /* In jiffies */
  75         u16                     temp[3];        /* Register values,
  76                                                    0 = input
  77                                                    1 = max
  78                                                    2 = hyst */
  79 };
  80
  81 static int lm75_read_value(struct i2c_client *client, u8 reg);
  82 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
  83 static struct lm75_data *lm75_update_device(struct device *dev);
  84
  85
  86 /*-----------------------------------------------------------------------*/
  87
  88 /* sysfs attributes for hwmon */
  89
  90 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
  91                          char *buf)
  92 {
  93         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
  94         struct lm75_data *data = lm75_update_device(dev);
  95         return sprintf(buf, "%d\n",
  96                        LM75_TEMP_FROM_REG(data->temp[attr->index]));
  97 }
  98
  99 static ssize_t set_temp(struct device *dev, struct device_attribute *da,
 100                         const char *buf, size_t count)
 101 {
 102         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 103         struct i2c_client *client = to_i2c_client(dev);
 104         struct lm75_data *data = i2c_get_clientdata(client);
 105         int nr = attr->index;
 106         long temp;
 107         int error;
 108
 109         error = strict_strtol(buf, 10, &temp);
 110         if (error)
 111                 return error;
 112
 113         mutex_lock(&data->update_lock);
 114         data->temp[nr] = LM75_TEMP_TO_REG(temp);
 115         lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
 116         mutex_unlock(&data->update_lock);
 117         return count;
 118 }
 119
 120 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
 121                         show_temp, set_temp, 1);
 122 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
 123                         show_temp, set_temp, 2);
 124 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 125
 126 static struct attribute *lm75_attributes[] = {
 127         &sensor_dev_attr_temp1_input.dev_attr.attr,
 128         &sensor_dev_attr_temp1_max.dev_attr.attr,
 129         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
 130
 131         NULL
 132 };
 133
 134 static const struct attribute_group lm75_group = {
 135         .attrs = lm75_attributes,
 136 };
 137
 138 /*-----------------------------------------------------------------------*/
 139
 140 /* device probe and removal */
 141
 142 static int
 143 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
 144 {
 145         struct lm75_data *data;
 146         int status;
 147         u8 set_mask, clr_mask;
 148         int new;
 149
 150         if (!i2c_check_functionality(client->adapter,
 151                         I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
 152                 return -EIO;
 153
 154         data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
 155         if (!data)
 156                 return -ENOMEM;
 157
 158         i2c_set_clientdata(client, data);
 159         mutex_init(&data->update_lock);
 160
 161         /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
 162          * Then tweak to be more precise when appropriate.
 163          */
 164         set_mask = 0;
 165         clr_mask = (1 << 0)                     /* continuous conversions */
 166                 | (1 << 6) | (1 << 5);          /* 9-bit mode */
 167
 168         /* configure as specified */
 169         status = lm75_read_value(client, LM75_REG_CONF);
 170         if (status < 0) {
 171                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
 172                 goto exit_free;
 173         }
 174         data->orig_conf = status;
 175         new = status & ~clr_mask;
 176         new |= set_mask;
 177         if (status != new)
 178                 lm75_write_value(client, LM75_REG_CONF, new);
 179         dev_dbg(&client->dev, "Config %02x\n", new);
 180
 181         /* Register sysfs hooks */
 182         status = sysfs_create_group(&client->dev.kobj, &lm75_group);
 183         if (status)
 184                 goto exit_free;
 185
 186         data->hwmon_dev = hwmon_device_register(&client->dev);
 187         if (IS_ERR(data->hwmon_dev)) {
 188                 status = PTR_ERR(data->hwmon_dev);
 189                 goto exit_remove;
 190         }
 191
 192         dev_info(&client->dev, "%s: sensor '%s'\n",
 193                  dev_name(data->hwmon_dev), client->name);
 194
 195         return 0;
 196
 197 exit_remove:
 198         sysfs_remove_group(&client->dev.kobj, &lm75_group);
 199 exit_free:
 200         kfree(data);
 201         return status;
 202 }
 203
 204 static int lm75_remove(struct i2c_client *client)
 205 {
 206         struct lm75_data *data = i2c_get_clientdata(client);
 207
 208         hwmon_device_unregister(data->hwmon_dev);
 209         sysfs_remove_group(&client->dev.kobj, &lm75_group);
 210         lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
 211         kfree(data);
 212         return 0;
 213 }
 214
 215 static const struct i2c_device_id lm75_ids[] = {
 216         { "ds1775", ds1775, },
 217         { "ds75", ds75, },
 218         { "lm75", lm75, },
 219         { "lm75a", lm75a, },
 220         { "max6625", max6625, },
 221         { "max6626", max6626, },
 222         { "mcp980x", mcp980x, },
 223         { "stds75", stds75, },
 224         { "tcn75", tcn75, },
 225         { "tmp100", tmp100, },
 226         { "tmp101", tmp101, },
 227         { "tmp105", tmp105, },
 228         { "tmp175", tmp175, },
 229         { "tmp275", tmp275, },
 230         { "tmp75", tmp75, },
 231         { /* LIST END */ }
 232 };
 233 MODULE_DEVICE_TABLE(i2c, lm75_ids);
 234
 235 #define LM75A_ID 0xA1
 236
 237 /* Return 0 if detection is successful, -ENODEV otherwise */
 238 static int lm75_detect(struct i2c_client *new_client,
 239                        struct i2c_board_info *info)
 240 {
 241         struct i2c_adapter *adapter = new_client->adapter;
 242         int i;
 243         int conf, hyst, os;
 244         bool is_lm75a = 0;
 245
 246         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 247                                      I2C_FUNC_SMBUS_WORD_DATA))
 248                 return -ENODEV;
 249
 250         /* Now, we do the remaining detection. There is no identification-
 251            dedicated register so we have to rely on several tricks:
 252            unused bits, registers cycling over 8-address boundaries,
 253            addresses 0x04-0x07 returning the last read value.
 254            The cycling+unused addresses combination is not tested,
 255            since it would significantly slow the detection down and would
 256            hardly add any value.
 257
 258            The National Semiconductor LM75A is different than earlier
 259            LM75s.  It has an ID byte of 0xaX (where X is the chip
 260            revision, with 1 being the only revision in existence) in
 261            register 7, and unused registers return 0xff rather than the
 262            last read value. */
 263
 264         /* Unused bits */
 265         conf = i2c_smbus_read_byte_data(new_client, 1);
 266         if (conf & 0xe0)
 267                 return -ENODEV;
 268
 269         /* First check for LM75A */
 270         if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
 271                 /* LM75A returns 0xff on unused registers so
 272                    just to be sure we check for that too. */
 273                 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
 274                  || i2c_smbus_read_byte_data(new_client, 5) != 0xff
 275                  || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
 276                         return -ENODEV;
 277                 is_lm75a = 1;
 278                 hyst = i2c_smbus_read_byte_data(new_client, 2);
 279                 os = i2c_smbus_read_byte_data(new_client, 3);
 280         } else { /* Traditional style LM75 detection */
 281                 /* Unused addresses */
 282                 hyst = i2c_smbus_read_byte_data(new_client, 2);
 283                 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
 284                  || i2c_smbus_read_byte_data(new_client, 5) != hyst
 285                  || i2c_smbus_read_byte_data(new_client, 6) != hyst
 286                  || i2c_smbus_read_byte_data(new_client, 7) != hyst)
 287                         return -ENODEV;
 288                 os = i2c_smbus_read_byte_data(new_client, 3);
 289                 if (i2c_smbus_read_byte_data(new_client, 4) != os
 290                  || i2c_smbus_read_byte_data(new_client, 5) != os
 291                  || i2c_smbus_read_byte_data(new_client, 6) != os
 292                  || i2c_smbus_read_byte_data(new_client, 7) != os)
 293                         return -ENODEV;
 294         }
 295
 296         /* Addresses cycling */
 297         for (i = 8; i <= 248; i += 40) {
 298                 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
 299                  || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
 300                  || i2c_smbus_read_byte_data(new_client, i + 3) != os)
 301                         return -ENODEV;
 302                 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
 303                                 != LM75A_ID)
 304                         return -ENODEV;
 305         }
 306
 307         strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
 308
 309         return 0;
 310 }
 311
 312 #ifdef CONFIG_PM
 313 static int lm75_suspend(struct device *dev)
 314 {
 315         int status;
 316         struct i2c_client *client = to_i2c_client(dev);
 317         status = lm75_read_value(client, LM75_REG_CONF);
 318         if (status < 0) {
 319                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
 320                 return status;
 321         }
 322         status = status | LM75_SHUTDOWN;
 323         lm75_write_value(client, LM75_REG_CONF, status);
 324         return 0;
 325 }
 326
 327 static int lm75_resume(struct device *dev)
 328 {
 329         int status;
 330         struct i2c_client *client = to_i2c_client(dev);
 331         status = lm75_read_value(client, LM75_REG_CONF);
 332         if (status < 0) {
 333                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
 334                 return status;
 335         }
 336         status = status & ~LM75_SHUTDOWN;
 337         lm75_write_value(client, LM75_REG_CONF, status);
 338         return 0;
 339 }
 340
 341 static const struct dev_pm_ops lm75_dev_pm_ops = {
 342         .suspend        = lm75_suspend,
 343         .resume         = lm75_resume,
 344 };
 345 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
 346 #else
 347 #define LM75_DEV_PM_OPS NULL
 348 #endif /* CONFIG_PM */
 349
 350 static struct i2c_driver lm75_driver = {
 351         .class          = I2C_CLASS_HWMON,
 352         .driver = {
 353                 .name   = "lm75",
 354                 .pm     = LM75_DEV_PM_OPS,
 355         },
 356         .probe          = lm75_probe,
 357         .remove         = lm75_remove,
 358         .id_table       = lm75_ids,
 359         .detect         = lm75_detect,
 360         .address_list   = normal_i2c,
 361 };
 362
 363 /*-----------------------------------------------------------------------*/
 364
 365 /* register access */
 366
 367 /*
 368  * All registers are word-sized, except for the configuration register.
 369  * LM75 uses a high-byte first convention, which is exactly opposite to
 370  * the SMBus standard.
 371  */
 372 static int lm75_read_value(struct i2c_client *client, u8 reg)
 373 {
 374         int value;
 375
 376         if (reg == LM75_REG_CONF)
 377                 return i2c_smbus_read_byte_data(client, reg);
 378
 379         value = i2c_smbus_read_word_data(client, reg);
 380         return (value < 0) ? value : swab16(value);
 381 }
 382
 383 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
 384 {
 385         if (reg == LM75_REG_CONF)
 386                 return i2c_smbus_write_byte_data(client, reg, value);
 387         else
 388                 return i2c_smbus_write_word_data(client, reg, swab16(value));
 389 }
 390
 391 static struct lm75_data *lm75_update_device(struct device *dev)
 392 {
 393         struct i2c_client *client = to_i2c_client(dev);
 394         struct lm75_data *data = i2c_get_clientdata(client);
 395
 396         mutex_lock(&data->update_lock);
 397
 398         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 399             || !data->valid) {
 400                 int i;
 401                 dev_dbg(&client->dev, "Starting lm75 update\n");
 402
 403                 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
 404                         int status;
 405
 406                         status = lm75_read_value(client, LM75_REG_TEMP[i]);
 407                         if (status < 0)
 408                                 dev_dbg(&client->dev, "reg %d, err %d\n",
 409                                                 LM75_REG_TEMP[i], status);
 410                         else
 411                                 data->temp[i] = status;
 412                 }
 413                 data->last_updated = jiffies;
 414                 data->valid = 1;
 415         }
 416
 417         mutex_unlock(&data->update_lock);
 418
 419         return data;
 420 }
 421
 422 /*-----------------------------------------------------------------------*/
 423
 424 /* module glue */
 425
 426 static int __init sensors_lm75_init(void)
 427 {
 428         return i2c_add_driver(&lm75_driver);
 429 }
 430
 431 static void __exit sensors_lm75_exit(void)
 432 {
 433         i2c_del_driver(&lm75_driver);
 434 }
 435
 436 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
 437 MODULE_DESCRIPTION("LM75 driver");
 438 MODULE_LICENSE("GPL");
 439
 440 module_init(sensors_lm75_init);
 441 module_exit(sensors_lm75_exit);