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