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