drivers/hwmon/lm90.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
   4  *          monitoring
   5  * Copyright (C) 2003-2010  Jean Delvare <jdelvare@suse.de>
   6  *
   7  * Based on the lm83 driver. The LM90 is a sensor chip made by National
   8  * Semiconductor. It reports up to two temperatures (its own plus up to
   9  * one external one) with a 0.125 deg resolution (1 deg for local
  10  * temperature) and a 3-4 deg accuracy.
  11  *
  12  * This driver also supports the LM89 and LM99, two other sensor chips
  13  * made by National Semiconductor. Both have an increased remote
  14  * temperature measurement accuracy (1 degree), and the LM99
  15  * additionally shifts remote temperatures (measured and limits) by 16
  16  * degrees, which allows for higher temperatures measurement.
  17  * Note that there is no way to differentiate between both chips.
  18  * When device is auto-detected, the driver will assume an LM99.
  19  *
  20  * This driver also supports the LM86, another sensor chip made by
  21  * National Semiconductor. It is exactly similar to the LM90 except it
  22  * has a higher accuracy.
  23  *
  24  * This driver also supports the ADM1032, a sensor chip made by Analog
  25  * Devices. That chip is similar to the LM90, with a few differences
  26  * that are not handled by this driver. Among others, it has a higher
  27  * accuracy than the LM90, much like the LM86 does.
  28  *
  29  * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
  30  * chips made by Maxim. These chips are similar to the LM86.
  31  * Note that there is no easy way to differentiate between the three
  32  * variants. We use the device address to detect MAX6659, which will result
  33  * in a detection as max6657 if it is on address 0x4c. The extra address
  34  * and features of the MAX6659 are only supported if the chip is configured
  35  * explicitly as max6659, or if its address is not 0x4c.
  36  * These chips lack the remote temperature offset feature.
  37  *
  38  * This driver also supports the MAX6654 chip made by Maxim. This chip can be
  39  * at 9 different addresses, similar to MAX6680/MAX6681. The MAX6654 is similar
  40  * to MAX6657/MAX6658/MAX6659, but does not support critical temperature
  41  * limits. Extended range is available by setting the configuration register
  42  * accordingly, and is done during initialization. Extended precision is only
  43  * available at conversion rates of 1 Hz and slower. Note that extended
  44  * precision is not enabled by default, as this driver initializes all chips
  45  * to 2 Hz by design. The driver also supports MAX6690, which is practically
  46  * identical to MAX6654.
  47  *
  48  * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
  49  * MAX6692 chips made by Maxim.  These are again similar to the LM86,
  50  * but they use unsigned temperature values and can report temperatures
  51  * from 0 to 145 degrees.
  52  *
  53  * This driver also supports the MAX6680 and MAX6681, two other sensor
  54  * chips made by Maxim. These are quite similar to the other Maxim
  55  * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
  56  * be treated identically.
  57  *
  58  * This driver also supports the MAX6695 and MAX6696, two other sensor
  59  * chips made by Maxim. These are also quite similar to other Maxim
  60  * chips, but support three temperature sensors instead of two. MAX6695
  61  * and MAX6696 only differ in the pinout so they can be treated identically.
  62  *
  63  * This driver also supports ADT7461 and ADT7461A from Analog Devices as well as
  64  * NCT1008 from ON Semiconductor. The chips are supported in both compatibility
  65  * and extended mode. They are mostly compatible with LM90 except for a data
  66  * format difference for the temperature value registers.
  67  *
  68  * This driver also supports ADT7481, ADT7482, and ADT7483 from Analog Devices
  69  * / ON Semiconductor. The chips are similar to ADT7461 but support two external
  70  * temperature sensors.
  71  *
  72  * This driver also supports NCT72, NCT214, and NCT218 from ON Semiconductor.
  73  * The chips are similar to ADT7461/ADT7461A but have full PEC support
  74  * (undocumented).
  75  *
  76  * This driver also supports the SA56004 from Philips. This device is
  77  * pin-compatible with the LM86, the ED/EDP parts are also address-compatible.
  78  *
  79  * This driver also supports the G781 from GMT. This device is compatible
  80  * with the ADM1032.
  81  *
  82  * This driver also supports TMP451 and TMP461 from Texas Instruments.
  83  * Those devices are supported in both compatibility and extended mode.
  84  * They are mostly compatible with ADT7461 except for local temperature
  85  * low byte register and max conversion rate.
  86  *
  87  * This driver also supports MAX1617 and various clones such as G767
  88  * and NE1617. Such clones will be detected as MAX1617.
  89  *
  90  * This driver also supports NE1618 from Philips. It is similar to NE1617
  91  * but supports 11 bit external temperature values.
  92  *
  93  * Since the LM90 was the first chipset supported by this driver, most
  94  * comments will refer to this chipset, but are actually general and
  95  * concern all supported chipsets, unless mentioned otherwise.
  96  */
  97
  98 #include <linux/bits.h>
  99 #include <linux/device.h>
 100 #include <linux/err.h>
 101 #include <linux/i2c.h>
 102 #include <linux/init.h>
 103 #include <linux/interrupt.h>
 104 #include <linux/jiffies.h>
 105 #include <linux/hwmon.h>
 106 #include <linux/kstrtox.h>
 107 #include <linux/module.h>
 108 #include <linux/mutex.h>
 109 #include <linux/of.h>
 110 #include <linux/regulator/consumer.h>
 111 #include <linux/slab.h>
 112 #include <linux/workqueue.h>
 113
 114 /* The maximum number of channels currently supported */
 115 #define MAX_CHANNELS    3
 116
 117 /*
 118  * Addresses to scan
 119  * Address is fully defined internally and cannot be changed except for
 120  * MAX6659, MAX6680 and MAX6681.
 121  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649,
 122  * MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c.
 123  * ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D
 124  * have address 0x4d.
 125  * MAX6647 has address 0x4e.
 126  * MAX6659 can have address 0x4c, 0x4d or 0x4e.
 127  * MAX6654, MAX6680, and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29,
 128  * 0x2a, 0x2b, 0x4c, 0x4d or 0x4e.
 129  * SA56004 can have address 0x48 through 0x4F.
 130  */
 131
 132 static const unsigned short normal_i2c[] = {
 133         0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
 134         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 135
 136 enum chips { adm1023, adm1032, adt7461, adt7461a, adt7481,
 137         g781, lm84, lm90, lm99,
 138         max1617, max6642, max6646, max6648, max6654, max6657, max6659, max6680, max6696,
 139         nct210, nct72, ne1618, sa56004, tmp451, tmp461, w83l771,
 140 };
 141
 142 /*
 143  * The LM90 registers
 144  */
 145
 146 #define LM90_REG_MAN_ID                 0xFE
 147 #define LM90_REG_CHIP_ID                0xFF
 148 #define LM90_REG_CONFIG1                0x03
 149 #define LM90_REG_CONFIG2                0xBF
 150 #define LM90_REG_CONVRATE               0x04
 151 #define LM90_REG_STATUS                 0x02
 152 #define LM90_REG_LOCAL_TEMP             0x00
 153 #define LM90_REG_LOCAL_HIGH             0x05
 154 #define LM90_REG_LOCAL_LOW              0x06
 155 #define LM90_REG_LOCAL_CRIT             0x20
 156 #define LM90_REG_REMOTE_TEMPH           0x01
 157 #define LM90_REG_REMOTE_TEMPL           0x10
 158 #define LM90_REG_REMOTE_OFFSH           0x11
 159 #define LM90_REG_REMOTE_OFFSL           0x12
 160 #define LM90_REG_REMOTE_HIGHH           0x07
 161 #define LM90_REG_REMOTE_HIGHL           0x13
 162 #define LM90_REG_REMOTE_LOWH            0x08
 163 #define LM90_REG_REMOTE_LOWL            0x14
 164 #define LM90_REG_REMOTE_CRIT            0x19
 165 #define LM90_REG_TCRIT_HYST             0x21
 166
 167 /* MAX6646/6647/6649/6654/6657/6658/6659/6695/6696 registers */
 168
 169 #define MAX6657_REG_LOCAL_TEMPL         0x11
 170 #define MAX6696_REG_STATUS2             0x12
 171 #define MAX6659_REG_REMOTE_EMERG        0x16
 172 #define MAX6659_REG_LOCAL_EMERG         0x17
 173
 174 /*  SA56004 registers */
 175
 176 #define SA56004_REG_LOCAL_TEMPL         0x22
 177
 178 #define LM90_MAX_CONVRATE_MS    16000   /* Maximum conversion rate in ms */
 179
 180 /* TMP451/TMP461 registers */
 181 #define TMP451_REG_LOCAL_TEMPL          0x15
 182 #define TMP451_REG_CONALERT             0x22
 183
 184 #define TMP461_REG_CHEN                 0x16
 185 #define TMP461_REG_DFC                  0x24
 186
 187 /* ADT7481 registers */
 188 #define ADT7481_REG_STATUS2             0x23
 189 #define ADT7481_REG_CONFIG2             0x24
 190
 191 #define ADT7481_REG_MAN_ID              0x3e
 192 #define ADT7481_REG_CHIP_ID             0x3d
 193
 194 /* Device features */
 195 #define LM90_HAVE_EXTENDED_TEMP BIT(0)  /* extended temperature support */
 196 #define LM90_HAVE_OFFSET        BIT(1)  /* temperature offset register  */
 197 #define LM90_HAVE_UNSIGNED_TEMP BIT(2)  /* temperatures are unsigned    */
 198 #define LM90_HAVE_REM_LIMIT_EXT BIT(3)  /* extended remote limit        */
 199 #define LM90_HAVE_EMERGENCY     BIT(4)  /* 3rd upper (emergency) limit  */
 200 #define LM90_HAVE_EMERGENCY_ALARM BIT(5)/* emergency alarm              */
 201 #define LM90_HAVE_TEMP3         BIT(6)  /* 3rd temperature sensor       */
 202 #define LM90_HAVE_BROKEN_ALERT  BIT(7)  /* Broken alert                 */
 203 #define LM90_PAUSE_FOR_CONFIG   BIT(8)  /* Pause conversion for config  */
 204 #define LM90_HAVE_CRIT          BIT(9)  /* Chip supports CRIT/OVERT register    */
 205 #define LM90_HAVE_CRIT_ALRM_SWP BIT(10) /* critical alarm bits swapped  */
 206 #define LM90_HAVE_PEC           BIT(11) /* Chip supports PEC            */
 207 #define LM90_HAVE_PARTIAL_PEC   BIT(12) /* Partial PEC support (adm1032)*/
 208 #define LM90_HAVE_ALARMS        BIT(13) /* Create 'alarms' attribute    */
 209 #define LM90_HAVE_EXT_UNSIGNED  BIT(14) /* extended unsigned temperature*/
 210 #define LM90_HAVE_LOW           BIT(15) /* low limits                   */
 211 #define LM90_HAVE_CONVRATE      BIT(16) /* conversion rate              */
 212 #define LM90_HAVE_REMOTE_EXT    BIT(17) /* extended remote temperature  */
 213 #define LM90_HAVE_FAULTQUEUE    BIT(18) /* configurable samples count   */
 214
 215 /* LM90 status */
 216 #define LM90_STATUS_LTHRM       BIT(0)  /* local THERM limit tripped */
 217 #define LM90_STATUS_RTHRM       BIT(1)  /* remote THERM limit tripped */
 218 #define LM90_STATUS_ROPEN       BIT(2)  /* remote is an open circuit */
 219 #define LM90_STATUS_RLOW        BIT(3)  /* remote low temp limit tripped */
 220 #define LM90_STATUS_RHIGH       BIT(4)  /* remote high temp limit tripped */
 221 #define LM90_STATUS_LLOW        BIT(5)  /* local low temp limit tripped */
 222 #define LM90_STATUS_LHIGH       BIT(6)  /* local high temp limit tripped */
 223 #define LM90_STATUS_BUSY        BIT(7)  /* conversion is ongoing */
 224
 225 /* MAX6695/6696 and ADT7481 2nd status register */
 226 #define MAX6696_STATUS2_R2THRM  BIT(1)  /* remote2 THERM limit tripped */
 227 #define MAX6696_STATUS2_R2OPEN  BIT(2)  /* remote2 is an open circuit */
 228 #define MAX6696_STATUS2_R2LOW   BIT(3)  /* remote2 low temp limit tripped */
 229 #define MAX6696_STATUS2_R2HIGH  BIT(4)  /* remote2 high temp limit tripped */
 230 #define MAX6696_STATUS2_ROT2    BIT(5)  /* remote emergency limit tripped */
 231 #define MAX6696_STATUS2_R2OT2   BIT(6)  /* remote2 emergency limit tripped */
 232 #define MAX6696_STATUS2_LOT2    BIT(7)  /* local emergency limit tripped */
 233
 234 /*
 235  * Driver data (common to all clients)
 236  */
 237
 238 static const struct i2c_device_id lm90_id[] = {
 239         { "adm1020", max1617 },
 240         { "adm1021", max1617 },
 241         { "adm1023", adm1023 },
 242         { "adm1032", adm1032 },
 243         { "adt7421", adt7461a },
 244         { "adt7461", adt7461 },
 245         { "adt7461a", adt7461a },
 246         { "adt7481", adt7481 },
 247         { "adt7482", adt7481 },
 248         { "adt7483a", adt7481 },
 249         { "g781", g781 },
 250         { "gl523sm", max1617 },
 251         { "lm84", lm84 },
 252         { "lm86", lm90 },
 253         { "lm89", lm90 },
 254         { "lm90", lm90 },
 255         { "lm99", lm99 },
 256         { "max1617", max1617 },
 257         { "max6642", max6642 },
 258         { "max6646", max6646 },
 259         { "max6647", max6646 },
 260         { "max6648", max6648 },
 261         { "max6649", max6646 },
 262         { "max6654", max6654 },
 263         { "max6657", max6657 },
 264         { "max6658", max6657 },
 265         { "max6659", max6659 },
 266         { "max6680", max6680 },
 267         { "max6681", max6680 },
 268         { "max6690", max6654 },
 269         { "max6692", max6648 },
 270         { "max6695", max6696 },
 271         { "max6696", max6696 },
 272         { "mc1066", max1617 },
 273         { "nct1008", adt7461a },
 274         { "nct210", nct210 },
 275         { "nct214", nct72 },
 276         { "nct218", nct72 },
 277         { "nct72", nct72 },
 278         { "ne1618", ne1618 },
 279         { "w83l771", w83l771 },
 280         { "sa56004", sa56004 },
 281         { "thmc10", max1617 },
 282         { "tmp451", tmp451 },
 283         { "tmp461", tmp461 },
 284         { }
 285 };
 286 MODULE_DEVICE_TABLE(i2c, lm90_id);
 287
 288 static const struct of_device_id __maybe_unused lm90_of_match[] = {
 289         {
 290                 .compatible = "adi,adm1032",
 291                 .data = (void *)adm1032
 292         },
 293         {
 294                 .compatible = "adi,adt7461",
 295                 .data = (void *)adt7461
 296         },
 297         {
 298                 .compatible = "adi,adt7461a",
 299                 .data = (void *)adt7461a
 300         },
 301         {
 302                 .compatible = "adi,adt7481",
 303                 .data = (void *)adt7481
 304         },
 305         {
 306                 .compatible = "gmt,g781",
 307                 .data = (void *)g781
 308         },
 309         {
 310                 .compatible = "national,lm90",
 311                 .data = (void *)lm90
 312         },
 313         {
 314                 .compatible = "national,lm86",
 315                 .data = (void *)lm90
 316         },
 317         {
 318                 .compatible = "national,lm89",
 319                 .data = (void *)lm90
 320         },
 321         {
 322                 .compatible = "national,lm99",
 323                 .data = (void *)lm99
 324         },
 325         {
 326                 .compatible = "dallas,max6646",
 327                 .data = (void *)max6646
 328         },
 329         {
 330                 .compatible = "dallas,max6647",
 331                 .data = (void *)max6646
 332         },
 333         {
 334                 .compatible = "dallas,max6649",
 335                 .data = (void *)max6646
 336         },
 337         {
 338                 .compatible = "dallas,max6654",
 339                 .data = (void *)max6654
 340         },
 341         {
 342                 .compatible = "dallas,max6657",
 343                 .data = (void *)max6657
 344         },
 345         {
 346                 .compatible = "dallas,max6658",
 347                 .data = (void *)max6657
 348         },
 349         {
 350                 .compatible = "dallas,max6659",
 351                 .data = (void *)max6659
 352         },
 353         {
 354                 .compatible = "dallas,max6680",
 355                 .data = (void *)max6680
 356         },
 357         {
 358                 .compatible = "dallas,max6681",
 359                 .data = (void *)max6680
 360         },
 361         {
 362                 .compatible = "dallas,max6695",
 363                 .data = (void *)max6696
 364         },
 365         {
 366                 .compatible = "dallas,max6696",
 367                 .data = (void *)max6696
 368         },
 369         {
 370                 .compatible = "onnn,nct1008",
 371                 .data = (void *)adt7461a
 372         },
 373         {
 374                 .compatible = "onnn,nct214",
 375                 .data = (void *)nct72
 376         },
 377         {
 378                 .compatible = "onnn,nct218",
 379                 .data = (void *)nct72
 380         },
 381         {
 382                 .compatible = "onnn,nct72",
 383                 .data = (void *)nct72
 384         },
 385         {
 386                 .compatible = "winbond,w83l771",
 387                 .data = (void *)w83l771
 388         },
 389         {
 390                 .compatible = "nxp,sa56004",
 391                 .data = (void *)sa56004
 392         },
 393         {
 394                 .compatible = "ti,tmp451",
 395                 .data = (void *)tmp451
 396         },
 397         {
 398                 .compatible = "ti,tmp461",
 399                 .data = (void *)tmp461
 400         },
 401         { },
 402 };
 403 MODULE_DEVICE_TABLE(of, lm90_of_match);
 404
 405 /*
 406  * chip type specific parameters
 407  */
 408 struct lm90_params {
 409         u32 flags;              /* Capabilities */
 410         u16 alert_alarms;       /* Which alarm bits trigger ALERT# */
 411                                 /* Upper 8 bits for max6695/96 */
 412         u8 max_convrate;        /* Maximum conversion rate register value */
 413         u8 resolution;          /* 16-bit resolution (default 11 bit) */
 414         u8 reg_status2;         /* 2nd status register (optional) */
 415         u8 reg_local_ext;       /* Extended local temp register (optional) */
 416         u8 faultqueue_mask;     /* fault queue bit mask */
 417         u8 faultqueue_depth;    /* fault queue depth if mask is used */
 418 };
 419
 420 static const struct lm90_params lm90_params[] = {
 421         [adm1023] = {
 422                 .flags = LM90_HAVE_ALARMS | LM90_HAVE_OFFSET | LM90_HAVE_BROKEN_ALERT
 423                   | LM90_HAVE_REM_LIMIT_EXT | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 424                   | LM90_HAVE_REMOTE_EXT,
 425                 .alert_alarms = 0x7c,
 426                 .resolution = 8,
 427                 .max_convrate = 7,
 428         },
 429         [adm1032] = {
 430                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 431                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_CRIT
 432                   | LM90_HAVE_PARTIAL_PEC | LM90_HAVE_ALARMS
 433                   | LM90_HAVE_LOW | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT
 434                   | LM90_HAVE_FAULTQUEUE,
 435                 .alert_alarms = 0x7c,
 436                 .max_convrate = 10,
 437         },
 438         [adt7461] = {
 439                 /*
 440                  * Standard temperature range is supposed to be unsigned,
 441                  * but that does not match reality. Negative temperatures
 442                  * are always reported.
 443                  */
 444                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 445                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXTENDED_TEMP
 446                   | LM90_HAVE_CRIT | LM90_HAVE_PARTIAL_PEC
 447                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 448                   | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 449                 .alert_alarms = 0x7c,
 450                 .max_convrate = 10,
 451                 .resolution = 10,
 452         },
 453         [adt7461a] = {
 454                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 455                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXTENDED_TEMP
 456                   | LM90_HAVE_CRIT | LM90_HAVE_PEC | LM90_HAVE_ALARMS
 457                   | LM90_HAVE_LOW | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT
 458                   | LM90_HAVE_FAULTQUEUE,
 459                 .alert_alarms = 0x7c,
 460                 .max_convrate = 10,
 461         },
 462         [adt7481] = {
 463                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 464                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXTENDED_TEMP
 465                   | LM90_HAVE_UNSIGNED_TEMP | LM90_HAVE_PEC
 466                   | LM90_HAVE_TEMP3 | LM90_HAVE_CRIT | LM90_HAVE_LOW
 467                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT
 468                   | LM90_HAVE_FAULTQUEUE,
 469                 .alert_alarms = 0x1c7c,
 470                 .max_convrate = 11,
 471                 .resolution = 10,
 472                 .reg_status2 = ADT7481_REG_STATUS2,
 473         },
 474         [g781] = {
 475                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 476                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_CRIT
 477                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 478                   | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 479                 .alert_alarms = 0x7c,
 480                 .max_convrate = 7,
 481         },
 482         [lm84] = {
 483                 .flags = LM90_HAVE_ALARMS,
 484                 .resolution = 8,
 485         },
 486         [lm90] = {
 487                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 488                   | LM90_HAVE_CRIT | LM90_HAVE_ALARMS | LM90_HAVE_LOW
 489                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT
 490                   | LM90_HAVE_FAULTQUEUE,
 491                 .alert_alarms = 0x7b,
 492                 .max_convrate = 9,
 493                 .faultqueue_mask = BIT(0),
 494                 .faultqueue_depth = 3,
 495         },
 496         [lm99] = {
 497                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 498                   | LM90_HAVE_CRIT | LM90_HAVE_ALARMS | LM90_HAVE_LOW
 499                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT
 500                   | LM90_HAVE_FAULTQUEUE,
 501                 .alert_alarms = 0x7b,
 502                 .max_convrate = 9,
 503                 .faultqueue_mask = BIT(0),
 504                 .faultqueue_depth = 3,
 505         },
 506         [max1617] = {
 507                 .flags = LM90_HAVE_CONVRATE | LM90_HAVE_BROKEN_ALERT |
 508                   LM90_HAVE_LOW | LM90_HAVE_ALARMS,
 509                 .alert_alarms = 0x78,
 510                 .resolution = 8,
 511                 .max_convrate = 7,
 512         },
 513         [max6642] = {
 514                 .flags = LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXT_UNSIGNED
 515                   | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 516                 .alert_alarms = 0x50,
 517                 .resolution = 10,
 518                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 519                 .faultqueue_mask = BIT(4),
 520                 .faultqueue_depth = 2,
 521         },
 522         [max6646] = {
 523                 .flags = LM90_HAVE_CRIT | LM90_HAVE_BROKEN_ALERT
 524                   | LM90_HAVE_EXT_UNSIGNED | LM90_HAVE_ALARMS | LM90_HAVE_LOW
 525                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT,
 526                 .alert_alarms = 0x7c,
 527                 .max_convrate = 6,
 528                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 529         },
 530         [max6648] = {
 531                 .flags = LM90_HAVE_UNSIGNED_TEMP | LM90_HAVE_CRIT
 532                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_LOW
 533                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT,
 534                 .alert_alarms = 0x7c,
 535                 .max_convrate = 6,
 536                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 537         },
 538         [max6654] = {
 539                 .flags = LM90_HAVE_BROKEN_ALERT | LM90_HAVE_ALARMS | LM90_HAVE_LOW
 540                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT,
 541                 .alert_alarms = 0x7c,
 542                 .max_convrate = 7,
 543                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 544         },
 545         [max6657] = {
 546                 .flags = LM90_PAUSE_FOR_CONFIG | LM90_HAVE_CRIT
 547                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 548                   | LM90_HAVE_REMOTE_EXT,
 549                 .alert_alarms = 0x7c,
 550                 .max_convrate = 8,
 551                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 552         },
 553         [max6659] = {
 554                 .flags = LM90_HAVE_EMERGENCY | LM90_HAVE_CRIT
 555                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 556                   | LM90_HAVE_REMOTE_EXT,
 557                 .alert_alarms = 0x7c,
 558                 .max_convrate = 8,
 559                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 560         },
 561         [max6680] = {
 562                 /*
 563                  * Apparent temperatures of 128 degrees C or higher are reported
 564                  * and treated as negative temperatures (meaning min_alarm will
 565                  * be set).
 566                  */
 567                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_CRIT
 568                   | LM90_HAVE_CRIT_ALRM_SWP | LM90_HAVE_BROKEN_ALERT
 569                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 570                   | LM90_HAVE_REMOTE_EXT,
 571                 .alert_alarms = 0x7c,
 572                 .max_convrate = 7,
 573         },
 574         [max6696] = {
 575                 .flags = LM90_HAVE_EMERGENCY
 576                   | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3 | LM90_HAVE_CRIT
 577                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 578                   | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 579                 .alert_alarms = 0x1c7c,
 580                 .max_convrate = 6,
 581                 .reg_status2 = MAX6696_REG_STATUS2,
 582                 .reg_local_ext = MAX6657_REG_LOCAL_TEMPL,
 583                 .faultqueue_mask = BIT(5),
 584                 .faultqueue_depth = 4,
 585         },
 586         [nct72] = {
 587                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 588                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXTENDED_TEMP
 589                   | LM90_HAVE_CRIT | LM90_HAVE_PEC | LM90_HAVE_UNSIGNED_TEMP
 590                   | LM90_HAVE_LOW | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT
 591                   | LM90_HAVE_FAULTQUEUE,
 592                 .alert_alarms = 0x7c,
 593                 .max_convrate = 10,
 594                 .resolution = 10,
 595         },
 596         [nct210] = {
 597                 .flags = LM90_HAVE_ALARMS | LM90_HAVE_BROKEN_ALERT
 598                   | LM90_HAVE_REM_LIMIT_EXT | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 599                   | LM90_HAVE_REMOTE_EXT,
 600                 .alert_alarms = 0x7c,
 601                 .resolution = 11,
 602                 .max_convrate = 7,
 603         },
 604         [ne1618] = {
 605                 .flags = LM90_PAUSE_FOR_CONFIG | LM90_HAVE_BROKEN_ALERT
 606                   | LM90_HAVE_LOW | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT,
 607                 .alert_alarms = 0x7c,
 608                 .resolution = 11,
 609                 .max_convrate = 7,
 610         },
 611         [w83l771] = {
 612                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT | LM90_HAVE_CRIT
 613                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 614                   | LM90_HAVE_REMOTE_EXT,
 615                 .alert_alarms = 0x7c,
 616                 .max_convrate = 8,
 617         },
 618         [sa56004] = {
 619                 /*
 620                  * Apparent temperatures of 128 degrees C or higher are reported
 621                  * and treated as negative temperatures (meaning min_alarm will
 622                  * be set).
 623                  */
 624                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT | LM90_HAVE_CRIT
 625                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 626                   | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 627                 .alert_alarms = 0x7b,
 628                 .max_convrate = 9,
 629                 .reg_local_ext = SA56004_REG_LOCAL_TEMPL,
 630                 .faultqueue_mask = BIT(0),
 631                 .faultqueue_depth = 3,
 632         },
 633         [tmp451] = {
 634                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 635                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXTENDED_TEMP | LM90_HAVE_CRIT
 636                   | LM90_HAVE_UNSIGNED_TEMP | LM90_HAVE_ALARMS | LM90_HAVE_LOW
 637                   | LM90_HAVE_CONVRATE | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 638                 .alert_alarms = 0x7c,
 639                 .max_convrate = 9,
 640                 .resolution = 12,
 641                 .reg_local_ext = TMP451_REG_LOCAL_TEMPL,
 642         },
 643         [tmp461] = {
 644                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 645                   | LM90_HAVE_BROKEN_ALERT | LM90_HAVE_EXTENDED_TEMP | LM90_HAVE_CRIT
 646                   | LM90_HAVE_ALARMS | LM90_HAVE_LOW | LM90_HAVE_CONVRATE
 647                   | LM90_HAVE_REMOTE_EXT | LM90_HAVE_FAULTQUEUE,
 648                 .alert_alarms = 0x7c,
 649                 .max_convrate = 9,
 650                 .resolution = 12,
 651                 .reg_local_ext = TMP451_REG_LOCAL_TEMPL,
 652         },
 653 };
 654
 655 /*
 656  * temperature register index
 657  */
 658 enum lm90_temp_reg_index {
 659         LOCAL_LOW = 0,
 660         LOCAL_HIGH,
 661         LOCAL_CRIT,
 662         REMOTE_CRIT,
 663         LOCAL_EMERG,    /* max6659 and max6695/96 */
 664         REMOTE_EMERG,   /* max6659 and max6695/96 */
 665         REMOTE2_CRIT,   /* max6695/96 only */
 666         REMOTE2_EMERG,  /* max6695/96 only */
 667
 668         REMOTE_TEMP,
 669         REMOTE_LOW,
 670         REMOTE_HIGH,
 671         REMOTE_OFFSET,  /* except max6646, max6657/58/59, and max6695/96 */
 672         LOCAL_TEMP,
 673         REMOTE2_TEMP,   /* max6695/96 only */
 674         REMOTE2_LOW,    /* max6695/96 only */
 675         REMOTE2_HIGH,   /* max6695/96 only */
 676         REMOTE2_OFFSET,
 677
 678         TEMP_REG_NUM
 679 };
 680
 681 /*
 682  * Client data (each client gets its own)
 683  */
 684
 685 struct lm90_data {
 686         struct i2c_client *client;
 687         struct device *hwmon_dev;
 688         u32 chip_config[2];
 689         u32 channel_config[MAX_CHANNELS + 1];
 690         const char *channel_label[MAX_CHANNELS];
 691         struct hwmon_channel_info chip_info;
 692         struct hwmon_channel_info temp_info;
 693         const struct hwmon_channel_info *info[3];
 694         struct hwmon_chip_info chip;
 695         struct mutex update_lock;
 696         struct delayed_work alert_work;
 697         struct work_struct report_work;
 698         bool valid;             /* true if register values are valid */
 699         bool alarms_valid;      /* true if status register values are valid */
 700         unsigned long last_updated; /* in jiffies */
 701         unsigned long alarms_updated; /* in jiffies */
 702         int kind;
 703         u32 flags;
 704
 705         unsigned int update_interval; /* in milliseconds */
 706
 707         u8 config;              /* Current configuration register value */
 708         u8 config_orig;         /* Original configuration register value */
 709         u8 convrate_orig;       /* Original conversion rate register value */
 710         u8 resolution;          /* temperature resolution in bit */
 711         u16 alert_alarms;       /* Which alarm bits trigger ALERT# */
 712                                 /* Upper 8 bits for max6695/96 */
 713         u8 max_convrate;        /* Maximum conversion rate */
 714         u8 reg_status2;         /* 2nd status register (optional) */
 715         u8 reg_local_ext;       /* local extension register offset */
 716         u8 reg_remote_ext;      /* remote temperature low byte */
 717         u8 faultqueue_mask;     /* fault queue mask */
 718         u8 faultqueue_depth;    /* fault queue mask */
 719
 720         /* registers values */
 721         u16 temp[TEMP_REG_NUM];
 722         u8 temp_hyst;
 723         u8 conalert;
 724         u16 reported_alarms;    /* alarms reported as sysfs/udev events */
 725         u16 current_alarms;     /* current alarms, reported by chip */
 726         u16 alarms;             /* alarms not yet reported to user */
 727 };
 728
 729 /*
 730  * Support functions
 731  */
 732
 733 /*
 734  * If the chip supports PEC but not on write byte transactions, we need
 735  * to explicitly ask for a transaction without PEC.
 736  */
 737 static inline s32 lm90_write_no_pec(struct i2c_client *client, u8 value)
 738 {
 739         return i2c_smbus_xfer(client->adapter, client->addr,
 740                               client->flags & ~I2C_CLIENT_PEC,
 741                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 742 }
 743
 744 /*
 745  * It is assumed that client->update_lock is held (unless we are in
 746  * detection or initialization steps). This matters when PEC is enabled
 747  * for chips with partial PEC support, because we don't want the address
 748  * pointer to change between the write byte and the read byte transactions.
 749  */
 750 static int lm90_read_reg(struct i2c_client *client, u8 reg)
 751 {
 752         struct lm90_data *data = i2c_get_clientdata(client);
 753         bool partial_pec = (client->flags & I2C_CLIENT_PEC) &&
 754                         (data->flags & LM90_HAVE_PARTIAL_PEC);
 755         int err;
 756
 757         if (partial_pec) {
 758                 err = lm90_write_no_pec(client, reg);
 759                 if (err)
 760                         return err;
 761                 return i2c_smbus_read_byte(client);
 762         }
 763         return i2c_smbus_read_byte_data(client, reg);
 764 }
 765
 766 /*
 767  * Return register write address
 768  *
 769  * The write address for registers 0x03 .. 0x08 is the read address plus 6.
 770  * For other registers the write address matches the read address.
 771  */
 772 static u8 lm90_write_reg_addr(u8 reg)
 773 {
 774         if (reg >= LM90_REG_CONFIG1 && reg <= LM90_REG_REMOTE_LOWH)
 775                 return reg + 6;
 776         return reg;
 777 }
 778
 779 /*
 780  * Write into LM90 register.
 781  * Convert register address to write address if needed, then execute the
 782  * operation.
 783  */
 784 static int lm90_write_reg(struct i2c_client *client, u8 reg, u8 val)
 785 {
 786         return i2c_smbus_write_byte_data(client, lm90_write_reg_addr(reg), val);
 787 }
 788
 789 /*
 790  * Write into 16-bit LM90 register.
 791  * Convert register addresses to write address if needed, then execute the
 792  * operation.
 793  */
 794 static int lm90_write16(struct i2c_client *client, u8 regh, u8 regl, u16 val)
 795 {
 796         int ret;
 797
 798         ret = lm90_write_reg(client, regh, val >> 8);
 799         if (ret < 0 || !regl)
 800                 return ret;
 801         return lm90_write_reg(client, regl, val & 0xff);
 802 }
 803
 804 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl,
 805                        bool is_volatile)
 806 {
 807         int oldh, newh, l;
 808
 809         oldh = lm90_read_reg(client, regh);
 810         if (oldh < 0)
 811                 return oldh;
 812
 813         if (!regl)
 814                 return oldh << 8;
 815
 816         l = lm90_read_reg(client, regl);
 817         if (l < 0)
 818                 return l;
 819
 820         if (!is_volatile)
 821                 return (oldh << 8) | l;
 822
 823         /*
 824          * For volatile registers we have to use a trick.
 825          * We have to read two registers to have the sensor temperature,
 826          * but we have to beware a conversion could occur between the
 827          * readings. The datasheet says we should either use
 828          * the one-shot conversion register, which we don't want to do
 829          * (disables hardware monitoring) or monitor the busy bit, which is
 830          * impossible (we can't read the values and monitor that bit at the
 831          * exact same time). So the solution used here is to read the high
 832          * the high byte again. If the new high byte matches the old one,
 833          * then we have a valid reading. Otherwise we have to read the low
 834          * byte again, and now we believe we have a correct reading.
 835          */
 836         newh = lm90_read_reg(client, regh);
 837         if (newh < 0)
 838                 return newh;
 839         if (oldh != newh) {
 840                 l = lm90_read_reg(client, regl);
 841                 if (l < 0)
 842                         return l;
 843         }
 844         return (newh << 8) | l;
 845 }
 846
 847 static int lm90_update_confreg(struct lm90_data *data, u8 config)
 848 {
 849         if (data->config != config) {
 850                 int err;
 851
 852                 err = lm90_write_reg(data->client, LM90_REG_CONFIG1, config);
 853                 if (err)
 854                         return err;
 855                 data->config = config;
 856         }
 857         return 0;
 858 }
 859
 860 /*
 861  * client->update_lock must be held when calling this function (unless we are
 862  * in detection or initialization steps), and while a remote channel other
 863  * than channel 0 is selected. Also, calling code must make sure to re-select
 864  * external channel 0 before releasing the lock. This is necessary because
 865  * various registers have different meanings as a result of selecting a
 866  * non-default remote channel.
 867  */
 868 static int lm90_select_remote_channel(struct lm90_data *data, bool second)
 869 {
 870         u8 config = data->config & ~0x08;
 871
 872         if (second)
 873                 config |= 0x08;
 874
 875         return lm90_update_confreg(data, config);
 876 }
 877
 878 static int lm90_write_convrate(struct lm90_data *data, int val)
 879 {
 880         u8 config = data->config;
 881         int err;
 882
 883         /* Save config and pause conversion */
 884         if (data->flags & LM90_PAUSE_FOR_CONFIG) {
 885                 err = lm90_update_confreg(data, config | 0x40);
 886                 if (err < 0)
 887                         return err;
 888         }
 889
 890         /* Set conv rate */
 891         err = lm90_write_reg(data->client, LM90_REG_CONVRATE, val);
 892
 893         /* Revert change to config */
 894         lm90_update_confreg(data, config);
 895
 896         return err;
 897 }
 898
 899 /*
 900  * Set conversion rate.
 901  * client->update_lock must be held when calling this function (unless we are
 902  * in detection or initialization steps).
 903  */
 904 static int lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,
 905                              unsigned int interval)
 906 {
 907         unsigned int update_interval;
 908         int i, err;
 909
 910         /* Shift calculations to avoid rounding errors */
 911         interval <<= 6;
 912
 913         /* find the nearest update rate */
 914         for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6;
 915              i < data->max_convrate; i++, update_interval >>= 1)
 916                 if (interval >= update_interval * 3 / 4)
 917                         break;
 918
 919         err = lm90_write_convrate(data, i);
 920         data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);
 921         return err;
 922 }
 923
 924 static int lm90_set_faultqueue(struct i2c_client *client,
 925                                struct lm90_data *data, int val)
 926 {
 927         int err;
 928
 929         if (data->faultqueue_mask) {
 930                 err = lm90_update_confreg(data, val <= data->faultqueue_depth / 2 ?
 931                                           data->config & ~data->faultqueue_mask :
 932                                           data->config | data->faultqueue_mask);
 933         } else {
 934                 static const u8 values[4] = {0, 2, 6, 0x0e};
 935
 936                 data->conalert = (data->conalert & 0xf1) | values[val - 1];
 937                 err = lm90_write_reg(data->client, TMP451_REG_CONALERT,
 938                                      data->conalert);
 939         }
 940
 941         return err;
 942 }
 943
 944 static int lm90_update_limits(struct device *dev)
 945 {
 946         struct lm90_data *data = dev_get_drvdata(dev);
 947         struct i2c_client *client = data->client;
 948         int val;
 949
 950         if (data->flags & LM90_HAVE_CRIT) {
 951                 val = lm90_read_reg(client, LM90_REG_LOCAL_CRIT);
 952                 if (val < 0)
 953                         return val;
 954                 data->temp[LOCAL_CRIT] = val << 8;
 955
 956                 val = lm90_read_reg(client, LM90_REG_REMOTE_CRIT);
 957                 if (val < 0)
 958                         return val;
 959                 data->temp[REMOTE_CRIT] = val << 8;
 960
 961                 val = lm90_read_reg(client, LM90_REG_TCRIT_HYST);
 962                 if (val < 0)
 963                         return val;
 964                 data->temp_hyst = val;
 965         }
 966         if ((data->flags & LM90_HAVE_FAULTQUEUE) && !data->faultqueue_mask) {
 967                 val = lm90_read_reg(client, TMP451_REG_CONALERT);
 968                 if (val < 0)
 969                         return val;
 970                 data->conalert = val;
 971         }
 972
 973         val = lm90_read16(client, LM90_REG_REMOTE_LOWH,
 974                           (data->flags & LM90_HAVE_REM_LIMIT_EXT) ? LM90_REG_REMOTE_LOWL : 0,
 975                           false);
 976         if (val < 0)
 977                 return val;
 978         data->temp[REMOTE_LOW] = val;
 979
 980         val = lm90_read16(client, LM90_REG_REMOTE_HIGHH,
 981                           (data->flags & LM90_HAVE_REM_LIMIT_EXT) ? LM90_REG_REMOTE_HIGHL : 0,
 982                           false);
 983         if (val < 0)
 984                 return val;
 985         data->temp[REMOTE_HIGH] = val;
 986
 987         if (data->flags & LM90_HAVE_OFFSET) {
 988                 val = lm90_read16(client, LM90_REG_REMOTE_OFFSH,
 989                                   LM90_REG_REMOTE_OFFSL, false);
 990                 if (val < 0)
 991                         return val;
 992                 data->temp[REMOTE_OFFSET] = val;
 993         }
 994
 995         if (data->flags & LM90_HAVE_EMERGENCY) {
 996                 val = lm90_read_reg(client, MAX6659_REG_LOCAL_EMERG);
 997                 if (val < 0)
 998                         return val;
 999                 data->temp[LOCAL_EMERG] = val << 8;
1000
1001                 val = lm90_read_reg(client, MAX6659_REG_REMOTE_EMERG);
1002                 if (val < 0)
1003                         return val;
1004                 data->temp[REMOTE_EMERG] = val << 8;
1005         }
1006
1007         if (data->flags & LM90_HAVE_TEMP3) {
1008                 val = lm90_select_remote_channel(data, true);
1009                 if (val < 0)
1010                         return val;
1011
1012                 val = lm90_read_reg(client, LM90_REG_REMOTE_CRIT);
1013                 if (val < 0)
1014                         return val;
1015                 data->temp[REMOTE2_CRIT] = val << 8;
1016
1017                 if (data->flags & LM90_HAVE_EMERGENCY) {
1018                         val = lm90_read_reg(client, MAX6659_REG_REMOTE_EMERG);
1019                         if (val < 0)
1020                                 return val;
1021                         data->temp[REMOTE2_EMERG] = val << 8;
1022                 }
1023
1024                 val = lm90_read_reg(client, LM90_REG_REMOTE_LOWH);
1025                 if (val < 0)
1026                         return val;
1027                 data->temp[REMOTE2_LOW] = val << 8;
1028
1029                 val = lm90_read_reg(client, LM90_REG_REMOTE_HIGHH);
1030                 if (val < 0)
1031                         return val;
1032                 data->temp[REMOTE2_HIGH] = val << 8;
1033
1034                 if (data->flags & LM90_HAVE_OFFSET) {
1035                         val = lm90_read16(client, LM90_REG_REMOTE_OFFSH,
1036                                           LM90_REG_REMOTE_OFFSL, false);
1037                         if (val < 0)
1038                                 return val;
1039                         data->temp[REMOTE2_OFFSET] = val;
1040                 }
1041
1042                 lm90_select_remote_channel(data, false);
1043         }
1044
1045         return 0;
1046 }
1047
1048 static void lm90_report_alarms(struct work_struct *work)
1049 {
1050         struct lm90_data *data = container_of(work, struct lm90_data, report_work);
1051         u16 cleared_alarms, new_alarms, current_alarms;
1052         struct device *hwmon_dev = data->hwmon_dev;
1053         struct device *dev = &data->client->dev;
1054         int st, st2;
1055
1056         current_alarms = data->current_alarms;
1057         cleared_alarms = data->reported_alarms & ~current_alarms;
1058         new_alarms = current_alarms & ~data->reported_alarms;
1059
1060         if (!cleared_alarms && !new_alarms)
1061                 return;
1062
1063         st = new_alarms & 0xff;
1064         st2 = new_alarms >> 8;
1065
1066         if ((st & (LM90_STATUS_LLOW | LM90_STATUS_LHIGH | LM90_STATUS_LTHRM)) ||
1067             (st2 & MAX6696_STATUS2_LOT2))
1068                 dev_dbg(dev, "temp%d out of range, please check!\n", 1);
1069         if ((st & (LM90_STATUS_RLOW | LM90_STATUS_RHIGH | LM90_STATUS_RTHRM)) ||
1070             (st2 & MAX6696_STATUS2_ROT2))
1071                 dev_dbg(dev, "temp%d out of range, please check!\n", 2);
1072         if (st & LM90_STATUS_ROPEN)
1073                 dev_dbg(dev, "temp%d diode open, please check!\n", 2);
1074         if (st2 & (MAX6696_STATUS2_R2LOW | MAX6696_STATUS2_R2HIGH |
1075                    MAX6696_STATUS2_R2THRM | MAX6696_STATUS2_R2OT2))
1076                 dev_dbg(dev, "temp%d out of range, please check!\n", 3);
1077         if (st2 & MAX6696_STATUS2_R2OPEN)
1078                 dev_dbg(dev, "temp%d diode open, please check!\n", 3);
1079
1080         st |= cleared_alarms & 0xff;
1081         st2 |= cleared_alarms >> 8;
1082
1083         if (st & LM90_STATUS_LLOW)
1084                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_min_alarm, 0);
1085         if (st & LM90_STATUS_RLOW)
1086                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_min_alarm, 1);
1087         if (st2 & MAX6696_STATUS2_R2LOW)
1088                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_min_alarm, 2);
1089
1090         if (st & LM90_STATUS_LHIGH)
1091                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_max_alarm, 0);
1092         if (st & LM90_STATUS_RHIGH)
1093                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_max_alarm, 1);
1094         if (st2 & MAX6696_STATUS2_R2HIGH)
1095                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_max_alarm, 2);
1096
1097         if (st & LM90_STATUS_LTHRM)
1098                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_crit_alarm, 0);
1099         if (st & LM90_STATUS_RTHRM)
1100                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_crit_alarm, 1);
1101         if (st2 & MAX6696_STATUS2_R2THRM)
1102                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_crit_alarm, 2);
1103
1104         if (st2 & MAX6696_STATUS2_LOT2)
1105                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_emergency_alarm, 0);
1106         if (st2 & MAX6696_STATUS2_ROT2)
1107                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_emergency_alarm, 1);
1108         if (st2 & MAX6696_STATUS2_R2OT2)
1109                 hwmon_notify_event(hwmon_dev, hwmon_temp, hwmon_temp_emergency_alarm, 2);
1110
1111         data->reported_alarms = current_alarms;
1112 }
1113
1114 static int lm90_update_alarms_locked(struct lm90_data *data, bool force)
1115 {
1116         if (force || !data->alarms_valid ||
1117             time_after(jiffies, data->alarms_updated + msecs_to_jiffies(data->update_interval))) {
1118                 struct i2c_client *client = data->client;
1119                 bool check_enable;
1120                 u16 alarms;
1121                 int val;
1122
1123                 data->alarms_valid = false;
1124
1125                 val = lm90_read_reg(client, LM90_REG_STATUS);
1126                 if (val < 0)
1127                         return val;
1128                 alarms = val & ~LM90_STATUS_BUSY;
1129
1130                 if (data->reg_status2) {
1131                         val = lm90_read_reg(client, data->reg_status2);
1132                         if (val < 0)
1133                                 return val;
1134                         alarms |= val << 8;
1135                 }
1136                 /*
1137                  * If the update is forced (called from interrupt or alert
1138                  * handler) and alarm data is valid, the alarms may have been
1139                  * updated after the last update interval, and the status
1140                  * register may still be cleared. Only add additional alarms
1141                  * in this case. Alarms will be cleared later if appropriate.
1142                  */
1143                 if (force && data->alarms_valid)
1144                         data->current_alarms |= alarms;
1145                 else
1146                         data->current_alarms = alarms;
1147                 data->alarms |= alarms;
1148
1149                 check_enable = (client->irq || !(data->config_orig & 0x80)) &&
1150                         (data->config & 0x80);
1151
1152                 if (force || check_enable)
1153                         schedule_work(&data->report_work);
1154
1155                 /*
1156                  * Re-enable ALERT# output if it was originally enabled, relevant
1157                  * alarms are all clear, and alerts are currently disabled.
1158                  * Otherwise (re)schedule worker if needed.
1159                  */
1160                 if (check_enable) {
1161                         if (!(data->current_alarms & data->alert_alarms)) {
1162                                 dev_dbg(&client->dev, "Re-enabling ALERT#\n");
1163                                 lm90_update_confreg(data, data->config & ~0x80);
1164                                 /*
1165                                  * We may have been called from the update handler.
1166                                  * If so, the worker, if scheduled, is no longer
1167                                  * needed. Cancel it. Don't synchronize because
1168                                  * it may already be running.
1169                                  */
1170                                 cancel_delayed_work(&data->alert_work);
1171                         } else {
1172                                 schedule_delayed_work(&data->alert_work,
1173                                         max_t(int, HZ, msecs_to_jiffies(data->update_interval)));
1174                         }
1175                 }
1176                 data->alarms_updated = jiffies;
1177                 data->alarms_valid = true;
1178         }
1179         return 0;
1180 }
1181
1182 static int lm90_update_alarms(struct lm90_data *data, bool force)
1183 {
1184         int err;
1185
1186         mutex_lock(&data->update_lock);
1187         err = lm90_update_alarms_locked(data, force);
1188         mutex_unlock(&data->update_lock);
1189
1190         return err;
1191 }
1192
1193 static void lm90_alert_work(struct work_struct *__work)
1194 {
1195         struct delayed_work *delayed_work = container_of(__work, struct delayed_work, work);
1196         struct lm90_data *data = container_of(delayed_work, struct lm90_data, alert_work);
1197
1198         /* Nothing to do if alerts are enabled */
1199         if (!(data->config & 0x80))
1200                 return;
1201
1202         lm90_update_alarms(data, true);
1203 }
1204
1205 static int lm90_update_device(struct device *dev)
1206 {
1207         struct lm90_data *data = dev_get_drvdata(dev);
1208         struct i2c_client *client = data->client;
1209         unsigned long next_update;
1210         int val;
1211
1212         if (!data->valid) {
1213                 val = lm90_update_limits(dev);
1214                 if (val < 0)
1215                         return val;
1216         }
1217
1218         next_update = data->last_updated +
1219                       msecs_to_jiffies(data->update_interval);
1220         if (time_after(jiffies, next_update) || !data->valid) {
1221                 dev_dbg(&client->dev, "Updating lm90 data.\n");
1222
1223                 data->valid = false;
1224
1225                 val = lm90_read_reg(client, LM90_REG_LOCAL_LOW);
1226                 if (val < 0)
1227                         return val;
1228                 data->temp[LOCAL_LOW] = val << 8;
1229
1230                 val = lm90_read_reg(client, LM90_REG_LOCAL_HIGH);
1231                 if (val < 0)
1232                         return val;
1233                 data->temp[LOCAL_HIGH] = val << 8;
1234
1235                 val = lm90_read16(client, LM90_REG_LOCAL_TEMP,
1236                                   data->reg_local_ext, true);
1237                 if (val < 0)
1238                         return val;
1239                 data->temp[LOCAL_TEMP] = val;
1240                 val = lm90_read16(client, LM90_REG_REMOTE_TEMPH,
1241                                   data->reg_remote_ext, true);
1242                 if (val < 0)
1243                         return val;
1244                 data->temp[REMOTE_TEMP] = val;
1245
1246                 if (data->flags & LM90_HAVE_TEMP3) {
1247                         val = lm90_select_remote_channel(data, true);
1248                         if (val < 0)
1249                                 return val;
1250
1251                         val = lm90_read16(client, LM90_REG_REMOTE_TEMPH,
1252                                           data->reg_remote_ext, true);
1253                         if (val < 0) {
1254                                 lm90_select_remote_channel(data, false);
1255                                 return val;
1256                         }
1257                         data->temp[REMOTE2_TEMP] = val;
1258
1259                         lm90_select_remote_channel(data, false);
1260                 }
1261
1262                 val = lm90_update_alarms_locked(data, false);
1263                 if (val < 0)
1264                         return val;
1265
1266                 data->last_updated = jiffies;
1267                 data->valid = true;
1268         }
1269
1270         return 0;
1271 }
1272
1273 /* pec used for devices with PEC support */
1274 static ssize_t pec_show(struct device *dev, struct device_attribute *dummy,
1275                         char *buf)
1276 {
1277         struct i2c_client *client = to_i2c_client(dev);
1278
1279         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
1280 }
1281
1282 static ssize_t pec_store(struct device *dev, struct device_attribute *dummy,
1283                          const char *buf, size_t count)
1284 {
1285         struct i2c_client *client = to_i2c_client(dev);
1286         long val;
1287         int err;
1288
1289         err = kstrtol(buf, 10, &val);
1290         if (err < 0)
1291                 return err;
1292
1293         switch (val) {
1294         case 0:
1295                 client->flags &= ~I2C_CLIENT_PEC;
1296                 break;
1297         case 1:
1298                 client->flags |= I2C_CLIENT_PEC;
1299                 break;
1300         default:
1301                 return -EINVAL;
1302         }
1303
1304         return count;
1305 }
1306
1307 static DEVICE_ATTR_RW(pec);
1308
1309 static int lm90_temp_get_resolution(struct lm90_data *data, int index)
1310 {
1311         switch (index) {
1312         case REMOTE_TEMP:
1313                 if (data->reg_remote_ext)
1314                         return data->resolution;
1315                 return 8;
1316         case REMOTE_OFFSET:
1317         case REMOTE2_OFFSET:
1318         case REMOTE2_TEMP:
1319                 return data->resolution;
1320         case LOCAL_TEMP:
1321                 if (data->reg_local_ext)
1322                         return data->resolution;
1323                 return 8;
1324         case REMOTE_LOW:
1325         case REMOTE_HIGH:
1326         case REMOTE2_LOW:
1327         case REMOTE2_HIGH:
1328                 if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
1329                         return data->resolution;
1330                 return 8;
1331         default:
1332                 return 8;
1333         }
1334 }
1335
1336 static int lm90_temp_from_reg(u32 flags, u16 regval, u8 resolution)
1337 {
1338         int val;
1339
1340         if (flags & LM90_HAVE_EXTENDED_TEMP)
1341                 val = regval - 0x4000;
1342         else if (flags & (LM90_HAVE_UNSIGNED_TEMP | LM90_HAVE_EXT_UNSIGNED))
1343                 val = regval;
1344         else
1345                 val = (s16)regval;
1346
1347         return ((val >> (16 - resolution)) * 1000) >> (resolution - 8);
1348 }
1349
1350 static int lm90_get_temp(struct lm90_data *data, int index, int channel)
1351 {
1352         int temp = lm90_temp_from_reg(data->flags, data->temp[index],
1353                                       lm90_temp_get_resolution(data, index));
1354
1355         /* +16 degrees offset for remote temperature on LM99 */
1356         if (data->kind == lm99 && channel)
1357                 temp += 16000;
1358
1359         return temp;
1360 }
1361
1362 static u16 lm90_temp_to_reg(u32 flags, long val, u8 resolution)
1363 {
1364         int fraction = resolution > 8 ?
1365                         1000 - DIV_ROUND_CLOSEST(1000, BIT(resolution - 8)) : 0;
1366
1367         if (flags & LM90_HAVE_EXTENDED_TEMP) {
1368                 val = clamp_val(val, -64000, 191000 + fraction);
1369                 val += 64000;
1370         } else if (flags & LM90_HAVE_EXT_UNSIGNED) {
1371                 val = clamp_val(val, 0, 255000 + fraction);
1372         } else if (flags & LM90_HAVE_UNSIGNED_TEMP) {
1373                 val = clamp_val(val, 0, 127000 + fraction);
1374         } else {
1375                 val = clamp_val(val, -128000, 127000 + fraction);
1376         }
1377
1378         return DIV_ROUND_CLOSEST(val << (resolution - 8), 1000) << (16 - resolution);
1379 }
1380
1381 static int lm90_set_temp(struct lm90_data *data, int index, int channel, long val)
1382 {
1383         static const u8 regs[] = {
1384                 [LOCAL_LOW] = LM90_REG_LOCAL_LOW,
1385                 [LOCAL_HIGH] = LM90_REG_LOCAL_HIGH,
1386                 [LOCAL_CRIT] = LM90_REG_LOCAL_CRIT,
1387                 [REMOTE_CRIT] = LM90_REG_REMOTE_CRIT,
1388                 [LOCAL_EMERG] = MAX6659_REG_LOCAL_EMERG,
1389                 [REMOTE_EMERG] = MAX6659_REG_REMOTE_EMERG,
1390                 [REMOTE2_CRIT] = LM90_REG_REMOTE_CRIT,
1391                 [REMOTE2_EMERG] = MAX6659_REG_REMOTE_EMERG,
1392                 [REMOTE_LOW] = LM90_REG_REMOTE_LOWH,
1393                 [REMOTE_HIGH] = LM90_REG_REMOTE_HIGHH,
1394                 [REMOTE2_LOW] = LM90_REG_REMOTE_LOWH,
1395                 [REMOTE2_HIGH] = LM90_REG_REMOTE_HIGHH,
1396         };
1397         struct i2c_client *client = data->client;
1398         u8 regh = regs[index];
1399         u8 regl = 0;
1400         int err;
1401
1402         if (channel && (data->flags & LM90_HAVE_REM_LIMIT_EXT)) {
1403                 if (index == REMOTE_LOW || index == REMOTE2_LOW)
1404                         regl = LM90_REG_REMOTE_LOWL;
1405                 else if (index == REMOTE_HIGH || index == REMOTE2_HIGH)
1406                         regl = LM90_REG_REMOTE_HIGHL;
1407         }
1408
1409         /* +16 degrees offset for remote temperature on LM99 */
1410         if (data->kind == lm99 && channel) {
1411                 /* prevent integer underflow */
1412                 val = max(val, -128000l);
1413                 val -= 16000;
1414         }
1415
1416         data->temp[index] = lm90_temp_to_reg(data->flags, val,
1417                                              lm90_temp_get_resolution(data, index));
1418
1419         if (channel > 1)
1420                 lm90_select_remote_channel(data, true);
1421
1422         err = lm90_write16(client, regh, regl, data->temp[index]);
1423
1424         if (channel > 1)
1425                 lm90_select_remote_channel(data, false);
1426
1427         return err;
1428 }
1429
1430 static int lm90_get_temphyst(struct lm90_data *data, int index, int channel)
1431 {
1432         int temp = lm90_get_temp(data, index, channel);
1433
1434         return temp - data->temp_hyst * 1000;
1435 }
1436
1437 static int lm90_set_temphyst(struct lm90_data *data, long val)
1438 {
1439         int temp = lm90_get_temp(data, LOCAL_CRIT, 0);
1440
1441         /* prevent integer overflow/underflow */
1442         val = clamp_val(val, -128000l, 255000l);
1443         data->temp_hyst = clamp_val(DIV_ROUND_CLOSEST(temp - val, 1000), 0, 31);
1444
1445         return lm90_write_reg(data->client, LM90_REG_TCRIT_HYST, data->temp_hyst);
1446 }
1447
1448 static int lm90_get_temp_offset(struct lm90_data *data, int index)
1449 {
1450         int res = lm90_temp_get_resolution(data, index);
1451
1452         return lm90_temp_from_reg(0, data->temp[index], res);
1453 }
1454
1455 static int lm90_set_temp_offset(struct lm90_data *data, int index, int channel, long val)
1456 {
1457         int err;
1458
1459         val = lm90_temp_to_reg(0, val, lm90_temp_get_resolution(data, index));
1460
1461         /* For ADT7481 we can use the same registers for remote channel 1 and 2 */
1462         if (channel > 1)
1463                 lm90_select_remote_channel(data, true);
1464
1465         err = lm90_write16(data->client, LM90_REG_REMOTE_OFFSH, LM90_REG_REMOTE_OFFSL, val);
1466
1467         if (channel > 1)
1468                 lm90_select_remote_channel(data, false);
1469
1470         if (err)
1471                 return err;
1472
1473         data->temp[index] = val;
1474
1475         return 0;
1476 }
1477
1478 static const u8 lm90_temp_index[MAX_CHANNELS] = {
1479         LOCAL_TEMP, REMOTE_TEMP, REMOTE2_TEMP
1480 };
1481
1482 static const u8 lm90_temp_min_index[MAX_CHANNELS] = {
1483         LOCAL_LOW, REMOTE_LOW, REMOTE2_LOW
1484 };
1485
1486 static const u8 lm90_temp_max_index[MAX_CHANNELS] = {
1487         LOCAL_HIGH, REMOTE_HIGH, REMOTE2_HIGH
1488 };
1489
1490 static const u8 lm90_temp_crit_index[MAX_CHANNELS] = {
1491         LOCAL_CRIT, REMOTE_CRIT, REMOTE2_CRIT
1492 };
1493
1494 static const u8 lm90_temp_emerg_index[MAX_CHANNELS] = {
1495         LOCAL_EMERG, REMOTE_EMERG, REMOTE2_EMERG
1496 };
1497
1498 static const s8 lm90_temp_offset_index[MAX_CHANNELS] = {
1499         -1, REMOTE_OFFSET, REMOTE2_OFFSET
1500 };
1501
1502 static const u16 lm90_min_alarm_bits[MAX_CHANNELS] = { BIT(5), BIT(3), BIT(11) };
1503 static const u16 lm90_max_alarm_bits[MAX_CHANNELS] = { BIT(6), BIT(4), BIT(12) };
1504 static const u16 lm90_crit_alarm_bits[MAX_CHANNELS] = { BIT(0), BIT(1), BIT(9) };
1505 static const u16 lm90_crit_alarm_bits_swapped[MAX_CHANNELS] = { BIT(1), BIT(0), BIT(9) };
1506 static const u16 lm90_emergency_alarm_bits[MAX_CHANNELS] = { BIT(15), BIT(13), BIT(14) };
1507 static const u16 lm90_fault_bits[MAX_CHANNELS] = { BIT(0), BIT(2), BIT(10) };
1508
1509 static int lm90_temp_read(struct device *dev, u32 attr, int channel, long *val)
1510 {
1511         struct lm90_data *data = dev_get_drvdata(dev);
1512         int err;
1513         u16 bit;
1514
1515         mutex_lock(&data->update_lock);
1516         err = lm90_update_device(dev);
1517         mutex_unlock(&data->update_lock);
1518         if (err)
1519                 return err;
1520
1521         switch (attr) {
1522         case hwmon_temp_input:
1523                 *val = lm90_get_temp(data, lm90_temp_index[channel], channel);
1524                 break;
1525         case hwmon_temp_min_alarm:
1526         case hwmon_temp_max_alarm:
1527         case hwmon_temp_crit_alarm:
1528         case hwmon_temp_emergency_alarm:
1529         case hwmon_temp_fault:
1530                 switch (attr) {
1531                 case hwmon_temp_min_alarm:
1532                         bit = lm90_min_alarm_bits[channel];
1533                         break;
1534                 case hwmon_temp_max_alarm:
1535                         bit = lm90_max_alarm_bits[channel];
1536                         break;
1537                 case hwmon_temp_crit_alarm:
1538                         if (data->flags & LM90_HAVE_CRIT_ALRM_SWP)
1539                                 bit = lm90_crit_alarm_bits_swapped[channel];
1540                         else
1541                                 bit = lm90_crit_alarm_bits[channel];
1542                         break;
1543                 case hwmon_temp_emergency_alarm:
1544                         bit = lm90_emergency_alarm_bits[channel];
1545                         break;
1546                 case hwmon_temp_fault:
1547                         bit = lm90_fault_bits[channel];
1548                         break;
1549                 }
1550                 *val = !!(data->alarms & bit);
1551                 data->alarms &= ~bit;
1552                 data->alarms |= data->current_alarms;
1553                 break;
1554         case hwmon_temp_min:
1555                 *val = lm90_get_temp(data, lm90_temp_min_index[channel], channel);
1556                 break;
1557         case hwmon_temp_max:
1558                 *val = lm90_get_temp(data, lm90_temp_max_index[channel], channel);
1559                 break;
1560         case hwmon_temp_crit:
1561                 *val = lm90_get_temp(data, lm90_temp_crit_index[channel], channel);
1562                 break;
1563         case hwmon_temp_crit_hyst:
1564                 *val = lm90_get_temphyst(data, lm90_temp_crit_index[channel], channel);
1565                 break;
1566         case hwmon_temp_emergency:
1567                 *val = lm90_get_temp(data, lm90_temp_emerg_index[channel], channel);
1568                 break;
1569         case hwmon_temp_emergency_hyst:
1570                 *val = lm90_get_temphyst(data, lm90_temp_emerg_index[channel], channel);
1571                 break;
1572         case hwmon_temp_offset:
1573                 *val = lm90_get_temp_offset(data, lm90_temp_offset_index[channel]);
1574                 break;
1575         default:
1576                 return -EOPNOTSUPP;
1577         }
1578         return 0;
1579 }
1580
1581 static int lm90_temp_write(struct device *dev, u32 attr, int channel, long val)
1582 {
1583         struct lm90_data *data = dev_get_drvdata(dev);
1584         int err;
1585
1586         mutex_lock(&data->update_lock);
1587
1588         err = lm90_update_device(dev);
1589         if (err)
1590                 goto error;
1591
1592         switch (attr) {
1593         case hwmon_temp_min:
1594                 err = lm90_set_temp(data, lm90_temp_min_index[channel],
1595                                     channel, val);
1596                 break;
1597         case hwmon_temp_max:
1598                 err = lm90_set_temp(data, lm90_temp_max_index[channel],
1599                                     channel, val);
1600                 break;
1601         case hwmon_temp_crit:
1602                 err = lm90_set_temp(data, lm90_temp_crit_index[channel],
1603                                     channel, val);
1604                 break;
1605         case hwmon_temp_crit_hyst:
1606                 err = lm90_set_temphyst(data, val);
1607                 break;
1608         case hwmon_temp_emergency:
1609                 err = lm90_set_temp(data, lm90_temp_emerg_index[channel],
1610                                     channel, val);
1611                 break;
1612         case hwmon_temp_offset:
1613                 err = lm90_set_temp_offset(data, lm90_temp_offset_index[channel],
1614                                            channel, val);
1615                 break;
1616         default:
1617                 err = -EOPNOTSUPP;
1618                 break;
1619         }
1620 error:
1621         mutex_unlock(&data->update_lock);
1622
1623         return err;
1624 }
1625
1626 static umode_t lm90_temp_is_visible(const void *data, u32 attr, int channel)
1627 {
1628         switch (attr) {
1629         case hwmon_temp_input:
1630         case hwmon_temp_min_alarm:
1631         case hwmon_temp_max_alarm:
1632         case hwmon_temp_crit_alarm:
1633         case hwmon_temp_emergency_alarm:
1634         case hwmon_temp_emergency_hyst:
1635         case hwmon_temp_fault:
1636         case hwmon_temp_label:
1637                 return 0444;
1638         case hwmon_temp_min:
1639         case hwmon_temp_max:
1640         case hwmon_temp_crit:
1641         case hwmon_temp_emergency:
1642         case hwmon_temp_offset:
1643                 return 0644;
1644         case hwmon_temp_crit_hyst:
1645                 if (channel == 0)
1646                         return 0644;
1647                 return 0444;
1648         default:
1649                 return 0;
1650         }
1651 }
1652
1653 static int lm90_chip_read(struct device *dev, u32 attr, int channel, long *val)
1654 {
1655         struct lm90_data *data = dev_get_drvdata(dev);
1656         int err;
1657
1658         mutex_lock(&data->update_lock);
1659         err = lm90_update_device(dev);
1660         mutex_unlock(&data->update_lock);
1661         if (err)
1662                 return err;
1663
1664         switch (attr) {
1665         case hwmon_chip_update_interval:
1666                 *val = data->update_interval;
1667                 break;
1668         case hwmon_chip_alarms:
1669                 *val = data->alarms;
1670                 break;
1671         case hwmon_chip_temp_samples:
1672                 if (data->faultqueue_mask) {
1673                         *val = (data->config & data->faultqueue_mask) ?
1674                                 data->faultqueue_depth : 1;
1675                 } else {
1676                         switch (data->conalert & 0x0e) {
1677                         case 0x0:
1678                         default:
1679                                 *val = 1;
1680                                 break;
1681                         case 0x2:
1682                                 *val = 2;
1683                                 break;
1684                         case 0x6:
1685                                 *val = 3;
1686                                 break;
1687                         case 0xe:
1688                                 *val = 4;
1689                                 break;
1690                         }
1691                 }
1692                 break;
1693         default:
1694                 return -EOPNOTSUPP;
1695         }
1696
1697         return 0;
1698 }
1699
1700 static int lm90_chip_write(struct device *dev, u32 attr, int channel, long val)
1701 {
1702         struct lm90_data *data = dev_get_drvdata(dev);
1703         struct i2c_client *client = data->client;
1704         int err;
1705
1706         mutex_lock(&data->update_lock);
1707
1708         err = lm90_update_device(dev);
1709         if (err)
1710                 goto error;
1711
1712         switch (attr) {
1713         case hwmon_chip_update_interval:
1714                 err = lm90_set_convrate(client, data,
1715                                         clamp_val(val, 0, 100000));
1716                 break;
1717         case hwmon_chip_temp_samples:
1718                 err = lm90_set_faultqueue(client, data, clamp_val(val, 1, 4));
1719                 break;
1720         default:
1721                 err = -EOPNOTSUPP;
1722                 break;
1723         }
1724 error:
1725         mutex_unlock(&data->update_lock);
1726
1727         return err;
1728 }
1729
1730 static umode_t lm90_chip_is_visible(const void *data, u32 attr, int channel)
1731 {
1732         switch (attr) {
1733         case hwmon_chip_update_interval:
1734         case hwmon_chip_temp_samples:
1735                 return 0644;
1736         case hwmon_chip_alarms:
1737                 return 0444;
1738         default:
1739                 return 0;
1740         }
1741 }
1742
1743 static int lm90_read(struct device *dev, enum hwmon_sensor_types type,
1744                      u32 attr, int channel, long *val)
1745 {
1746         switch (type) {
1747         case hwmon_chip:
1748                 return lm90_chip_read(dev, attr, channel, val);
1749         case hwmon_temp:
1750                 return lm90_temp_read(dev, attr, channel, val);
1751         default:
1752                 return -EOPNOTSUPP;
1753         }
1754 }
1755
1756 static int lm90_read_string(struct device *dev, enum hwmon_sensor_types type,
1757                             u32 attr, int channel, const char **str)
1758 {
1759         struct lm90_data *data = dev_get_drvdata(dev);
1760
1761         *str = data->channel_label[channel];
1762
1763         return 0;
1764 }
1765
1766 static int lm90_write(struct device *dev, enum hwmon_sensor_types type,
1767                       u32 attr, int channel, long val)
1768 {
1769         switch (type) {
1770         case hwmon_chip:
1771                 return lm90_chip_write(dev, attr, channel, val);
1772         case hwmon_temp:
1773                 return lm90_temp_write(dev, attr, channel, val);
1774         default:
1775                 return -EOPNOTSUPP;
1776         }
1777 }
1778
1779 static umode_t lm90_is_visible(const void *data, enum hwmon_sensor_types type,
1780                                u32 attr, int channel)
1781 {
1782         switch (type) {
1783         case hwmon_chip:
1784                 return lm90_chip_is_visible(data, attr, channel);
1785         case hwmon_temp:
1786                 return lm90_temp_is_visible(data, attr, channel);
1787         default:
1788                 return 0;
1789         }
1790 }
1791
1792 static const char *lm90_detect_lm84(struct i2c_client *client)
1793 {
1794         static const u8 regs[] = {
1795                 LM90_REG_STATUS, LM90_REG_LOCAL_TEMP, LM90_REG_LOCAL_HIGH,
1796                 LM90_REG_REMOTE_TEMPH, LM90_REG_REMOTE_HIGHH
1797         };
1798         int status = i2c_smbus_read_byte_data(client, LM90_REG_STATUS);
1799         int reg1, reg2, reg3, reg4;
1800         bool nonzero = false;
1801         u8 ff = 0xff;
1802         int i;
1803
1804         if (status < 0 || (status & 0xab))
1805                 return NULL;
1806
1807         /*
1808          * For LM84, undefined registers return the most recent value.
1809          * Repeat several times, each time checking against a different
1810          * (presumably) existing register.
1811          */
1812         for (i = 0; i < ARRAY_SIZE(regs); i++) {
1813                 reg1 = i2c_smbus_read_byte_data(client, regs[i]);
1814                 reg2 = i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_TEMPL);
1815                 reg3 = i2c_smbus_read_byte_data(client, LM90_REG_LOCAL_LOW);
1816                 reg4 = i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_LOWH);
1817
1818                 if (reg1 < 0)
1819                         return NULL;
1820
1821                 /* If any register has a different value, this is not an LM84 */
1822                 if (reg2 != reg1 || reg3 != reg1 || reg4 != reg1)
1823                         return NULL;
1824
1825                 nonzero |= reg1 || reg2 || reg3 || reg4;
1826                 ff &= reg1;
1827         }
1828         /*
1829          * If all registers always returned 0 or 0xff, all bets are off,
1830          * and we can not make any predictions about the chip type.
1831          */
1832         return nonzero && ff != 0xff ? "lm84" : NULL;
1833 }
1834
1835 static const char *lm90_detect_max1617(struct i2c_client *client, int config1)
1836 {
1837         int status = i2c_smbus_read_byte_data(client, LM90_REG_STATUS);
1838         int llo, rlo, lhi, rhi;
1839
1840         if (status < 0 || (status & 0x03))
1841                 return NULL;
1842
1843         if (config1 & 0x3f)
1844                 return NULL;
1845
1846         /*
1847          * Fail if unsupported registers return anything but 0xff.
1848          * The calling code already checked man_id and chip_id.
1849          * A byte read operation repeats the most recent read operation
1850          * and should also return 0xff.
1851          */
1852         if (i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_TEMPL) != 0xff ||
1853             i2c_smbus_read_byte_data(client, MAX6657_REG_LOCAL_TEMPL) != 0xff ||
1854             i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_LOWL) != 0xff ||
1855             i2c_smbus_read_byte(client) != 0xff)
1856                 return NULL;
1857
1858         llo = i2c_smbus_read_byte_data(client, LM90_REG_LOCAL_LOW);
1859         rlo = i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_LOWH);
1860
1861         lhi = i2c_smbus_read_byte_data(client, LM90_REG_LOCAL_HIGH);
1862         rhi = i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_HIGHH);
1863
1864         if (llo < 0 || rlo < 0)
1865                 return NULL;
1866
1867         /*
1868          * A byte read operation repeats the most recent read and should
1869          * return the same value.
1870          */
1871         if (i2c_smbus_read_byte(client) != rhi)
1872                 return NULL;
1873
1874         /*
1875          * The following two checks are marginal since the checked values
1876          * are strictly speaking valid.
1877          */
1878
1879         /* fail for negative high limits; this also catches read errors */
1880         if ((s8)lhi < 0 || (s8)rhi < 0)
1881                 return NULL;
1882
1883         /* fail if low limits are larger than or equal to high limits */
1884         if ((s8)llo >= lhi || (s8)rlo >= rhi)
1885                 return NULL;
1886
1887         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
1888                 /*
1889                  * Word read operations return 0xff in second byte
1890                  */
1891                 if (i2c_smbus_read_word_data(client, LM90_REG_REMOTE_TEMPL) !=
1892                                                 0xffff)
1893                         return NULL;
1894                 if (i2c_smbus_read_word_data(client, LM90_REG_CONFIG1) !=
1895                                                 (config1 | 0xff00))
1896                         return NULL;
1897                 if (i2c_smbus_read_word_data(client, LM90_REG_LOCAL_HIGH) !=
1898                                                 (lhi | 0xff00))
1899                         return NULL;
1900         }
1901
1902         return "max1617";
1903 }
1904
1905 static const char *lm90_detect_national(struct i2c_client *client, int chip_id,
1906                                         int config1, int convrate)
1907 {
1908         int config2 = i2c_smbus_read_byte_data(client, LM90_REG_CONFIG2);
1909         int address = client->addr;
1910         const char *name = NULL;
1911
1912         if (config2 < 0)
1913                 return NULL;
1914
1915         if ((config1 & 0x2a) || (config2 & 0xf8) || convrate > 0x09)
1916                 return NULL;
1917
1918         if (address != 0x4c && address != 0x4d)
1919                 return NULL;
1920
1921         switch (chip_id & 0xf0) {
1922         case 0x10:      /* LM86 */
1923                 if (address == 0x4c)
1924                         name = "lm86";
1925                 break;
1926         case 0x20:      /* LM90 */
1927                 if (address == 0x4c)
1928                         name = "lm90";
1929                 break;
1930         case 0x30:      /* LM89/LM99 */
1931                 name = "lm99";  /* detect LM89 as LM99 */
1932                 break;
1933         default:
1934                 break;
1935         }
1936
1937         return name;
1938 }
1939
1940 static const char *lm90_detect_on(struct i2c_client *client, int chip_id, int config1,
1941                                   int convrate)
1942 {
1943         int address = client->addr;
1944         const char *name = NULL;
1945
1946         switch (chip_id) {
1947         case 0xca:              /* NCT218 */
1948                 if ((address == 0x4c || address == 0x4d) && !(config1 & 0x1b) &&
1949                     convrate <= 0x0a)
1950                         name = "nct218";
1951                 break;
1952         default:
1953                 break;
1954         }
1955         return name;
1956 }
1957
1958 static const char *lm90_detect_analog(struct i2c_client *client, bool common_address,
1959                                       int chip_id, int config1, int convrate)
1960 {
1961         int status = i2c_smbus_read_byte_data(client, LM90_REG_STATUS);
1962         int config2 = i2c_smbus_read_byte_data(client, ADT7481_REG_CONFIG2);
1963         int man_id2 = i2c_smbus_read_byte_data(client, ADT7481_REG_MAN_ID);
1964         int chip_id2 = i2c_smbus_read_byte_data(client, ADT7481_REG_CHIP_ID);
1965         int address = client->addr;
1966         const char *name = NULL;
1967
1968         if (status < 0 || config2 < 0 || man_id2 < 0 || chip_id2 < 0)
1969                 return NULL;
1970
1971         /*
1972          * The following chips should be detected by this function. Known
1973          * register values are listed. Registers 0x3d .. 0x3e are undocumented
1974          * for most of the chips, yet appear to return a well defined value.
1975          * Register 0xff is undocumented for some of the chips. Register 0x3f
1976          * is undocumented for all chips, but also returns a well defined value.
1977          * Values are as reported from real chips unless mentioned otherwise.
1978          * The code below checks values for registers 0x3d, 0x3e, and 0xff,
1979          * but not for register 0x3f.
1980          *
1981          * Chip                 Register
1982          *              3d      3e      3f      fe      ff      Notes
1983          * ----------------------------------------------------------
1984          * adm1020      00      00      00      41      39
1985          * adm1021      00      00      00      41      03
1986          * adm1021a     00      00      00      41      3c
1987          * adm1023      00      00      00      41      3c      same as adm1021a
1988          * adm1032      00      00      00      41      42
1989          *
1990          * adt7421      21      41      04      41      04
1991          * adt7461      00      00      00      41      51
1992          * adt7461a     61      41      05      41      57
1993          * adt7481      81      41      02      41      62
1994          * adt7482      -       -       -       41      65      datasheet
1995          *              82      41      05      41      75      real chip
1996          * adt7483      83      41      04      41      94
1997          *
1998          * nct72        61      41      07      41      55
1999          * nct210       00      00      00      41      3f
2000          * nct214       61      41      08      41      5a
2001          * nct1008      -       -       -       41      57      datasheet rev. 3
2002          *              61      41      06      41      54      real chip
2003          *
2004          * nvt210       -       -       -       41      -       datasheet
2005          * nvt211       -       -       -       41      -       datasheet
2006          */
2007         switch (chip_id) {
2008         case 0x00 ... 0x03:     /* ADM1021 */
2009         case 0x05 ... 0x0f:
2010                 if (man_id2 == 0x00 && chip_id2 == 0x00 && common_address &&
2011                     !(status & 0x03) && !(config1 & 0x3f) && !(convrate & 0xf8))
2012                         name = "adm1021";
2013                 break;
2014         case 0x04:              /* ADT7421 (undocumented) */
2015                 if (man_id2 == 0x41 && chip_id2 == 0x21 &&
2016                     (address == 0x4c || address == 0x4d) &&
2017                     (config1 & 0x0b) == 0x08 && convrate <= 0x0a)
2018                         name = "adt7421";
2019                 break;
2020         case 0x30 ... 0x38:     /* ADM1021A, ADM1023 */
2021         case 0x3a ... 0x3e:
2022                 /*
2023                  * ADM1021A and compatible chips will be mis-detected as
2024                  * ADM1023. Chips labeled 'ADM1021A' and 'ADM1023' were both
2025                  * found to have a Chip ID of 0x3c.
2026                  * ADM1021A does not officially support low byte registers
2027                  * (0x12 .. 0x14), but a chip labeled ADM1021A does support it.
2028                  * Official support for the temperature offset high byte
2029                  * register (0x11) was added to revision F of the ADM1021A
2030                  * datasheet.
2031                  * It is currently unknown if there is a means to distinguish
2032                  * ADM1021A from ADM1023, and/or if revisions of ADM1021A exist
2033                  * which differ in functionality from ADM1023.
2034                  */
2035                 if (man_id2 == 0x00 && chip_id2 == 0x00 && common_address &&
2036                     !(status & 0x03) && !(config1 & 0x3f) && !(convrate & 0xf8))
2037                         name = "adm1023";
2038                 break;
2039         case 0x39:              /* ADM1020 (undocumented) */
2040                 if (man_id2 == 0x00 && chip_id2 == 0x00 &&
2041                     (address == 0x4c || address == 0x4d || address == 0x4e) &&
2042                     !(status & 0x03) && !(config1 & 0x3f) && !(convrate & 0xf8))
2043                         name = "adm1020";
2044                 break;
2045         case 0x3f:              /* NCT210 */
2046                 if (man_id2 == 0x00 && chip_id2 == 0x00 && common_address &&
2047                     !(status & 0x03) && !(config1 & 0x3f) && !(convrate & 0xf8))
2048                         name = "nct210";
2049                 break;
2050         case 0x40 ... 0x4f:     /* ADM1032 */
2051                 if (man_id2 == 0x00 && chip_id2 == 0x00 &&
2052                     (address == 0x4c || address == 0x4d) && !(config1 & 0x3f) &&
2053                     convrate <= 0x0a)
2054                         name = "adm1032";
2055                 break;
2056         case 0x51:      /* ADT7461 */
2057                 if (man_id2 == 0x00 && chip_id2 == 0x00 &&
2058                     (address == 0x4c || address == 0x4d) && !(config1 & 0x1b) &&
2059                     convrate <= 0x0a)
2060                         name = "adt7461";
2061                 break;
2062         case 0x54:      /* NCT1008 */
2063                 if (man_id2 == 0x41 && chip_id2 == 0x61 &&
2064                     (address == 0x4c || address == 0x4d) && !(config1 & 0x1b) &&
2065                     convrate <= 0x0a)
2066                         name = "nct1008";
2067                 break;
2068         case 0x55:      /* NCT72 */
2069                 if (man_id2 == 0x41 && chip_id2 == 0x61 &&
2070                     (address == 0x4c || address == 0x4d) && !(config1 & 0x1b) &&
2071                     convrate <= 0x0a)
2072                         name = "nct72";
2073                 break;
2074         case 0x57:      /* ADT7461A, NCT1008 (datasheet rev. 3) */
2075                 if (man_id2 == 0x41 && chip_id2 == 0x61 &&
2076                     (address == 0x4c || address == 0x4d) && !(config1 & 0x1b) &&
2077                     convrate <= 0x0a)
2078                         name = "adt7461a";
2079                 break;
2080         case 0x5a:      /* NCT214 */
2081                 if (man_id2 == 0x41 && chip_id2 == 0x61 &&
2082                     common_address && !(config1 & 0x1b) && convrate <= 0x0a)
2083                         name = "nct214";
2084                 break;
2085         case 0x62:      /* ADT7481, undocumented */
2086                 if (man_id2 == 0x41 && chip_id2 == 0x81 &&
2087                     (address == 0x4b || address == 0x4c) && !(config1 & 0x10) &&
2088                     !(config2 & 0x7f) && (convrate & 0x0f) <= 0x0b) {
2089                         name = "adt7481";
2090                 }
2091                 break;
2092         case 0x65:      /* ADT7482, datasheet */
2093         case 0x75:      /* ADT7482, real chip */
2094                 if (man_id2 == 0x41 && chip_id2 == 0x82 &&
2095                     address == 0x4c && !(config1 & 0x10) && !(config2 & 0x7f) &&
2096                     convrate <= 0x0a)
2097                         name = "adt7482";
2098                 break;
2099         case 0x94:      /* ADT7483 */
2100                 if (man_id2 == 0x41 && chip_id2 == 0x83 &&
2101                     common_address &&
2102                     ((address >= 0x18 && address <= 0x1a) ||
2103                      (address >= 0x29 && address <= 0x2b) ||
2104                      (address >= 0x4c && address <= 0x4e)) &&
2105                     !(config1 & 0x10) && !(config2 & 0x7f) && convrate <= 0x0a)
2106                         name = "adt7483a";
2107                 break;
2108         default:
2109                 break;
2110         }
2111
2112         return name;
2113 }
2114
2115 static const char *lm90_detect_maxim(struct i2c_client *client, bool common_address,
2116                                      int chip_id, int config1, int convrate)
2117 {
2118         int man_id, emerg, emerg2, status2;
2119         int address = client->addr;
2120         const char *name = NULL;
2121
2122         switch (chip_id) {
2123         case 0x01:
2124                 if (!common_address)
2125                         break;
2126
2127                 /*
2128                  * We read MAX6659_REG_REMOTE_EMERG twice, and re-read
2129                  * LM90_REG_MAN_ID in between. If MAX6659_REG_REMOTE_EMERG
2130                  * exists, both readings will reflect the same value. Otherwise,
2131                  * the readings will be different.
2132                  */
2133                 emerg = i2c_smbus_read_byte_data(client,
2134                                                  MAX6659_REG_REMOTE_EMERG);
2135                 man_id = i2c_smbus_read_byte_data(client,
2136                                                   LM90_REG_MAN_ID);
2137                 emerg2 = i2c_smbus_read_byte_data(client,
2138                                                   MAX6659_REG_REMOTE_EMERG);
2139                 status2 = i2c_smbus_read_byte_data(client,
2140                                                    MAX6696_REG_STATUS2);
2141                 if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0)
2142                         return NULL;
2143
2144                 /*
2145                  * Even though MAX6695 and MAX6696 do not have a chip ID
2146                  * register, reading it returns 0x01. Bit 4 of the config1
2147                  * register is unused and should return zero when read. Bit 0 of
2148                  * the status2 register is unused and should return zero when
2149                  * read.
2150                  *
2151                  * MAX6695 and MAX6696 have an additional set of temperature
2152                  * limit registers. We can detect those chips by checking if
2153                  * one of those registers exists.
2154                  */
2155                 if (!(config1 & 0x10) && !(status2 & 0x01) && emerg == emerg2 &&
2156                     convrate <= 0x07)
2157                         name = "max6696";
2158                 /*
2159                  * The chip_id register of the MAX6680 and MAX6681 holds the
2160                  * revision of the chip. The lowest bit of the config1 register
2161                  * is unused and should return zero when read, so should the
2162                  * second to last bit of config1 (software reset). Register
2163                  * address 0x12 (LM90_REG_REMOTE_OFFSL) exists for this chip and
2164                  * should differ from emerg2, and emerg2 should match man_id
2165                  * since it does not exist.
2166                  */
2167                 else if (!(config1 & 0x03) && convrate <= 0x07 &&
2168                          emerg2 == man_id && emerg2 != status2)
2169                         name = "max6680";
2170                 /*
2171                  * MAX1617A does not have any extended registers (register
2172                  * address 0x10 or higher) except for manufacturer and
2173                  * device ID registers. Unlike other chips of this series,
2174                  * unsupported registers were observed to return a fixed value
2175                  * of 0x01.
2176                  * Note: Multiple chips with different markings labeled as
2177                  * "MAX1617" (no "A") were observed to report manufacturer ID
2178                  * 0x4d and device ID 0x01. It is unknown if other variants of
2179                  * MAX1617/MAX617A with different behavior exist. The detection
2180                  * code below works for those chips.
2181                  */
2182                 else if (!(config1 & 0x03f) && convrate <= 0x07 &&
2183                          emerg == 0x01 && emerg2 == 0x01 && status2 == 0x01)
2184                         name = "max1617";
2185                 break;
2186         case 0x08:
2187                 /*
2188                  * The chip_id of the MAX6654 holds the revision of the chip.
2189                  * The lowest 3 bits of the config1 register are unused and
2190                  * should return zero when read.
2191                  */
2192                 if (common_address && !(config1 & 0x07) && convrate <= 0x07)
2193                         name = "max6654";
2194                 break;
2195         case 0x09:
2196                 /*
2197                  * The chip_id of the MAX6690 holds the revision of the chip.
2198                  * The lowest 3 bits of the config1 register are unused and
2199                  * should return zero when read.
2200                  * Note that MAX6654 and MAX6690 are practically the same chips.
2201                  * The only diference is the rated accuracy. Rev. 1 of the
2202                  * MAX6690 datasheet lists a chip ID of 0x08, and a chip labeled
2203                  * MAX6654 was observed to have a chip ID of 0x09.
2204                  */
2205                 if (common_address && !(config1 & 0x07) && convrate <= 0x07)
2206                         name = "max6690";
2207                 break;
2208         case 0x4d:
2209                 /*
2210                  * MAX6642, MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
2211                  * register. Reading from that address will return the last
2212                  * read value, which in our case is those of the man_id
2213                  * register, or 0x4d.
2214                  * MAX6642 does not have a conversion rate register, nor low
2215                  * limit registers. Reading from those registers returns the
2216                  * last read value.
2217                  *
2218                  * For MAX6657, MAX6658 and MAX6659, the config1 register lacks
2219                  * a low nibble, so the value will be those of the previous
2220                  * read, so in our case again those of the man_id register.
2221                  * MAX6659 has a third set of upper temperature limit registers.
2222                  * Those registers also return values on MAX6657 and MAX6658,
2223                  * thus the only way to detect MAX6659 is by its address.
2224                  * For this reason it will be mis-detected as MAX6657 if its
2225                  * address is 0x4c.
2226                  */
2227                 if (address >= 0x48 && address <= 0x4f && config1 == convrate &&
2228                     !(config1 & 0x0f)) {
2229                         int regval;
2230
2231                         /*
2232                          * We know that this is not a MAX6657/58/59 because its
2233                          * configuration register has the wrong value and it does
2234                          * not appear to have a conversion rate register.
2235                          */
2236
2237                         /* re-read manufacturer ID to have a good baseline */
2238                         if (i2c_smbus_read_byte_data(client, LM90_REG_MAN_ID) != 0x4d)
2239                                 break;
2240
2241                         /* check various non-existing registers */
2242                         if (i2c_smbus_read_byte_data(client, LM90_REG_CONVRATE) != 0x4d ||
2243                             i2c_smbus_read_byte_data(client, LM90_REG_LOCAL_LOW) != 0x4d ||
2244                             i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_LOWH) != 0x4d)
2245                                 break;
2246
2247                         /* check for unused status register bits */
2248                         regval = i2c_smbus_read_byte_data(client, LM90_REG_STATUS);
2249                         if (regval < 0 || (regval & 0x2b))
2250                                 break;
2251
2252                         /* re-check unsupported registers */
2253                         if (i2c_smbus_read_byte_data(client, LM90_REG_CONVRATE) != regval ||
2254                             i2c_smbus_read_byte_data(client, LM90_REG_LOCAL_LOW) != regval ||
2255                             i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_LOWH) != regval)
2256                                 break;
2257
2258                         name = "max6642";
2259                 } else if ((address == 0x4c || address == 0x4d || address == 0x4e) &&
2260                            (config1 & 0x1f) == 0x0d && convrate <= 0x09) {
2261                         if (address == 0x4c)
2262                                 name = "max6657";
2263                         else
2264                                 name = "max6659";
2265                 }
2266                 break;
2267         case 0x59:
2268                 /*
2269                  * The chip_id register of the MAX6646/6647/6649 holds the
2270                  * revision of the chip. The lowest 6 bits of the config1
2271                  * register are unused and should return zero when read.
2272                  * The I2C address of MAX6648/6692 is fixed at 0x4c.
2273                  * MAX6646 is at address 0x4d, MAX6647 is at address 0x4e,
2274                  * and MAX6649 is at address 0x4c. A slight difference between
2275                  * the two sets of chips is that the remote temperature register
2276                  * reports different values if the DXP pin is open or shorted.
2277                  * We can use that information to help distinguish between the
2278                  * chips. MAX6648 will be mis-detected as MAX6649 if the remote
2279                  * diode is connected, but there isn't really anything we can
2280                  * do about that.
2281                  */
2282                 if (!(config1 & 0x3f) && convrate <= 0x07) {
2283                         int temp;
2284
2285                         switch (address) {
2286                         case 0x4c:
2287                                 /*
2288                                  * MAX6649 reports an external temperature
2289                                  * value of 0xff if DXP is open or shorted.
2290                                  * MAX6648 reports 0x80 in that case.
2291                                  */
2292                                 temp = i2c_smbus_read_byte_data(client,
2293                                                                 LM90_REG_REMOTE_TEMPH);
2294                                 if (temp == 0x80)
2295                                         name = "max6648";
2296                                 else
2297                                         name = "max6649";
2298                                 break;
2299                         case 0x4d:
2300                                 name = "max6646";
2301                                 break;
2302                         case 0x4e:
2303                                 name = "max6647";
2304                                 break;
2305                         default:
2306                                 break;
2307                         }
2308                 }
2309                 break;
2310         default:
2311                 break;
2312         }
2313
2314         return name;
2315 }
2316
2317 static const char *lm90_detect_nuvoton(struct i2c_client *client, int chip_id,
2318                                        int config1, int convrate)
2319 {
2320         int config2 = i2c_smbus_read_byte_data(client, LM90_REG_CONFIG2);
2321         int address = client->addr;
2322         const char *name = NULL;
2323
2324         if (config2 < 0)
2325                 return NULL;
2326
2327         if (address == 0x4c && !(config1 & 0x2a) && !(config2 & 0xf8)) {
2328                 if (chip_id == 0x01 && convrate <= 0x09) {
2329                         /* W83L771W/G */
2330                         name = "w83l771";
2331                 } else if ((chip_id & 0xfe) == 0x10 && convrate <= 0x08) {
2332                         /* W83L771AWG/ASG */
2333                         name = "w83l771";
2334                 }
2335         }
2336         return name;
2337 }
2338
2339 static const char *lm90_detect_nxp(struct i2c_client *client, bool common_address,
2340                                    int chip_id, int config1, int convrate)
2341 {
2342         int address = client->addr;
2343         const char *name = NULL;
2344         int config2;
2345
2346         switch (chip_id) {
2347         case 0x00:
2348                 config2 = i2c_smbus_read_byte_data(client, LM90_REG_CONFIG2);
2349                 if (config2 < 0)
2350                         return NULL;
2351                 if (address >= 0x48 && address <= 0x4f &&
2352                     !(config1 & 0x2a) && !(config2 & 0xfe) && convrate <= 0x09)
2353                         name = "sa56004";
2354                 break;
2355         case 0x80:
2356                 if (common_address && !(config1 & 0x3f) && convrate <= 0x07)
2357                         name = "ne1618";
2358                 break;
2359         default:
2360                 break;
2361         }
2362         return name;
2363 }
2364
2365 static const char *lm90_detect_gmt(struct i2c_client *client, int chip_id,
2366                                    int config1, int convrate)
2367 {
2368         int address = client->addr;
2369
2370         /*
2371          * According to the datasheet, G781 is supposed to be at I2C Address
2372          * 0x4c and have a chip ID of 0x01. G781-1 is supposed to be at I2C
2373          * address 0x4d and have a chip ID of 0x03. However, when support
2374          * for G781 was added, chips at 0x4c and 0x4d were found to have a
2375          * chip ID of 0x01. A G781-1 at I2C address 0x4d was now found with
2376          * chip ID 0x03.
2377          * To avoid detection failures, accept chip ID 0x01 and 0x03 at both
2378          * addresses.
2379          * G784 reports manufacturer ID 0x47 and chip ID 0x01. A public
2380          * datasheet is not available. Extensive testing suggests that
2381          * the chip appears to be fully compatible with G781.
2382          * Available register dumps show that G751 also reports manufacturer
2383          * ID 0x47 and chip ID 0x01 even though that chip does not officially
2384          * support those registers. This makes chip detection somewhat
2385          * vulnerable. To improve detection quality, read the offset low byte
2386          * and alert fault queue registers and verify that only expected bits
2387          * are set.
2388          */
2389         if ((chip_id == 0x01 || chip_id == 0x03) &&
2390             (address == 0x4c || address == 0x4d) &&
2391             !(config1 & 0x3f) && convrate <= 0x08) {
2392                 int reg;
2393
2394                 reg = i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_OFFSL);
2395                 if (reg < 0 || reg & 0x1f)
2396                         return NULL;
2397                 reg = i2c_smbus_read_byte_data(client, TMP451_REG_CONALERT);
2398                 if (reg < 0 || reg & 0xf1)
2399                         return NULL;
2400
2401                 return "g781";
2402         }
2403
2404         return NULL;
2405 }
2406
2407 static const char *lm90_detect_ti49(struct i2c_client *client, bool common_address,
2408                                     int chip_id, int config1, int convrate)
2409 {
2410         if (common_address && chip_id == 0x00 && !(config1 & 0x3f) && !(convrate & 0xf8)) {
2411                 /* THMC10: Unsupported registers return 0xff */
2412                 if (i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_TEMPL) == 0xff &&
2413                     i2c_smbus_read_byte_data(client, LM90_REG_REMOTE_CRIT) == 0xff)
2414                         return "thmc10";
2415         }
2416         return NULL;
2417 }
2418
2419 static const char *lm90_detect_ti(struct i2c_client *client, int chip_id,
2420                                   int config1, int convrate)
2421 {
2422         int address = client->addr;
2423         const char *name = NULL;
2424
2425         if (chip_id == 0x00 && !(config1 & 0x1b) && convrate <= 0x09) {
2426                 int local_ext, conalert, chen, dfc;
2427
2428                 local_ext = i2c_smbus_read_byte_data(client,
2429                                                      TMP451_REG_LOCAL_TEMPL);
2430                 conalert = i2c_smbus_read_byte_data(client,
2431                                                     TMP451_REG_CONALERT);
2432                 chen = i2c_smbus_read_byte_data(client, TMP461_REG_CHEN);
2433                 dfc = i2c_smbus_read_byte_data(client, TMP461_REG_DFC);
2434
2435                 if (!(local_ext & 0x0f) && (conalert & 0xf1) == 0x01 &&
2436                     (chen & 0xfc) == 0x00 && (dfc & 0xfc) == 0x00) {
2437                         if (address == 0x4c && !(chen & 0x03))
2438                                 name = "tmp451";
2439                         else if (address >= 0x48 && address <= 0x4f)
2440                                 name = "tmp461";
2441                 }
2442         }
2443
2444         return name;
2445 }
2446
2447 /* Return 0 if detection is successful, -ENODEV otherwise */
2448 static int lm90_detect(struct i2c_client *client, struct i2c_board_info *info)
2449 {
2450         struct i2c_adapter *adapter = client->adapter;
2451         int man_id, chip_id, config1, convrate, lhigh;
2452         const char *name = NULL;
2453         int address = client->addr;
2454         bool common_address =
2455                         (address >= 0x18 && address <= 0x1a) ||
2456                         (address >= 0x29 && address <= 0x2b) ||
2457                         (address >= 0x4c && address <= 0x4e);
2458
2459         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
2460                 return -ENODEV;
2461
2462         /*
2463          * Get well defined register value for chips with neither man_id nor
2464          * chip_id registers.
2465          */
2466         lhigh = i2c_smbus_read_byte_data(client, LM90_REG_LOCAL_HIGH);
2467
2468         /* detection and identification */
2469         man_id = i2c_smbus_read_byte_data(client, LM90_REG_MAN_ID);
2470         chip_id = i2c_smbus_read_byte_data(client, LM90_REG_CHIP_ID);
2471         config1 = i2c_smbus_read_byte_data(client, LM90_REG_CONFIG1);
2472         convrate = i2c_smbus_read_byte_data(client, LM90_REG_CONVRATE);
2473         if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0 || lhigh < 0)
2474                 return -ENODEV;
2475
2476         /* Bail out immediately if all register report the same value */
2477         if (lhigh == man_id && lhigh == chip_id && lhigh == config1 && lhigh == convrate)
2478                 return -ENODEV;
2479
2480         /*
2481          * If reading man_id and chip_id both return the same value as lhigh,
2482          * the chip may not support those registers and return the most recent read
2483          * value. Check again with a different register and handle accordingly.
2484          */
2485         if (man_id == lhigh && chip_id == lhigh) {
2486                 convrate = i2c_smbus_read_byte_data(client, LM90_REG_CONVRATE);
2487                 man_id = i2c_smbus_read_byte_data(client, LM90_REG_MAN_ID);
2488                 chip_id = i2c_smbus_read_byte_data(client, LM90_REG_CHIP_ID);
2489                 if (convrate < 0 || man_id < 0 || chip_id < 0)
2490                         return -ENODEV;
2491                 if (man_id == convrate && chip_id == convrate)
2492                         man_id = -1;
2493         }
2494         switch (man_id) {
2495         case -1:        /* Chip does not support man_id / chip_id */
2496                 if (common_address && !convrate && !(config1 & 0x7f))
2497                         name = lm90_detect_lm84(client);
2498                 break;
2499         case 0x01:      /* National Semiconductor */
2500                 name = lm90_detect_national(client, chip_id, config1, convrate);
2501                 break;
2502         case 0x1a:      /* ON */
2503                 name = lm90_detect_on(client, chip_id, config1, convrate);
2504                 break;
2505         case 0x23:      /* Genesys Logic */
2506                 if (common_address && !(config1 & 0x3f) && !(convrate & 0xf8))
2507                         name = "gl523sm";
2508                 break;
2509         case 0x41:      /* Analog Devices */
2510                 name = lm90_detect_analog(client, common_address, chip_id, config1,
2511                                           convrate);
2512                 break;
2513         case 0x47:      /* GMT */
2514                 name = lm90_detect_gmt(client, chip_id, config1, convrate);
2515                 break;
2516         case 0x49:      /* TI */
2517                 name = lm90_detect_ti49(client, common_address, chip_id, config1, convrate);
2518                 break;
2519         case 0x4d:      /* Maxim Integrated */
2520                 name = lm90_detect_maxim(client, common_address, chip_id,
2521                                          config1, convrate);
2522                 break;
2523         case 0x54:      /* ON MC1066, Microchip TC1068, TCM1617 (originally TelCom) */
2524                 if (common_address && !(config1 & 0x3f) && !(convrate & 0xf8))
2525                         name = "mc1066";
2526                 break;
2527         case 0x55:      /* TI */
2528                 name = lm90_detect_ti(client, chip_id, config1, convrate);
2529                 break;
2530         case 0x5c:      /* Winbond/Nuvoton */
2531                 name = lm90_detect_nuvoton(client, chip_id, config1, convrate);
2532                 break;
2533         case 0xa1:      /*  NXP Semiconductor/Philips */
2534                 name = lm90_detect_nxp(client, common_address, chip_id, config1, convrate);
2535                 break;
2536         case 0xff:      /* MAX1617, G767, NE1617 */
2537                 if (common_address && chip_id == 0xff && convrate < 8)
2538                         name = lm90_detect_max1617(client, config1);
2539                 break;
2540         default:
2541                 break;
2542         }
2543
2544         if (!name) {    /* identification failed */
2545                 dev_dbg(&adapter->dev,
2546                         "Unsupported chip at 0x%02x (man_id=0x%02X, chip_id=0x%02X)\n",
2547                         client->addr, man_id, chip_id);
2548                 return -ENODEV;
2549         }
2550
2551         strscpy(info->type, name, I2C_NAME_SIZE);
2552
2553         return 0;
2554 }
2555
2556 static void lm90_restore_conf(void *_data)
2557 {
2558         struct lm90_data *data = _data;
2559         struct i2c_client *client = data->client;
2560
2561         cancel_delayed_work_sync(&data->alert_work);
2562         cancel_work_sync(&data->report_work);
2563
2564         /* Restore initial configuration */
2565         if (data->flags & LM90_HAVE_CONVRATE)
2566                 lm90_write_convrate(data, data->convrate_orig);
2567         lm90_write_reg(client, LM90_REG_CONFIG1, data->config_orig);
2568 }
2569
2570 static int lm90_init_client(struct i2c_client *client, struct lm90_data *data)
2571 {
2572         struct device_node *np = client->dev.of_node;
2573         int config, convrate;
2574
2575         if (data->flags & LM90_HAVE_CONVRATE) {
2576                 convrate = lm90_read_reg(client, LM90_REG_CONVRATE);
2577                 if (convrate < 0)
2578                         return convrate;
2579                 data->convrate_orig = convrate;
2580                 lm90_set_convrate(client, data, 500); /* 500ms; 2Hz conversion rate */
2581         } else {
2582                 data->update_interval = 500;
2583         }
2584
2585         /*
2586          * Start the conversions.
2587          */
2588         config = lm90_read_reg(client, LM90_REG_CONFIG1);
2589         if (config < 0)
2590                 return config;
2591         data->config_orig = config;
2592         data->config = config;
2593
2594         /* Check Temperature Range Select */
2595         if (data->flags & LM90_HAVE_EXTENDED_TEMP) {
2596                 if (of_property_read_bool(np, "ti,extended-range-enable"))
2597                         config |= 0x04;
2598                 if (!(config & 0x04))
2599                         data->flags &= ~LM90_HAVE_EXTENDED_TEMP;
2600         }
2601
2602         /*
2603          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
2604          * 0.125 degree resolution) and range (0x08, extend range
2605          * to -64 degree) mode for the remote temperature sensor.
2606          * Note that expeciments with an actual chip do not show a difference
2607          * if bit 3 is set or not.
2608          */
2609         if (data->kind == max6680)
2610                 config |= 0x18;
2611
2612         /*
2613          * Put MAX6654 into extended range (0x20, extend minimum range from
2614          * 0 degrees to -64 degrees). Note that extended resolution is not
2615          * possible on the MAX6654 unless conversion rate is set to 1 Hz or
2616          * slower, which is intentionally not done by default.
2617          */
2618         if (data->kind == max6654)
2619                 config |= 0x20;
2620
2621         /*
2622          * Select external channel 0 for devices with three sensors
2623          */
2624         if (data->flags & LM90_HAVE_TEMP3)
2625                 config &= ~0x08;
2626
2627         /*
2628          * Interrupt is enabled by default on reset, but it may be disabled
2629          * by bootloader, unmask it.
2630          */
2631         if (client->irq)
2632                 config &= ~0x80;
2633
2634         config &= 0xBF; /* run */
2635         lm90_update_confreg(data, config);
2636
2637         return devm_add_action_or_reset(&client->dev, lm90_restore_conf, data);
2638 }
2639
2640 static bool lm90_is_tripped(struct i2c_client *client)
2641 {
2642         struct lm90_data *data = i2c_get_clientdata(client);
2643         int ret;
2644
2645         ret = lm90_update_alarms(data, true);
2646         if (ret < 0)
2647                 return false;
2648
2649         return !!data->current_alarms;
2650 }
2651
2652 static irqreturn_t lm90_irq_thread(int irq, void *dev_id)
2653 {
2654         struct i2c_client *client = dev_id;
2655
2656         if (lm90_is_tripped(client))
2657                 return IRQ_HANDLED;
2658         else
2659                 return IRQ_NONE;
2660 }
2661
2662 static void lm90_remove_pec(void *dev)
2663 {
2664         device_remove_file(dev, &dev_attr_pec);
2665 }
2666
2667 static int lm90_probe_channel_from_dt(struct i2c_client *client,
2668                                       struct device_node *child,
2669                                       struct lm90_data *data)
2670 {
2671         u32 id;
2672         s32 val;
2673         int err;
2674         struct device *dev = &client->dev;
2675
2676         err = of_property_read_u32(child, "reg", &id);
2677         if (err) {
2678                 dev_err(dev, "missing reg property of %pOFn\n", child);
2679                 return err;
2680         }
2681
2682         if (id >= MAX_CHANNELS) {
2683                 dev_err(dev, "invalid reg property value %d in %pOFn\n", id, child);
2684                 return -EINVAL;
2685         }
2686
2687         err = of_property_read_string(child, "label", &data->channel_label[id]);
2688         if (err == -ENODATA || err == -EILSEQ) {
2689                 dev_err(dev, "invalid label property in %pOFn\n", child);
2690                 return err;
2691         }
2692
2693         if (data->channel_label[id])
2694                 data->channel_config[id] |= HWMON_T_LABEL;
2695
2696         err = of_property_read_s32(child, "temperature-offset-millicelsius", &val);
2697         if (!err) {
2698                 if (id == 0) {
2699                         dev_err(dev, "temperature-offset-millicelsius can't be set for internal channel\n");
2700                         return -EINVAL;
2701                 }
2702
2703                 err = lm90_set_temp_offset(data, lm90_temp_offset_index[id], id, val);
2704                 if (err) {
2705                         dev_err(dev, "can't set temperature offset %d for channel %d (%d)\n",
2706                                 val, id, err);
2707                         return err;
2708                 }
2709         }
2710
2711         return 0;
2712 }
2713
2714 static int lm90_parse_dt_channel_info(struct i2c_client *client,
2715                                       struct lm90_data *data)
2716 {
2717         int err;
2718         struct device_node *child;
2719         struct device *dev = &client->dev;
2720         const struct device_node *np = dev->of_node;
2721
2722         for_each_child_of_node(np, child) {
2723                 if (strcmp(child->name, "channel"))
2724                         continue;
2725
2726                 err = lm90_probe_channel_from_dt(client, child, data);
2727                 if (err) {
2728                         of_node_put(child);
2729                         return err;
2730                 }
2731         }
2732
2733         return 0;
2734 }
2735
2736 static const struct hwmon_ops lm90_ops = {
2737         .is_visible = lm90_is_visible,
2738         .read = lm90_read,
2739         .read_string = lm90_read_string,
2740         .write = lm90_write,
2741 };
2742
2743 static int lm90_probe(struct i2c_client *client)
2744 {
2745         struct device *dev = &client->dev;
2746         struct i2c_adapter *adapter = client->adapter;
2747         struct hwmon_channel_info *info;
2748         struct device *hwmon_dev;
2749         struct lm90_data *data;
2750         int err;
2751
2752         err = devm_regulator_get_enable(dev, "vcc");
2753         if (err)
2754                 return dev_err_probe(dev, err, "Failed to enable regulator\n");
2755
2756         data = devm_kzalloc(dev, sizeof(struct lm90_data), GFP_KERNEL);
2757         if (!data)
2758                 return -ENOMEM;
2759
2760         data->client = client;
2761         i2c_set_clientdata(client, data);
2762         mutex_init(&data->update_lock);
2763         INIT_DELAYED_WORK(&data->alert_work, lm90_alert_work);
2764         INIT_WORK(&data->report_work, lm90_report_alarms);
2765
2766         /* Set the device type */
2767         if (client->dev.of_node)
2768                 data->kind = (uintptr_t)of_device_get_match_data(&client->dev);
2769         else
2770                 data->kind = i2c_match_id(lm90_id, client)->driver_data;
2771
2772         /*
2773          * Different devices have different alarm bits triggering the
2774          * ALERT# output
2775          */
2776         data->alert_alarms = lm90_params[data->kind].alert_alarms;
2777         data->resolution = lm90_params[data->kind].resolution ? : 11;
2778
2779         /* Set chip capabilities */
2780         data->flags = lm90_params[data->kind].flags;
2781
2782         if ((data->flags & (LM90_HAVE_PEC | LM90_HAVE_PARTIAL_PEC)) &&
2783             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_PEC))
2784                 data->flags &= ~(LM90_HAVE_PEC | LM90_HAVE_PARTIAL_PEC);
2785
2786         if ((data->flags & LM90_HAVE_PARTIAL_PEC) &&
2787             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
2788                 data->flags &= ~LM90_HAVE_PARTIAL_PEC;
2789
2790         data->chip.ops = &lm90_ops;
2791         data->chip.info = data->info;
2792
2793         data->info[0] = &data->chip_info;
2794         info = &data->chip_info;
2795         info->type = hwmon_chip;
2796         info->config = data->chip_config;
2797
2798         data->chip_config[0] = HWMON_C_REGISTER_TZ;
2799         if (data->flags & LM90_HAVE_ALARMS)
2800                 data->chip_config[0] |= HWMON_C_ALARMS;
2801         if (data->flags & LM90_HAVE_CONVRATE)
2802                 data->chip_config[0] |= HWMON_C_UPDATE_INTERVAL;
2803         if (data->flags & LM90_HAVE_FAULTQUEUE)
2804                 data->chip_config[0] |= HWMON_C_TEMP_SAMPLES;
2805         data->info[1] = &data->temp_info;
2806
2807         info = &data->temp_info;
2808         info->type = hwmon_temp;
2809         info->config = data->channel_config;
2810
2811         data->channel_config[0] = HWMON_T_INPUT | HWMON_T_MAX |
2812                 HWMON_T_MAX_ALARM;
2813         data->channel_config[1] = HWMON_T_INPUT | HWMON_T_MAX |
2814                 HWMON_T_MAX_ALARM | HWMON_T_FAULT;
2815
2816         if (data->flags & LM90_HAVE_LOW) {
2817                 data->channel_config[0] |= HWMON_T_MIN | HWMON_T_MIN_ALARM;
2818                 data->channel_config[1] |= HWMON_T_MIN | HWMON_T_MIN_ALARM;
2819         }
2820
2821         if (data->flags & LM90_HAVE_CRIT) {
2822                 data->channel_config[0] |= HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_CRIT_HYST;
2823                 data->channel_config[1] |= HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_CRIT_HYST;
2824         }
2825
2826         if (data->flags & LM90_HAVE_OFFSET)
2827                 data->channel_config[1] |= HWMON_T_OFFSET;
2828
2829         if (data->flags & LM90_HAVE_EMERGENCY) {
2830                 data->channel_config[0] |= HWMON_T_EMERGENCY |
2831                         HWMON_T_EMERGENCY_HYST;
2832                 data->channel_config[1] |= HWMON_T_EMERGENCY |
2833                         HWMON_T_EMERGENCY_HYST;
2834         }
2835
2836         if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {
2837                 data->channel_config[0] |= HWMON_T_EMERGENCY_ALARM;
2838                 data->channel_config[1] |= HWMON_T_EMERGENCY_ALARM;
2839         }
2840
2841         if (data->flags & LM90_HAVE_TEMP3) {
2842                 data->channel_config[2] = HWMON_T_INPUT |
2843                         HWMON_T_MIN | HWMON_T_MAX |
2844                         HWMON_T_CRIT | HWMON_T_CRIT_HYST |
2845                         HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
2846                         HWMON_T_CRIT_ALARM | HWMON_T_FAULT;
2847                 if (data->flags & LM90_HAVE_EMERGENCY) {
2848                         data->channel_config[2] |= HWMON_T_EMERGENCY |
2849                                 HWMON_T_EMERGENCY_HYST;
2850                 }
2851                 if (data->flags & LM90_HAVE_EMERGENCY_ALARM)
2852                         data->channel_config[2] |= HWMON_T_EMERGENCY_ALARM;
2853                 if (data->flags & LM90_HAVE_OFFSET)
2854                         data->channel_config[2] |= HWMON_T_OFFSET;
2855         }
2856
2857         data->faultqueue_mask = lm90_params[data->kind].faultqueue_mask;
2858         data->faultqueue_depth = lm90_params[data->kind].faultqueue_depth;
2859         data->reg_local_ext = lm90_params[data->kind].reg_local_ext;
2860         if (data->flags & LM90_HAVE_REMOTE_EXT)
2861                 data->reg_remote_ext = LM90_REG_REMOTE_TEMPL;
2862         data->reg_status2 = lm90_params[data->kind].reg_status2;
2863
2864         /* Set maximum conversion rate */
2865         data->max_convrate = lm90_params[data->kind].max_convrate;
2866
2867         /* Parse device-tree channel information */
2868         if (client->dev.of_node) {
2869                 err = lm90_parse_dt_channel_info(client, data);
2870                 if (err)
2871                         return err;
2872         }
2873
2874         /* Initialize the LM90 chip */
2875         err = lm90_init_client(client, data);
2876         if (err < 0) {
2877                 dev_err(dev, "Failed to initialize device\n");
2878                 return err;
2879         }
2880
2881         /*
2882          * The 'pec' attribute is attached to the i2c device and thus created
2883          * separately.
2884          */
2885         if (data->flags & (LM90_HAVE_PEC | LM90_HAVE_PARTIAL_PEC)) {
2886                 err = device_create_file(dev, &dev_attr_pec);
2887                 if (err)
2888                         return err;
2889                 err = devm_add_action_or_reset(dev, lm90_remove_pec, dev);
2890                 if (err)
2891                         return err;
2892         }
2893
2894         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
2895                                                          data, &data->chip,
2896                                                          NULL);
2897         if (IS_ERR(hwmon_dev))
2898                 return PTR_ERR(hwmon_dev);
2899
2900         data->hwmon_dev = hwmon_dev;
2901
2902         if (client->irq) {
2903                 dev_dbg(dev, "IRQ: %d\n", client->irq);
2904                 err = devm_request_threaded_irq(dev, client->irq,
2905                                                 NULL, lm90_irq_thread,
2906                                                 IRQF_ONESHOT, "lm90", client);
2907                 if (err < 0) {
2908                         dev_err(dev, "cannot request IRQ %d\n", client->irq);
2909                         return err;
2910                 }
2911         }
2912
2913         return 0;
2914 }
2915
2916 static void lm90_alert(struct i2c_client *client, enum i2c_alert_protocol type,
2917                        unsigned int flag)
2918 {
2919         if (type != I2C_PROTOCOL_SMBUS_ALERT)
2920                 return;
2921
2922         if (lm90_is_tripped(client)) {
2923                 /*
2924                  * Disable ALERT# output, because these chips don't implement
2925                  * SMBus alert correctly; they should only hold the alert line
2926                  * low briefly.
2927                  */
2928                 struct lm90_data *data = i2c_get_clientdata(client);
2929
2930                 if ((data->flags & LM90_HAVE_BROKEN_ALERT) &&
2931                     (data->current_alarms & data->alert_alarms)) {
2932                         if (!(data->config & 0x80)) {
2933                                 dev_dbg(&client->dev, "Disabling ALERT#\n");
2934                                 lm90_update_confreg(data, data->config | 0x80);
2935                         }
2936                         schedule_delayed_work(&data->alert_work,
2937                                 max_t(int, HZ, msecs_to_jiffies(data->update_interval)));
2938                 }
2939         } else {
2940                 dev_dbg(&client->dev, "Everything OK\n");
2941         }
2942 }
2943
2944 static int lm90_suspend(struct device *dev)
2945 {
2946         struct lm90_data *data = dev_get_drvdata(dev);
2947         struct i2c_client *client = data->client;
2948
2949         if (client->irq)
2950                 disable_irq(client->irq);
2951
2952         return 0;
2953 }
2954
2955 static int lm90_resume(struct device *dev)
2956 {
2957         struct lm90_data *data = dev_get_drvdata(dev);
2958         struct i2c_client *client = data->client;
2959
2960         if (client->irq)
2961                 enable_irq(client->irq);
2962
2963         return 0;
2964 }
2965
2966 static DEFINE_SIMPLE_DEV_PM_OPS(lm90_pm_ops, lm90_suspend, lm90_resume);
2967
2968 static struct i2c_driver lm90_driver = {
2969         .class          = I2C_CLASS_HWMON,
2970         .driver = {
2971                 .name   = "lm90",
2972                 .of_match_table = of_match_ptr(lm90_of_match),
2973                 .pm     = pm_sleep_ptr(&lm90_pm_ops),
2974         },
2975         .probe          = lm90_probe,
2976         .alert          = lm90_alert,
2977         .id_table       = lm90_id,
2978         .detect         = lm90_detect,
2979         .address_list   = normal_i2c,
2980 };
2981
2982 module_i2c_driver(lm90_driver);
2983
2984 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
2985 MODULE_DESCRIPTION("LM90/ADM1032 driver");
2986 MODULE_LICENSE("GPL");