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 <[email protected]>
   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/of.h>
  30 #include <linux/regmap.h>
  31 #include "lm75.h"
  32
  33
  34 /*
  35  * This driver handles the LM75 and compatible digital temperature sensors.
  36  */
  37
  38 enum lm75_type {                /* keep sorted in alphabetical order */
  39         adt75,
  40         ds1775,
  41         ds75,
  42         ds7505,
  43         g751,
  44         lm75,
  45         lm75a,
  46         lm75b,
  47         max6625,
  48         max6626,
  49         mcp980x,
  50         stds75,
  51         tcn75,
  52         tmp100,
  53         tmp101,
  54         tmp105,
  55         tmp112,
  56         tmp175,
  57         tmp275,
  58         tmp75,
  59         tmp75c,
  60 };
  61
  62 /* Addresses scanned */
  63 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
  64                                         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
  65
  66
  67 /* The LM75 registers */
  68 #define LM75_REG_TEMP           0x00
  69 #define LM75_REG_CONF           0x01
  70 #define LM75_REG_HYST           0x02
  71 #define LM75_REG_MAX            0x03
  72
  73 /* Each client has this additional data */
  74 struct lm75_data {
  75         struct i2c_client       *client;
  76         struct regmap           *regmap;
  77         u8                      orig_conf;
  78         u8                      resolution;     /* In bits, between 9 and 12 */
  79         u8                      resolution_limits;
  80         unsigned int            sample_time;    /* In ms */
  81 };
  82
  83 /*-----------------------------------------------------------------------*/
  84
  85 static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
  86 {
  87         return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
  88 }
  89
  90 static int lm75_read(struct device *dev, enum hwmon_sensor_types type,
  91                      u32 attr, int channel, long *val)
  92 {
  93         struct lm75_data *data = dev_get_drvdata(dev);
  94         unsigned int regval;
  95         int err, reg;
  96
  97         switch (type) {
  98         case hwmon_chip:
  99                 switch (attr) {
 100                 case hwmon_chip_update_interval:
 101                         *val = data->sample_time;
 102                         break;;
 103                 default:
 104                         return -EINVAL;
 105                 }
 106                 break;
 107         case hwmon_temp:
 108                 switch (attr) {
 109                 case hwmon_temp_input:
 110                         reg = LM75_REG_TEMP;
 111                         break;
 112                 case hwmon_temp_max:
 113                         reg = LM75_REG_MAX;
 114                         break;
 115                 case hwmon_temp_max_hyst:
 116                         reg = LM75_REG_HYST;
 117                         break;
 118                 default:
 119                         return -EINVAL;
 120                 }
 121                 err = regmap_read(data->regmap, reg, &regval);
 122                 if (err < 0)
 123                         return err;
 124
 125                 *val = lm75_reg_to_mc(regval, data->resolution);
 126                 break;
 127         default:
 128                 return -EINVAL;
 129         }
 130         return 0;
 131 }
 132
 133 static int lm75_write(struct device *dev, enum hwmon_sensor_types type,
 134                       u32 attr, int channel, long temp)
 135 {
 136         struct lm75_data *data = dev_get_drvdata(dev);
 137         u8 resolution;
 138         int reg;
 139
 140         if (type != hwmon_temp)
 141                 return -EINVAL;
 142
 143         switch (attr) {
 144         case hwmon_temp_max:
 145                 reg = LM75_REG_MAX;
 146                 break;
 147         case hwmon_temp_max_hyst:
 148                 reg = LM75_REG_HYST;
 149                 break;
 150         default:
 151                 return -EINVAL;
 152         }
 153
 154         /*
 155          * Resolution of limit registers is assumed to be the same as the
 156          * temperature input register resolution unless given explicitly.
 157          */
 158         if (data->resolution_limits)
 159                 resolution = data->resolution_limits;
 160         else
 161                 resolution = data->resolution;
 162
 163         temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
 164         temp = DIV_ROUND_CLOSEST(temp  << (resolution - 8),
 165                                  1000) << (16 - resolution);
 166
 167         return regmap_write(data->regmap, reg, temp);
 168 }
 169
 170 static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type,
 171                                u32 attr, int channel)
 172 {
 173         switch (type) {
 174         case hwmon_chip:
 175                 switch (attr) {
 176                 case hwmon_chip_update_interval:
 177                         return S_IRUGO;
 178                 }
 179                 break;
 180         case hwmon_temp:
 181                 switch (attr) {
 182                 case hwmon_temp_input:
 183                         return S_IRUGO;
 184                 case hwmon_temp_max:
 185                 case hwmon_temp_max_hyst:
 186                         return S_IRUGO | S_IWUSR;
 187                 }
 188                 break;
 189         default:
 190                 break;
 191         }
 192         return 0;
 193 }
 194
 195 /*-----------------------------------------------------------------------*/
 196
 197 /* device probe and removal */
 198
 199 /* chip configuration */
 200
 201 static const u32 lm75_chip_config[] = {
 202         HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL,
 203         0
 204 };
 205
 206 static const struct hwmon_channel_info lm75_chip = {
 207         .type = hwmon_chip,
 208         .config = lm75_chip_config,
 209 };
 210
 211 static const u32 lm75_temp_config[] = {
 212         HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST,
 213         0
 214 };
 215
 216 static const struct hwmon_channel_info lm75_temp = {
 217         .type = hwmon_temp,
 218         .config = lm75_temp_config,
 219 };
 220
 221 static const struct hwmon_channel_info *lm75_info[] = {
 222         &lm75_chip,
 223         &lm75_temp,
 224         NULL
 225 };
 226
 227 static const struct hwmon_ops lm75_hwmon_ops = {
 228         .is_visible = lm75_is_visible,
 229         .read = lm75_read,
 230         .write = lm75_write,
 231 };
 232
 233 static const struct hwmon_chip_info lm75_chip_info = {
 234         .ops = &lm75_hwmon_ops,
 235         .info = lm75_info,
 236 };
 237
 238 static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
 239 {
 240         return reg != LM75_REG_TEMP;
 241 }
 242
 243 static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg)
 244 {
 245         return reg == LM75_REG_TEMP;
 246 }
 247
 248 static const struct regmap_config lm75_regmap_config = {
 249         .reg_bits = 8,
 250         .val_bits = 16,
 251         .max_register = LM75_REG_MAX,
 252         .writeable_reg = lm75_is_writeable_reg,
 253         .volatile_reg = lm75_is_volatile_reg,
 254         .val_format_endian = REGMAP_ENDIAN_BIG,
 255         .cache_type = REGCACHE_RBTREE,
 256         .use_single_rw = true,
 257 };
 258
 259 static void lm75_remove(void *data)
 260 {
 261         struct lm75_data *lm75 = data;
 262         struct i2c_client *client = lm75->client;
 263
 264         i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
 265 }
 266
 267 static int
 268 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
 269 {
 270         struct device *dev = &client->dev;
 271         struct device *hwmon_dev;
 272         struct lm75_data *data;
 273         int status, err;
 274         u8 set_mask, clr_mask;
 275         int new;
 276         enum lm75_type kind = id->driver_data;
 277
 278         if (!i2c_check_functionality(client->adapter,
 279                         I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
 280                 return -EIO;
 281
 282         data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL);
 283         if (!data)
 284                 return -ENOMEM;
 285
 286         data->client = client;
 287
 288         data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
 289         if (IS_ERR(data->regmap))
 290                 return PTR_ERR(data->regmap);
 291
 292         /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
 293          * Then tweak to be more precise when appropriate.
 294          */
 295         set_mask = 0;
 296         clr_mask = LM75_SHUTDOWN;               /* continuous conversions */
 297
 298         switch (kind) {
 299         case adt75:
 300                 clr_mask |= 1 << 5;             /* not one-shot mode */
 301                 data->resolution = 12;
 302                 data->sample_time = MSEC_PER_SEC / 8;
 303                 break;
 304         case ds1775:
 305         case ds75:
 306         case stds75:
 307                 clr_mask |= 3 << 5;
 308                 set_mask |= 2 << 5;             /* 11-bit mode */
 309                 data->resolution = 11;
 310                 data->sample_time = MSEC_PER_SEC;
 311                 break;
 312         case ds7505:
 313                 set_mask |= 3 << 5;             /* 12-bit mode */
 314                 data->resolution = 12;
 315                 data->sample_time = MSEC_PER_SEC / 4;
 316                 break;
 317         case g751:
 318         case lm75:
 319         case lm75a:
 320                 data->resolution = 9;
 321                 data->sample_time = MSEC_PER_SEC / 2;
 322                 break;
 323         case lm75b:
 324                 data->resolution = 11;
 325                 data->sample_time = MSEC_PER_SEC / 4;
 326                 break;
 327         case max6625:
 328                 data->resolution = 9;
 329                 data->sample_time = MSEC_PER_SEC / 4;
 330                 break;
 331         case max6626:
 332                 data->resolution = 12;
 333                 data->resolution_limits = 9;
 334                 data->sample_time = MSEC_PER_SEC / 4;
 335                 break;
 336         case tcn75:
 337                 data->resolution = 9;
 338                 data->sample_time = MSEC_PER_SEC / 8;
 339                 break;
 340         case mcp980x:
 341                 data->resolution_limits = 9;
 342                 /* fall through */
 343         case tmp100:
 344         case tmp101:
 345                 set_mask |= 3 << 5;             /* 12-bit mode */
 346                 data->resolution = 12;
 347                 data->sample_time = MSEC_PER_SEC;
 348                 clr_mask |= 1 << 7;             /* not one-shot mode */
 349                 break;
 350         case tmp112:
 351                 set_mask |= 3 << 5;             /* 12-bit mode */
 352                 clr_mask |= 1 << 7;             /* not one-shot mode */
 353                 data->resolution = 12;
 354                 data->sample_time = MSEC_PER_SEC / 4;
 355                 break;
 356         case tmp105:
 357         case tmp175:
 358         case tmp275:
 359         case tmp75:
 360                 set_mask |= 3 << 5;             /* 12-bit mode */
 361                 clr_mask |= 1 << 7;             /* not one-shot mode */
 362                 data->resolution = 12;
 363                 data->sample_time = MSEC_PER_SEC / 2;
 364                 break;
 365         case tmp75c:
 366                 clr_mask |= 1 << 5;             /* not one-shot mode */
 367                 data->resolution = 12;
 368                 data->sample_time = MSEC_PER_SEC / 4;
 369                 break;
 370         }
 371
 372         /* configure as specified */
 373         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
 374         if (status < 0) {
 375                 dev_dbg(dev, "Can't read config? %d\n", status);
 376                 return status;
 377         }
 378         data->orig_conf = status;
 379         new = status & ~clr_mask;
 380         new |= set_mask;
 381         if (status != new)
 382                 i2c_smbus_write_byte_data(client, LM75_REG_CONF, new);
 383
 384         err = devm_add_action_or_reset(dev, lm75_remove, data);
 385         if (err)
 386                 return err;
 387
 388         dev_dbg(dev, "Config %02x\n", new);
 389
 390         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
 391                                                          data, &lm75_chip_info,
 392                                                          NULL);
 393         if (IS_ERR(hwmon_dev))
 394                 return PTR_ERR(hwmon_dev);
 395
 396         dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
 397
 398         return 0;
 399 }
 400
 401 static const struct i2c_device_id lm75_ids[] = {
 402         { "adt75", adt75, },
 403         { "ds1775", ds1775, },
 404         { "ds75", ds75, },
 405         { "ds7505", ds7505, },
 406         { "g751", g751, },
 407         { "lm75", lm75, },
 408         { "lm75a", lm75a, },
 409         { "lm75b", lm75b, },
 410         { "max6625", max6625, },
 411         { "max6626", max6626, },
 412         { "mcp980x", mcp980x, },
 413         { "stds75", stds75, },
 414         { "tcn75", tcn75, },
 415         { "tmp100", tmp100, },
 416         { "tmp101", tmp101, },
 417         { "tmp105", tmp105, },
 418         { "tmp112", tmp112, },
 419         { "tmp175", tmp175, },
 420         { "tmp275", tmp275, },
 421         { "tmp75", tmp75, },
 422         { "tmp75c", tmp75c, },
 423         { /* LIST END */ }
 424 };
 425 MODULE_DEVICE_TABLE(i2c, lm75_ids);
 426
 427 #define LM75A_ID 0xA1
 428
 429 /* Return 0 if detection is successful, -ENODEV otherwise */
 430 static int lm75_detect(struct i2c_client *new_client,
 431                        struct i2c_board_info *info)
 432 {
 433         struct i2c_adapter *adapter = new_client->adapter;
 434         int i;
 435         int conf, hyst, os;
 436         bool is_lm75a = 0;
 437
 438         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 439                                      I2C_FUNC_SMBUS_WORD_DATA))
 440                 return -ENODEV;
 441
 442         /*
 443          * Now, we do the remaining detection. There is no identification-
 444          * dedicated register so we have to rely on several tricks:
 445          * unused bits, registers cycling over 8-address boundaries,
 446          * addresses 0x04-0x07 returning the last read value.
 447          * The cycling+unused addresses combination is not tested,
 448          * since it would significantly slow the detection down and would
 449          * hardly add any value.
 450          *
 451          * The National Semiconductor LM75A is different than earlier
 452          * LM75s.  It has an ID byte of 0xaX (where X is the chip
 453          * revision, with 1 being the only revision in existence) in
 454          * register 7, and unused registers return 0xff rather than the
 455          * last read value.
 456          *
 457          * Note that this function only detects the original National
 458          * Semiconductor LM75 and the LM75A. Clones from other vendors
 459          * aren't detected, on purpose, because they are typically never
 460          * found on PC hardware. They are found on embedded designs where
 461          * they can be instantiated explicitly so detection is not needed.
 462          * The absence of identification registers on all these clones
 463          * would make their exhaustive detection very difficult and weak,
 464          * and odds are that the driver would bind to unsupported devices.
 465          */
 466
 467         /* Unused bits */
 468         conf = i2c_smbus_read_byte_data(new_client, 1);
 469         if (conf & 0xe0)
 470                 return -ENODEV;
 471
 472         /* First check for LM75A */
 473         if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
 474                 /* LM75A returns 0xff on unused registers so
 475                    just to be sure we check for that too. */
 476                 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
 477                  || i2c_smbus_read_byte_data(new_client, 5) != 0xff
 478                  || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
 479                         return -ENODEV;
 480                 is_lm75a = 1;
 481                 hyst = i2c_smbus_read_byte_data(new_client, 2);
 482                 os = i2c_smbus_read_byte_data(new_client, 3);
 483         } else { /* Traditional style LM75 detection */
 484                 /* Unused addresses */
 485                 hyst = i2c_smbus_read_byte_data(new_client, 2);
 486                 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
 487                  || i2c_smbus_read_byte_data(new_client, 5) != hyst
 488                  || i2c_smbus_read_byte_data(new_client, 6) != hyst
 489                  || i2c_smbus_read_byte_data(new_client, 7) != hyst)
 490                         return -ENODEV;
 491                 os = i2c_smbus_read_byte_data(new_client, 3);
 492                 if (i2c_smbus_read_byte_data(new_client, 4) != os
 493                  || i2c_smbus_read_byte_data(new_client, 5) != os
 494                  || i2c_smbus_read_byte_data(new_client, 6) != os
 495                  || i2c_smbus_read_byte_data(new_client, 7) != os)
 496                         return -ENODEV;
 497         }
 498         /*
 499          * It is very unlikely that this is a LM75 if both
 500          * hysteresis and temperature limit registers are 0.
 501          */
 502         if (hyst == 0 && os == 0)
 503                 return -ENODEV;
 504
 505         /* Addresses cycling */
 506         for (i = 8; i <= 248; i += 40) {
 507                 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
 508                  || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
 509                  || i2c_smbus_read_byte_data(new_client, i + 3) != os)
 510                         return -ENODEV;
 511                 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
 512                                 != LM75A_ID)
 513                         return -ENODEV;
 514         }
 515
 516         strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
 517
 518         return 0;
 519 }
 520
 521 #ifdef CONFIG_PM
 522 static int lm75_suspend(struct device *dev)
 523 {
 524         int status;
 525         struct i2c_client *client = to_i2c_client(dev);
 526         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
 527         if (status < 0) {
 528                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
 529                 return status;
 530         }
 531         status = status | LM75_SHUTDOWN;
 532         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
 533         return 0;
 534 }
 535
 536 static int lm75_resume(struct device *dev)
 537 {
 538         int status;
 539         struct i2c_client *client = to_i2c_client(dev);
 540         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
 541         if (status < 0) {
 542                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
 543                 return status;
 544         }
 545         status = status & ~LM75_SHUTDOWN;
 546         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
 547         return 0;
 548 }
 549
 550 static const struct dev_pm_ops lm75_dev_pm_ops = {
 551         .suspend        = lm75_suspend,
 552         .resume         = lm75_resume,
 553 };
 554 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
 555 #else
 556 #define LM75_DEV_PM_OPS NULL
 557 #endif /* CONFIG_PM */
 558
 559 static struct i2c_driver lm75_driver = {
 560         .class          = I2C_CLASS_HWMON,
 561         .driver = {
 562                 .name   = "lm75",
 563                 .pm     = LM75_DEV_PM_OPS,
 564         },
 565         .probe          = lm75_probe,
 566         .id_table       = lm75_ids,
 567         .detect         = lm75_detect,
 568         .address_list   = normal_i2c,
 569 };
 570
 571 module_i2c_driver(lm75_driver);
 572
 573 MODULE_AUTHOR("Frodo Looijaard <[email protected]>");
 574 MODULE_DESCRIPTION("LM75 driver");
 575 MODULE_LICENSE("GPL");