drivers/hwmon/lm75.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
   4  *       monitoring
   5  * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/init.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/slab.h>
  12 #include <linux/jiffies.h>
  13 #include <linux/i2c.h>
  14 #include <linux/hwmon.h>
  15 #include <linux/err.h>
  16 #include <linux/of.h>
  17 #include <linux/regmap.h>
  18 #include <linux/util_macros.h>
  19 #include <linux/regulator/consumer.h>
  20 #include "lm75.h"
  21
  22 /*
  23  * This driver handles the LM75 and compatible digital temperature sensors.
  24  */
  25
  26 enum lm75_type {                /* keep sorted in alphabetical order */
  27         adt75,
  28         as6200,
  29         at30ts74,
  30         ds1775,
  31         ds75,
  32         ds7505,
  33         g751,
  34         lm75,
  35         lm75a,
  36         lm75b,
  37         max6625,
  38         max6626,
  39         max31725,
  40         mcp980x,
  41         pct2075,
  42         stds75,
  43         stlm75,
  44         tcn75,
  45         tmp100,
  46         tmp101,
  47         tmp105,
  48         tmp112,
  49         tmp175,
  50         tmp275,
  51         tmp75,
  52         tmp75b,
  53         tmp75c,
  54         tmp1075,
  55 };
  56
  57 /**
  58  * struct lm75_params - lm75 configuration parameters.
  59  * @config_reg_16bits:  Configure register size is 2 bytes.
  60  * @set_mask:           Bits to set in configuration register when configuring
  61  *                      the chip.
  62  * @clr_mask:           Bits to clear in configuration register when configuring
  63  *                      the chip.
  64  * @default_resolution: Default number of bits to represent the temperature
  65  *                      value.
  66  * @resolution_limits:  Limit register resolution. Optional. Should be set if
  67  *                      the resolution of limit registers does not match the
  68  *                      resolution of the temperature register.
  69  * @resolutions:        List of resolutions associated with sample times.
  70  *                      Optional. Should be set if num_sample_times is larger
  71  *                      than 1, and if the resolution changes with sample times.
  72  *                      If set, number of entries must match num_sample_times.
  73  * @default_sample_time:Sample time to be set by default.
  74  * @num_sample_times:   Number of possible sample times to be set. Optional.
  75  *                      Should be set if the number of sample times is larger
  76  *                      than one.
  77  * @sample_times:       All the possible sample times to be set. Mandatory if
  78  *                      num_sample_times is larger than 1. If set, number of
  79  *                      entries must match num_sample_times.
  80  * @alarm:              Alarm bit is supported.
  81  */
  82
  83 struct lm75_params {
  84         bool                    config_reg_16bits;
  85         u16                     set_mask;
  86         u16                     clr_mask;
  87         u8                      default_resolution;
  88         u8                      resolution_limits;
  89         const u8                *resolutions;
  90         unsigned int            default_sample_time;
  91         u8                      num_sample_times;
  92         const unsigned int      *sample_times;
  93         bool                    alarm;
  94 };
  95
  96 /* Addresses scanned */
  97 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
  98                                         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
  99
 100 /* The LM75 registers */
 101 #define LM75_REG_TEMP           0x00
 102 #define LM75_REG_CONF           0x01
 103 #define LM75_REG_HYST           0x02
 104 #define LM75_REG_MAX            0x03
 105 #define PCT2075_REG_IDLE        0x04
 106
 107 /* Each client has this additional data */
 108 struct lm75_data {
 109         struct i2c_client               *client;
 110         struct regmap                   *regmap;
 111         struct regulator                *vs;
 112         u16                             orig_conf;
 113         u16                             current_conf;
 114         u8                              resolution;     /* In bits, 9 to 16 */
 115         unsigned int                    sample_time;    /* In ms */
 116         enum lm75_type                  kind;
 117         const struct lm75_params        *params;
 118 };
 119
 120 /*-----------------------------------------------------------------------*/
 121
 122 static const u8 lm75_sample_set_masks[] = { 0 << 5, 1 << 5, 2 << 5, 3 << 5 };
 123
 124 #define LM75_SAMPLE_CLEAR_MASK  (3 << 5)
 125
 126 /* The structure below stores the configuration values of the supported devices.
 127  * In case of being supported multiple configurations, the default one must
 128  * always be the first element of the array
 129  */
 130 static const struct lm75_params device_params[] = {
 131         [adt75] = {
 132                 .clr_mask = 1 << 5,     /* not one-shot mode */
 133                 .default_resolution = 12,
 134                 .default_sample_time = MSEC_PER_SEC / 10,
 135         },
 136         [as6200] = {
 137                 .config_reg_16bits = true,
 138                 .set_mask = 0x94C0,     /* 8 sample/s, 4 CF, positive polarity */
 139                 .default_resolution = 12,
 140                 .default_sample_time = 125,
 141                 .num_sample_times = 4,
 142                 .sample_times = (unsigned int []){ 125, 250, 1000, 4000 },
 143                 .alarm = true,
 144         },
 145         [at30ts74] = {
 146                 .set_mask = 3 << 5,     /* 12-bit mode*/
 147                 .default_resolution = 12,
 148                 .default_sample_time = 200,
 149                 .num_sample_times = 4,
 150                 .sample_times = (unsigned int []){ 25, 50, 100, 200 },
 151                 .resolutions = (u8 []) {9, 10, 11, 12 },
 152         },
 153         [ds1775] = {
 154                 .clr_mask = 3 << 5,
 155                 .set_mask = 2 << 5,     /* 11-bit mode */
 156                 .default_resolution = 11,
 157                 .default_sample_time = 500,
 158                 .num_sample_times = 4,
 159                 .sample_times = (unsigned int []){ 125, 250, 500, 1000 },
 160                 .resolutions = (u8 []) {9, 10, 11, 12 },
 161         },
 162         [ds75] = {
 163                 .clr_mask = 3 << 5,
 164                 .set_mask = 2 << 5,     /* 11-bit mode */
 165                 .default_resolution = 11,
 166                 .default_sample_time = 600,
 167                 .num_sample_times = 4,
 168                 .sample_times = (unsigned int []){ 150, 300, 600, 1200 },
 169                 .resolutions = (u8 []) {9, 10, 11, 12 },
 170         },
 171         [stds75] = {
 172                 .clr_mask = 3 << 5,
 173                 .set_mask = 2 << 5,     /* 11-bit mode */
 174                 .default_resolution = 11,
 175                 .default_sample_time = 600,
 176                 .num_sample_times = 4,
 177                 .sample_times = (unsigned int []){ 150, 300, 600, 1200 },
 178                 .resolutions = (u8 []) {9, 10, 11, 12 },
 179         },
 180         [stlm75] = {
 181                 .default_resolution = 9,
 182                 .default_sample_time = MSEC_PER_SEC / 6,
 183         },
 184         [ds7505] = {
 185                 .set_mask = 3 << 5,     /* 12-bit mode*/
 186                 .default_resolution = 12,
 187                 .default_sample_time = 200,
 188                 .num_sample_times = 4,
 189                 .sample_times = (unsigned int []){ 25, 50, 100, 200 },
 190                 .resolutions = (u8 []) {9, 10, 11, 12 },
 191         },
 192         [g751] = {
 193                 .default_resolution = 9,
 194                 .default_sample_time = MSEC_PER_SEC / 10,
 195         },
 196         [lm75] = {
 197                 .default_resolution = 9,
 198                 .default_sample_time = MSEC_PER_SEC / 10,
 199         },
 200         [lm75a] = {
 201                 .default_resolution = 9,
 202                 .default_sample_time = MSEC_PER_SEC / 10,
 203         },
 204         [lm75b] = {
 205                 .default_resolution = 11,
 206                 .default_sample_time = MSEC_PER_SEC / 10,
 207         },
 208         [max6625] = {
 209                 .default_resolution = 9,
 210                 .default_sample_time = MSEC_PER_SEC / 7,
 211         },
 212         [max6626] = {
 213                 .default_resolution = 12,
 214                 .default_sample_time = MSEC_PER_SEC / 7,
 215                 .resolution_limits = 9,
 216         },
 217         [max31725] = {
 218                 .default_resolution = 16,
 219                 .default_sample_time = MSEC_PER_SEC / 20,
 220         },
 221         [tcn75] = {
 222                 .default_resolution = 9,
 223                 .default_sample_time = MSEC_PER_SEC / 18,
 224         },
 225         [pct2075] = {
 226                 .default_resolution = 11,
 227                 .default_sample_time = MSEC_PER_SEC / 10,
 228                 .num_sample_times = 31,
 229                 .sample_times = (unsigned int []){ 100, 200, 300, 400, 500, 600,
 230                 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700,
 231                 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700,
 232                 2800, 2900, 3000, 3100 },
 233         },
 234         [mcp980x] = {
 235                 .set_mask = 3 << 5,     /* 12-bit mode */
 236                 .clr_mask = 1 << 7,     /* not one-shot mode */
 237                 .default_resolution = 12,
 238                 .resolution_limits = 9,
 239                 .default_sample_time = 240,
 240                 .num_sample_times = 4,
 241                 .sample_times = (unsigned int []){ 30, 60, 120, 240 },
 242                 .resolutions = (u8 []) {9, 10, 11, 12 },
 243         },
 244         [tmp100] = {
 245                 .set_mask = 3 << 5,     /* 12-bit mode */
 246                 .clr_mask = 1 << 7,     /* not one-shot mode */
 247                 .default_resolution = 12,
 248                 .default_sample_time = 320,
 249                 .num_sample_times = 4,
 250                 .sample_times = (unsigned int []){ 40, 80, 160, 320 },
 251                 .resolutions = (u8 []) {9, 10, 11, 12 },
 252         },
 253         [tmp101] = {
 254                 .set_mask = 3 << 5,     /* 12-bit mode */
 255                 .clr_mask = 1 << 7,     /* not one-shot mode */
 256                 .default_resolution = 12,
 257                 .default_sample_time = 320,
 258                 .num_sample_times = 4,
 259                 .sample_times = (unsigned int []){ 40, 80, 160, 320 },
 260                 .resolutions = (u8 []) {9, 10, 11, 12 },
 261         },
 262         [tmp105] = {
 263                 .set_mask = 3 << 5,     /* 12-bit mode */
 264                 .clr_mask = 1 << 7,     /* not one-shot mode*/
 265                 .default_resolution = 12,
 266                 .default_sample_time = 220,
 267                 .num_sample_times = 4,
 268                 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
 269                 .resolutions = (u8 []) {9, 10, 11, 12 },
 270         },
 271         [tmp112] = {
 272                 .config_reg_16bits = true,
 273                 .set_mask = 0x60C0,     /* 12-bit mode, 8 samples / second */
 274                 .clr_mask = 1 << 15,    /* no one-shot mode*/
 275                 .default_resolution = 12,
 276                 .default_sample_time = 125,
 277                 .num_sample_times = 4,
 278                 .sample_times = (unsigned int []){ 125, 250, 1000, 4000 },
 279         },
 280         [tmp175] = {
 281                 .set_mask = 3 << 5,     /* 12-bit mode */
 282                 .clr_mask = 1 << 7,     /* not one-shot mode*/
 283                 .default_resolution = 12,
 284                 .default_sample_time = 220,
 285                 .num_sample_times = 4,
 286                 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
 287                 .resolutions = (u8 []) {9, 10, 11, 12 },
 288         },
 289         [tmp275] = {
 290                 .set_mask = 3 << 5,     /* 12-bit mode */
 291                 .clr_mask = 1 << 7,     /* not one-shot mode*/
 292                 .default_resolution = 12,
 293                 .default_sample_time = 220,
 294                 .num_sample_times = 4,
 295                 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
 296                 .resolutions = (u8 []) {9, 10, 11, 12 },
 297         },
 298         [tmp75] = {
 299                 .set_mask = 3 << 5,     /* 12-bit mode */
 300                 .clr_mask = 1 << 7,     /* not one-shot mode*/
 301                 .default_resolution = 12,
 302                 .default_sample_time = 220,
 303                 .num_sample_times = 4,
 304                 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
 305                 .resolutions = (u8 []) {9, 10, 11, 12 },
 306         },
 307         [tmp75b] = { /* not one-shot mode, Conversion rate 37Hz */
 308                 .clr_mask = 1 << 7 | 3 << 5,
 309                 .default_resolution = 12,
 310                 .default_sample_time = MSEC_PER_SEC / 37,
 311                 .sample_times = (unsigned int []){ MSEC_PER_SEC / 37,
 312                         MSEC_PER_SEC / 18,
 313                         MSEC_PER_SEC / 9, MSEC_PER_SEC / 4 },
 314                 .num_sample_times = 4,
 315         },
 316         [tmp75c] = {
 317                 .clr_mask = 1 << 5,     /*not one-shot mode*/
 318                 .default_resolution = 12,
 319                 .default_sample_time = MSEC_PER_SEC / 12,
 320         },
 321         [tmp1075] = { /* not one-shot mode, 27.5 ms sample rate */
 322                 .clr_mask = 1 << 5 | 1 << 6 | 1 << 7,
 323                 .default_resolution = 12,
 324                 .default_sample_time = 28,
 325                 .num_sample_times = 4,
 326                 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
 327         }
 328 };
 329
 330 static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
 331 {
 332         return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
 333 }
 334
 335 static int lm75_write_config(struct lm75_data *data, u16 set_mask,
 336                              u16 clr_mask)
 337 {
 338         unsigned int value;
 339
 340         clr_mask |= LM75_SHUTDOWN << (8 * data->params->config_reg_16bits);
 341         value = data->current_conf & ~clr_mask;
 342         value |= set_mask;
 343
 344         if (data->current_conf != value) {
 345                 s32 err;
 346                 if (data->params->config_reg_16bits)
 347                         err = regmap_write(data->regmap, LM75_REG_CONF, value);
 348                 else
 349                         err = i2c_smbus_write_byte_data(data->client,
 350                                                         LM75_REG_CONF,
 351                                                         value);
 352                 if (err)
 353                         return err;
 354                 data->current_conf = value;
 355         }
 356         return 0;
 357 }
 358
 359 static int lm75_read_config(struct lm75_data *data)
 360 {
 361         int ret;
 362         unsigned int status;
 363
 364         if (data->params->config_reg_16bits) {
 365                 ret = regmap_read(data->regmap, LM75_REG_CONF, &status);
 366                 return ret ? ret : status;
 367         }
 368
 369         return i2c_smbus_read_byte_data(data->client, LM75_REG_CONF);
 370 }
 371
 372 static irqreturn_t lm75_alarm_handler(int irq, void *private)
 373 {
 374         struct device *hwmon_dev = private;
 375
 376         hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_alarm, 0);
 377         return IRQ_HANDLED;
 378 }
 379
 380 static int lm75_read(struct device *dev, enum hwmon_sensor_types type,
 381                      u32 attr, int channel, long *val)
 382 {
 383         struct lm75_data *data = dev_get_drvdata(dev);
 384         unsigned int regval;
 385         int err, reg;
 386
 387         switch (type) {
 388         case hwmon_chip:
 389                 switch (attr) {
 390                 case hwmon_chip_update_interval:
 391                         *val = data->sample_time;
 392                         break;
 393                 default:
 394                         return -EINVAL;
 395                 }
 396                 break;
 397         case hwmon_temp:
 398                 switch (attr) {
 399                 case hwmon_temp_input:
 400                         reg = LM75_REG_TEMP;
 401                         break;
 402                 case hwmon_temp_max:
 403                         reg = LM75_REG_MAX;
 404                         break;
 405                 case hwmon_temp_max_hyst:
 406                         reg = LM75_REG_HYST;
 407                         break;
 408                 case hwmon_temp_alarm:
 409                         reg = LM75_REG_CONF;
 410                         break;
 411                 default:
 412                         return -EINVAL;
 413                 }
 414                 err = regmap_read(data->regmap, reg, &regval);
 415                 if (err < 0)
 416                         return err;
 417
 418                 if (attr == hwmon_temp_alarm) {
 419                         switch (data->kind) {
 420                         case as6200:
 421                                 *val = (regval >> 5) & 0x1;
 422                                 break;
 423                         default:
 424                                 return -EINVAL;
 425                         }
 426                 } else {
 427                         *val = lm75_reg_to_mc(regval, data->resolution);
 428                 }
 429                 break;
 430         default:
 431                 return -EINVAL;
 432         }
 433         return 0;
 434 }
 435
 436 static int lm75_write_temp(struct device *dev, u32 attr, long temp)
 437 {
 438         struct lm75_data *data = dev_get_drvdata(dev);
 439         u8 resolution;
 440         int reg;
 441
 442         switch (attr) {
 443         case hwmon_temp_max:
 444                 reg = LM75_REG_MAX;
 445                 break;
 446         case hwmon_temp_max_hyst:
 447                 reg = LM75_REG_HYST;
 448                 break;
 449         default:
 450                 return -EINVAL;
 451         }
 452
 453         /*
 454          * Resolution of limit registers is assumed to be the same as the
 455          * temperature input register resolution unless given explicitly.
 456          */
 457         if (data->params->resolution_limits)
 458                 resolution = data->params->resolution_limits;
 459         else
 460                 resolution = data->resolution;
 461
 462         temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
 463         temp = DIV_ROUND_CLOSEST(temp  << (resolution - 8),
 464                                  1000) << (16 - resolution);
 465
 466         return regmap_write(data->regmap, reg, (u16)temp);
 467 }
 468
 469 static int lm75_update_interval(struct device *dev, long val)
 470 {
 471         struct lm75_data *data = dev_get_drvdata(dev);
 472         unsigned int reg;
 473         u8 index;
 474         s32 err;
 475
 476         index = find_closest(val, data->params->sample_times,
 477                              (int)data->params->num_sample_times);
 478
 479         switch (data->kind) {
 480         default:
 481                 err = lm75_write_config(data, lm75_sample_set_masks[index],
 482                                         LM75_SAMPLE_CLEAR_MASK);
 483                 if (err)
 484                         return err;
 485
 486                 data->sample_time = data->params->sample_times[index];
 487                 if (data->params->resolutions)
 488                         data->resolution = data->params->resolutions[index];
 489                 break;
 490         case tmp112:
 491         case as6200:
 492                 err = regmap_read(data->regmap, LM75_REG_CONF, &reg);
 493                 if (err < 0)
 494                         return err;
 495                 reg &= ~0x00c0;
 496                 reg |= (3 - index) << 6;
 497                 err = regmap_write(data->regmap, LM75_REG_CONF, reg);
 498                 if (err < 0)
 499                         return err;
 500                 data->sample_time = data->params->sample_times[index];
 501                 break;
 502         case pct2075:
 503                 err = i2c_smbus_write_byte_data(data->client, PCT2075_REG_IDLE,
 504                                                 index + 1);
 505                 if (err)
 506                         return err;
 507                 data->sample_time = data->params->sample_times[index];
 508                 break;
 509         }
 510         return 0;
 511 }
 512
 513 static int lm75_write_chip(struct device *dev, u32 attr, long val)
 514 {
 515         switch (attr) {
 516         case hwmon_chip_update_interval:
 517                 return lm75_update_interval(dev, val);
 518         default:
 519                 return -EINVAL;
 520         }
 521         return 0;
 522 }
 523
 524 static int lm75_write(struct device *dev, enum hwmon_sensor_types type,
 525                       u32 attr, int channel, long val)
 526 {
 527         switch (type) {
 528         case hwmon_chip:
 529                 return lm75_write_chip(dev, attr, val);
 530         case hwmon_temp:
 531                 return lm75_write_temp(dev, attr, val);
 532         default:
 533                 return -EINVAL;
 534         }
 535         return 0;
 536 }
 537
 538 static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type,
 539                                u32 attr, int channel)
 540 {
 541         const struct lm75_data *config_data = data;
 542
 543         switch (type) {
 544         case hwmon_chip:
 545                 switch (attr) {
 546                 case hwmon_chip_update_interval:
 547                         if (config_data->params->num_sample_times > 1)
 548                                 return 0644;
 549                         return 0444;
 550                 }
 551                 break;
 552         case hwmon_temp:
 553                 switch (attr) {
 554                 case hwmon_temp_input:
 555                         return 0444;
 556                 case hwmon_temp_max:
 557                 case hwmon_temp_max_hyst:
 558                         return 0644;
 559                 case hwmon_temp_alarm:
 560                         if (config_data->params->alarm)
 561                                 return 0444;
 562                         break;
 563                 }
 564                 break;
 565         default:
 566                 break;
 567         }
 568         return 0;
 569 }
 570
 571 static const struct hwmon_channel_info * const lm75_info[] = {
 572         HWMON_CHANNEL_INFO(chip,
 573                            HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
 574         HWMON_CHANNEL_INFO(temp,
 575                            HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
 576                            HWMON_T_ALARM),
 577         NULL
 578 };
 579
 580 static const struct hwmon_ops lm75_hwmon_ops = {
 581         .is_visible = lm75_is_visible,
 582         .read = lm75_read,
 583         .write = lm75_write,
 584 };
 585
 586 static const struct hwmon_chip_info lm75_chip_info = {
 587         .ops = &lm75_hwmon_ops,
 588         .info = lm75_info,
 589 };
 590
 591 static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
 592 {
 593         return reg != LM75_REG_TEMP;
 594 }
 595
 596 static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg)
 597 {
 598         return reg == LM75_REG_TEMP || reg == LM75_REG_CONF;
 599 }
 600
 601 static const struct regmap_config lm75_regmap_config = {
 602         .reg_bits = 8,
 603         .val_bits = 16,
 604         .max_register = PCT2075_REG_IDLE,
 605         .writeable_reg = lm75_is_writeable_reg,
 606         .volatile_reg = lm75_is_volatile_reg,
 607         .val_format_endian = REGMAP_ENDIAN_BIG,
 608         .cache_type = REGCACHE_MAPLE,
 609         .use_single_read = true,
 610         .use_single_write = true,
 611 };
 612
 613 static void lm75_disable_regulator(void *data)
 614 {
 615         struct lm75_data *lm75 = data;
 616
 617         regulator_disable(lm75->vs);
 618 }
 619
 620 static void lm75_remove(void *data)
 621 {
 622         struct lm75_data *lm75 = data;
 623         struct i2c_client *client = lm75->client;
 624
 625         i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
 626 }
 627
 628 static const struct i2c_device_id lm75_ids[];
 629
 630 static int lm75_probe(struct i2c_client *client)
 631 {
 632         struct device *dev = &client->dev;
 633         struct device *hwmon_dev;
 634         struct lm75_data *data;
 635         int status, err;
 636         enum lm75_type kind;
 637
 638         if (client->dev.of_node)
 639                 kind = (uintptr_t)of_device_get_match_data(&client->dev);
 640         else
 641                 kind = i2c_match_id(lm75_ids, client)->driver_data;
 642
 643         if (!i2c_check_functionality(client->adapter,
 644                         I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
 645                 return -EIO;
 646
 647         data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL);
 648         if (!data)
 649                 return -ENOMEM;
 650
 651         data->client = client;
 652         data->kind = kind;
 653
 654         data->vs = devm_regulator_get(dev, "vs");
 655         if (IS_ERR(data->vs))
 656                 return PTR_ERR(data->vs);
 657
 658         data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
 659         if (IS_ERR(data->regmap))
 660                 return PTR_ERR(data->regmap);
 661
 662         /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
 663          * Then tweak to be more precise when appropriate.
 664          */
 665
 666         data->params = &device_params[data->kind];
 667
 668         /* Save default sample time and resolution*/
 669         data->sample_time = data->params->default_sample_time;
 670         data->resolution = data->params->default_resolution;
 671
 672         /* Enable the power */
 673         err = regulator_enable(data->vs);
 674         if (err) {
 675                 dev_err(dev, "failed to enable regulator: %d\n", err);
 676                 return err;
 677         }
 678
 679         err = devm_add_action_or_reset(dev, lm75_disable_regulator, data);
 680         if (err)
 681                 return err;
 682
 683         /* Cache original configuration */
 684         status = lm75_read_config(data);
 685         if (status < 0) {
 686                 dev_dbg(dev, "Can't read config? %d\n", status);
 687                 return status;
 688         }
 689         data->orig_conf = status;
 690         data->current_conf = status;
 691
 692         err = lm75_write_config(data, data->params->set_mask,
 693                                 data->params->clr_mask);
 694         if (err)
 695                 return err;
 696
 697         err = devm_add_action_or_reset(dev, lm75_remove, data);
 698         if (err)
 699                 return err;
 700
 701         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
 702                                                          data, &lm75_chip_info,
 703                                                          NULL);
 704         if (IS_ERR(hwmon_dev))
 705                 return PTR_ERR(hwmon_dev);
 706
 707         if (client->irq) {
 708                 if (data->params->alarm) {
 709                         err = devm_request_threaded_irq(dev,
 710                                                         client->irq,
 711                                                         NULL,
 712                                                         &lm75_alarm_handler,
 713                                                         IRQF_ONESHOT,
 714                                                         client->name,
 715                                                         hwmon_dev);
 716                         if (err)
 717                                 return err;
 718                 } else {
 719                          /* alarm is only supported for chips with alarm bit */
 720                         dev_err(dev, "alarm interrupt is not supported\n");
 721                 }
 722         }
 723
 724         dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
 725
 726         return 0;
 727 }
 728
 729 static const struct i2c_device_id lm75_ids[] = {
 730         { "adt75", adt75, },
 731         { "as6200", as6200, },
 732         { "at30ts74", at30ts74, },
 733         { "ds1775", ds1775, },
 734         { "ds75", ds75, },
 735         { "ds7505", ds7505, },
 736         { "g751", g751, },
 737         { "lm75", lm75, },
 738         { "lm75a", lm75a, },
 739         { "lm75b", lm75b, },
 740         { "max6625", max6625, },
 741         { "max6626", max6626, },
 742         { "max31725", max31725, },
 743         { "max31726", max31725, },
 744         { "mcp980x", mcp980x, },
 745         { "pct2075", pct2075, },
 746         { "stds75", stds75, },
 747         { "stlm75", stlm75, },
 748         { "tcn75", tcn75, },
 749         { "tmp100", tmp100, },
 750         { "tmp101", tmp101, },
 751         { "tmp105", tmp105, },
 752         { "tmp112", tmp112, },
 753         { "tmp175", tmp175, },
 754         { "tmp275", tmp275, },
 755         { "tmp75", tmp75, },
 756         { "tmp75b", tmp75b, },
 757         { "tmp75c", tmp75c, },
 758         { "tmp1075", tmp1075, },
 759         { /* LIST END */ }
 760 };
 761 MODULE_DEVICE_TABLE(i2c, lm75_ids);
 762
 763 static const struct of_device_id __maybe_unused lm75_of_match[] = {
 764         {
 765                 .compatible = "adi,adt75",
 766                 .data = (void *)adt75
 767         },
 768         {
 769                 .compatible = "ams,as6200",
 770                 .data = (void *)as6200
 771         },
 772         {
 773                 .compatible = "atmel,at30ts74",
 774                 .data = (void *)at30ts74
 775         },
 776         {
 777                 .compatible = "dallas,ds1775",
 778                 .data = (void *)ds1775
 779         },
 780         {
 781                 .compatible = "dallas,ds75",
 782                 .data = (void *)ds75
 783         },
 784         {
 785                 .compatible = "dallas,ds7505",
 786                 .data = (void *)ds7505
 787         },
 788         {
 789                 .compatible = "gmt,g751",
 790                 .data = (void *)g751
 791         },
 792         {
 793                 .compatible = "national,lm75",
 794                 .data = (void *)lm75
 795         },
 796         {
 797                 .compatible = "national,lm75a",
 798                 .data = (void *)lm75a
 799         },
 800         {
 801                 .compatible = "national,lm75b",
 802                 .data = (void *)lm75b
 803         },
 804         {
 805                 .compatible = "maxim,max6625",
 806                 .data = (void *)max6625
 807         },
 808         {
 809                 .compatible = "maxim,max6626",
 810                 .data = (void *)max6626
 811         },
 812         {
 813                 .compatible = "maxim,max31725",
 814                 .data = (void *)max31725
 815         },
 816         {
 817                 .compatible = "maxim,max31726",
 818                 .data = (void *)max31725
 819         },
 820         {
 821                 .compatible = "maxim,mcp980x",
 822                 .data = (void *)mcp980x
 823         },
 824         {
 825                 .compatible = "nxp,pct2075",
 826                 .data = (void *)pct2075
 827         },
 828         {
 829                 .compatible = "st,stds75",
 830                 .data = (void *)stds75
 831         },
 832         {
 833                 .compatible = "st,stlm75",
 834                 .data = (void *)stlm75
 835         },
 836         {
 837                 .compatible = "microchip,tcn75",
 838                 .data = (void *)tcn75
 839         },
 840         {
 841                 .compatible = "ti,tmp100",
 842                 .data = (void *)tmp100
 843         },
 844         {
 845                 .compatible = "ti,tmp101",
 846                 .data = (void *)tmp101
 847         },
 848         {
 849                 .compatible = "ti,tmp105",
 850                 .data = (void *)tmp105
 851         },
 852         {
 853                 .compatible = "ti,tmp112",
 854                 .data = (void *)tmp112
 855         },
 856         {
 857                 .compatible = "ti,tmp175",
 858                 .data = (void *)tmp175
 859         },
 860         {
 861                 .compatible = "ti,tmp275",
 862                 .data = (void *)tmp275
 863         },
 864         {
 865                 .compatible = "ti,tmp75",
 866                 .data = (void *)tmp75
 867         },
 868         {
 869                 .compatible = "ti,tmp75b",
 870                 .data = (void *)tmp75b
 871         },
 872         {
 873                 .compatible = "ti,tmp75c",
 874                 .data = (void *)tmp75c
 875         },
 876         {
 877                 .compatible = "ti,tmp1075",
 878                 .data = (void *)tmp1075
 879         },
 880         { },
 881 };
 882 MODULE_DEVICE_TABLE(of, lm75_of_match);
 883
 884 #define LM75A_ID 0xA1
 885
 886 /* Return 0 if detection is successful, -ENODEV otherwise */
 887 static int lm75_detect(struct i2c_client *new_client,
 888                        struct i2c_board_info *info)
 889 {
 890         struct i2c_adapter *adapter = new_client->adapter;
 891         int i;
 892         int conf, hyst, os;
 893         bool is_lm75a = 0;
 894
 895         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 896                                      I2C_FUNC_SMBUS_WORD_DATA))
 897                 return -ENODEV;
 898
 899         /*
 900          * Now, we do the remaining detection. There is no identification-
 901          * dedicated register so we have to rely on several tricks:
 902          * unused bits, registers cycling over 8-address boundaries,
 903          * addresses 0x04-0x07 returning the last read value.
 904          * The cycling+unused addresses combination is not tested,
 905          * since it would significantly slow the detection down and would
 906          * hardly add any value.
 907          *
 908          * The National Semiconductor LM75A is different than earlier
 909          * LM75s.  It has an ID byte of 0xaX (where X is the chip
 910          * revision, with 1 being the only revision in existence) in
 911          * register 7, and unused registers return 0xff rather than the
 912          * last read value.
 913          *
 914          * Note that this function only detects the original National
 915          * Semiconductor LM75 and the LM75A. Clones from other vendors
 916          * aren't detected, on purpose, because they are typically never
 917          * found on PC hardware. They are found on embedded designs where
 918          * they can be instantiated explicitly so detection is not needed.
 919          * The absence of identification registers on all these clones
 920          * would make their exhaustive detection very difficult and weak,
 921          * and odds are that the driver would bind to unsupported devices.
 922          */
 923
 924         /* Unused bits */
 925         conf = i2c_smbus_read_byte_data(new_client, 1);
 926         if (conf & 0xe0)
 927                 return -ENODEV;
 928
 929         /* First check for LM75A */
 930         if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
 931                 /*
 932                  * LM75A returns 0xff on unused registers so
 933                  * just to be sure we check for that too.
 934                  */
 935                 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
 936                  || i2c_smbus_read_byte_data(new_client, 5) != 0xff
 937                  || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
 938                         return -ENODEV;
 939                 is_lm75a = 1;
 940                 hyst = i2c_smbus_read_byte_data(new_client, 2);
 941                 os = i2c_smbus_read_byte_data(new_client, 3);
 942         } else { /* Traditional style LM75 detection */
 943                 /* Unused addresses */
 944                 hyst = i2c_smbus_read_byte_data(new_client, 2);
 945                 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
 946                  || i2c_smbus_read_byte_data(new_client, 5) != hyst
 947                  || i2c_smbus_read_byte_data(new_client, 6) != hyst
 948                  || i2c_smbus_read_byte_data(new_client, 7) != hyst)
 949                         return -ENODEV;
 950                 os = i2c_smbus_read_byte_data(new_client, 3);
 951                 if (i2c_smbus_read_byte_data(new_client, 4) != os
 952                  || i2c_smbus_read_byte_data(new_client, 5) != os
 953                  || i2c_smbus_read_byte_data(new_client, 6) != os
 954                  || i2c_smbus_read_byte_data(new_client, 7) != os)
 955                         return -ENODEV;
 956         }
 957         /*
 958          * It is very unlikely that this is a LM75 if both
 959          * hysteresis and temperature limit registers are 0.
 960          */
 961         if (hyst == 0 && os == 0)
 962                 return -ENODEV;
 963
 964         /* Addresses cycling */
 965         for (i = 8; i <= 248; i += 40) {
 966                 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
 967                  || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
 968                  || i2c_smbus_read_byte_data(new_client, i + 3) != os)
 969                         return -ENODEV;
 970                 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
 971                                 != LM75A_ID)
 972                         return -ENODEV;
 973         }
 974
 975         strscpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
 976
 977         return 0;
 978 }
 979
 980 #ifdef CONFIG_PM
 981 static int lm75_suspend(struct device *dev)
 982 {
 983         int status;
 984         struct i2c_client *client = to_i2c_client(dev);
 985
 986         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
 987         if (status < 0) {
 988                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
 989                 return status;
 990         }
 991         status = status | LM75_SHUTDOWN;
 992         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
 993         return 0;
 994 }
 995
 996 static int lm75_resume(struct device *dev)
 997 {
 998         int status;
 999         struct i2c_client *client = to_i2c_client(dev);
1000
1001         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
1002         if (status < 0) {
1003                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
1004                 return status;
1005         }
1006         status = status & ~LM75_SHUTDOWN;
1007         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
1008         return 0;
1009 }
1010
1011 static const struct dev_pm_ops lm75_dev_pm_ops = {
1012         .suspend        = lm75_suspend,
1013         .resume         = lm75_resume,
1014 };
1015 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
1016 #else
1017 #define LM75_DEV_PM_OPS NULL
1018 #endif /* CONFIG_PM */
1019
1020 static struct i2c_driver lm75_driver = {
1021         .class          = I2C_CLASS_HWMON,
1022         .driver = {
1023                 .name   = "lm75",
1024                 .of_match_table = of_match_ptr(lm75_of_match),
1025                 .pm     = LM75_DEV_PM_OPS,
1026         },
1027         .probe          = lm75_probe,
1028         .id_table       = lm75_ids,
1029         .detect         = lm75_detect,
1030         .address_list   = normal_i2c,
1031 };
1032
1033 module_i2c_driver(lm75_driver);
1034
1035 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1036 MODULE_DESCRIPTION("LM75 driver");
1037 MODULE_LICENSE("GPL");