drivers/hwmon/tmp401.c

   1 /* tmp401.c
   2  *
   3  * Copyright (C) 2007,2008 Hans de Goede <hdegoede@redhat.com>
   4  * Preliminary tmp411 support by:
   5  * Gabriel Konat, Sander Leget, Wouter Willems
   6  * Copyright (C) 2009 Andre Prendel <andre.prendel@gmx.de>
   7  *
   8  * Cleanup and support for TMP431 and TMP432 by Guenter Roeck
   9  * Copyright (c) 2013 Guenter Roeck <linux@roeck-us.net>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 /*
  27  * Driver for the Texas Instruments TMP401 SMBUS temperature sensor IC.
  28  *
  29  * Note this IC is in some aspect similar to the LM90, but it has quite a
  30  * few differences too, for example the local temp has a higher resolution
  31  * and thus has 16 bits registers for its value and limit instead of 8 bits.
  32  */
  33
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/bitops.h>
  37 #include <linux/slab.h>
  38 #include <linux/jiffies.h>
  39 #include <linux/i2c.h>
  40 #include <linux/hwmon.h>
  41 #include <linux/hwmon-sysfs.h>
  42 #include <linux/err.h>
  43 #include <linux/mutex.h>
  44 #include <linux/sysfs.h>
  45
  46 /* Addresses to scan */
  47 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4c, 0x4d,
  48         0x4e, 0x4f, I2C_CLIENT_END };
  49
  50 enum chips { tmp401, tmp411, tmp431, tmp432, tmp435, tmp461 };
  51
  52 /*
  53  * The TMP401 registers, note some registers have different addresses for
  54  * reading and writing
  55  */
  56 #define TMP401_STATUS                           0x02
  57 #define TMP401_CONFIG_READ                      0x03
  58 #define TMP401_CONFIG_WRITE                     0x09
  59 #define TMP401_CONVERSION_RATE_READ             0x04
  60 #define TMP401_CONVERSION_RATE_WRITE            0x0A
  61 #define TMP401_TEMP_CRIT_HYST                   0x21
  62 #define TMP401_MANUFACTURER_ID_REG              0xFE
  63 #define TMP401_DEVICE_ID_REG                    0xFF
  64
  65 static const u8 TMP401_TEMP_MSB_READ[7][2] = {
  66         { 0x00, 0x01 }, /* temp */
  67         { 0x06, 0x08 }, /* low limit */
  68         { 0x05, 0x07 }, /* high limit */
  69         { 0x20, 0x19 }, /* therm (crit) limit */
  70         { 0x30, 0x34 }, /* lowest */
  71         { 0x32, 0x36 }, /* highest */
  72         { 0, 0x11 },    /* offset */
  73 };
  74
  75 static const u8 TMP401_TEMP_MSB_WRITE[7][2] = {
  76         { 0, 0 },       /* temp (unused) */
  77         { 0x0C, 0x0E }, /* low limit */
  78         { 0x0B, 0x0D }, /* high limit */
  79         { 0x20, 0x19 }, /* therm (crit) limit */
  80         { 0x30, 0x34 }, /* lowest */
  81         { 0x32, 0x36 }, /* highest */
  82         { 0, 0x11 },    /* offset */
  83 };
  84
  85 static const u8 TMP432_TEMP_MSB_READ[4][3] = {
  86         { 0x00, 0x01, 0x23 },   /* temp */
  87         { 0x06, 0x08, 0x16 },   /* low limit */
  88         { 0x05, 0x07, 0x15 },   /* high limit */
  89         { 0x20, 0x19, 0x1A },   /* therm (crit) limit */
  90 };
  91
  92 static const u8 TMP432_TEMP_MSB_WRITE[4][3] = {
  93         { 0, 0, 0 },            /* temp  - unused */
  94         { 0x0C, 0x0E, 0x16 },   /* low limit */
  95         { 0x0B, 0x0D, 0x15 },   /* high limit */
  96         { 0x20, 0x19, 0x1A },   /* therm (crit) limit */
  97 };
  98
  99 /* [0] = fault, [1] = low, [2] = high, [3] = therm/crit */
 100 static const u8 TMP432_STATUS_REG[] = {
 101         0x1b, 0x36, 0x35, 0x37 };
 102
 103 /* Flags */
 104 #define TMP401_CONFIG_RANGE                     BIT(2)
 105 #define TMP401_CONFIG_SHUTDOWN                  BIT(6)
 106 #define TMP401_STATUS_LOCAL_CRIT                BIT(0)
 107 #define TMP401_STATUS_REMOTE_CRIT               BIT(1)
 108 #define TMP401_STATUS_REMOTE_OPEN               BIT(2)
 109 #define TMP401_STATUS_REMOTE_LOW                BIT(3)
 110 #define TMP401_STATUS_REMOTE_HIGH               BIT(4)
 111 #define TMP401_STATUS_LOCAL_LOW                 BIT(5)
 112 #define TMP401_STATUS_LOCAL_HIGH                BIT(6)
 113
 114 /* On TMP432, each status has its own register */
 115 #define TMP432_STATUS_LOCAL                     BIT(0)
 116 #define TMP432_STATUS_REMOTE1                   BIT(1)
 117 #define TMP432_STATUS_REMOTE2                   BIT(2)
 118
 119 /* Manufacturer / Device ID's */
 120 #define TMP401_MANUFACTURER_ID                  0x55
 121 #define TMP401_DEVICE_ID                        0x11
 122 #define TMP411A_DEVICE_ID                       0x12
 123 #define TMP411B_DEVICE_ID                       0x13
 124 #define TMP411C_DEVICE_ID                       0x10
 125 #define TMP431_DEVICE_ID                        0x31
 126 #define TMP432_DEVICE_ID                        0x32
 127 #define TMP435_DEVICE_ID                        0x35
 128
 129 /*
 130  * Driver data (common to all clients)
 131  */
 132
 133 static const struct i2c_device_id tmp401_id[] = {
 134         { "tmp401", tmp401 },
 135         { "tmp411", tmp411 },
 136         { "tmp431", tmp431 },
 137         { "tmp432", tmp432 },
 138         { "tmp435", tmp435 },
 139         { "tmp461", tmp461 },
 140         { }
 141 };
 142 MODULE_DEVICE_TABLE(i2c, tmp401_id);
 143
 144 /*
 145  * Client data (each client gets its own)
 146  */
 147
 148 struct tmp401_data {
 149         struct i2c_client *client;
 150         const struct attribute_group *groups[3];
 151         struct mutex update_lock;
 152         char valid; /* zero until following fields are valid */
 153         unsigned long last_updated; /* in jiffies */
 154         enum chips kind;
 155
 156         unsigned int update_interval;   /* in milliseconds */
 157
 158         /* register values */
 159         u8 status[4];
 160         u8 config;
 161         u16 temp[7][3];
 162         u8 temp_crit_hyst;
 163 };
 164
 165 /*
 166  * Sysfs attr show / store functions
 167  */
 168
 169 static int tmp401_register_to_temp(u16 reg, u8 config)
 170 {
 171         int temp = reg;
 172
 173         if (config & TMP401_CONFIG_RANGE)
 174                 temp -= 64 * 256;
 175
 176         return DIV_ROUND_CLOSEST(temp * 125, 32);
 177 }
 178
 179 static u16 tmp401_temp_to_register(long temp, u8 config, int zbits)
 180 {
 181         if (config & TMP401_CONFIG_RANGE) {
 182                 temp = clamp_val(temp, -64000, 191000);
 183                 temp += 64000;
 184         } else
 185                 temp = clamp_val(temp, 0, 127000);
 186
 187         return DIV_ROUND_CLOSEST(temp * (1 << (8 - zbits)), 1000) << zbits;
 188 }
 189
 190 static int tmp401_update_device_reg16(struct i2c_client *client,
 191                                       struct tmp401_data *data)
 192 {
 193         int i, j, val;
 194         int num_regs = data->kind == tmp411 ? 6 : 4;
 195         int num_sensors = data->kind == tmp432 ? 3 : 2;
 196
 197         for (i = 0; i < num_sensors; i++) {             /* local / r1 / r2 */
 198                 for (j = 0; j < num_regs; j++) {        /* temp / low / ... */
 199                         u8 regaddr;
 200
 201                         regaddr = data->kind == tmp432 ?
 202                                                 TMP432_TEMP_MSB_READ[j][i] :
 203                                                 TMP401_TEMP_MSB_READ[j][i];
 204                         if (j == 3) { /* crit is msb only */
 205                                 val = i2c_smbus_read_byte_data(client, regaddr);
 206                         } else {
 207                                 val = i2c_smbus_read_word_swapped(client,
 208                                                                   regaddr);
 209                         }
 210                         if (val < 0)
 211                                 return val;
 212
 213                         data->temp[j][i] = j == 3 ? val << 8 : val;
 214                 }
 215         }
 216         return 0;
 217 }
 218
 219 static struct tmp401_data *tmp401_update_device(struct device *dev)
 220 {
 221         struct tmp401_data *data = dev_get_drvdata(dev);
 222         struct i2c_client *client = data->client;
 223         struct tmp401_data *ret = data;
 224         int i, val;
 225         unsigned long next_update;
 226
 227         mutex_lock(&data->update_lock);
 228
 229         next_update = data->last_updated +
 230                       msecs_to_jiffies(data->update_interval);
 231         if (time_after(jiffies, next_update) || !data->valid) {
 232                 if (data->kind != tmp432) {
 233                         /*
 234                          * The driver uses the TMP432 status format internally.
 235                          * Convert status to TMP432 format for other chips.
 236                          */
 237                         val = i2c_smbus_read_byte_data(client, TMP401_STATUS);
 238                         if (val < 0) {
 239                                 ret = ERR_PTR(val);
 240                                 goto abort;
 241                         }
 242                         data->status[0] =
 243                           (val & TMP401_STATUS_REMOTE_OPEN) >> 1;
 244                         data->status[1] =
 245                           ((val & TMP401_STATUS_REMOTE_LOW) >> 2) |
 246                           ((val & TMP401_STATUS_LOCAL_LOW) >> 5);
 247                         data->status[2] =
 248                           ((val & TMP401_STATUS_REMOTE_HIGH) >> 3) |
 249                           ((val & TMP401_STATUS_LOCAL_HIGH) >> 6);
 250                         data->status[3] = val & (TMP401_STATUS_LOCAL_CRIT
 251                                                 | TMP401_STATUS_REMOTE_CRIT);
 252                 } else {
 253                         for (i = 0; i < ARRAY_SIZE(data->status); i++) {
 254                                 val = i2c_smbus_read_byte_data(client,
 255                                                         TMP432_STATUS_REG[i]);
 256                                 if (val < 0) {
 257                                         ret = ERR_PTR(val);
 258                                         goto abort;
 259                                 }
 260                                 data->status[i] = val;
 261                         }
 262                 }
 263
 264                 val = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
 265                 if (val < 0) {
 266                         ret = ERR_PTR(val);
 267                         goto abort;
 268                 }
 269                 data->config = val;
 270                 val = tmp401_update_device_reg16(client, data);
 271                 if (val < 0) {
 272                         ret = ERR_PTR(val);
 273                         goto abort;
 274                 }
 275                 val = i2c_smbus_read_byte_data(client, TMP401_TEMP_CRIT_HYST);
 276                 if (val < 0) {
 277                         ret = ERR_PTR(val);
 278                         goto abort;
 279                 }
 280                 data->temp_crit_hyst = val;
 281
 282                 data->last_updated = jiffies;
 283                 data->valid = 1;
 284         }
 285
 286 abort:
 287         mutex_unlock(&data->update_lock);
 288         return ret;
 289 }
 290
 291 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
 292                          char *buf)
 293 {
 294         int nr = to_sensor_dev_attr_2(devattr)->nr;
 295         int index = to_sensor_dev_attr_2(devattr)->index;
 296         struct tmp401_data *data = tmp401_update_device(dev);
 297
 298         if (IS_ERR(data))
 299                 return PTR_ERR(data);
 300
 301         return sprintf(buf, "%d\n",
 302                 tmp401_register_to_temp(data->temp[nr][index], data->config));
 303 }
 304
 305 static ssize_t temp_crit_hyst_show(struct device *dev,
 306                                    struct device_attribute *devattr,
 307                                    char *buf)
 308 {
 309         int temp, index = to_sensor_dev_attr(devattr)->index;
 310         struct tmp401_data *data = tmp401_update_device(dev);
 311
 312         if (IS_ERR(data))
 313                 return PTR_ERR(data);
 314
 315         mutex_lock(&data->update_lock);
 316         temp = tmp401_register_to_temp(data->temp[3][index], data->config);
 317         temp -= data->temp_crit_hyst * 1000;
 318         mutex_unlock(&data->update_lock);
 319
 320         return sprintf(buf, "%d\n", temp);
 321 }
 322
 323 static ssize_t status_show(struct device *dev,
 324                            struct device_attribute *devattr, char *buf)
 325 {
 326         int nr = to_sensor_dev_attr_2(devattr)->nr;
 327         int mask = to_sensor_dev_attr_2(devattr)->index;
 328         struct tmp401_data *data = tmp401_update_device(dev);
 329
 330         if (IS_ERR(data))
 331                 return PTR_ERR(data);
 332
 333         return sprintf(buf, "%d\n", !!(data->status[nr] & mask));
 334 }
 335
 336 static ssize_t temp_store(struct device *dev,
 337                           struct device_attribute *devattr, const char *buf,
 338                           size_t count)
 339 {
 340         int nr = to_sensor_dev_attr_2(devattr)->nr;
 341         int index = to_sensor_dev_attr_2(devattr)->index;
 342         struct tmp401_data *data = dev_get_drvdata(dev);
 343         struct i2c_client *client = data->client;
 344         long val;
 345         u16 reg;
 346         u8 regaddr;
 347
 348         if (kstrtol(buf, 10, &val))
 349                 return -EINVAL;
 350
 351         reg = tmp401_temp_to_register(val, data->config, nr == 3 ? 8 : 4);
 352
 353         mutex_lock(&data->update_lock);
 354
 355         regaddr = data->kind == tmp432 ? TMP432_TEMP_MSB_WRITE[nr][index]
 356                                        : TMP401_TEMP_MSB_WRITE[nr][index];
 357         if (nr == 3) { /* crit is msb only */
 358                 i2c_smbus_write_byte_data(client, regaddr, reg >> 8);
 359         } else {
 360                 /* Hardware expects big endian data --> use _swapped */
 361                 i2c_smbus_write_word_swapped(client, regaddr, reg);
 362         }
 363         data->temp[nr][index] = reg;
 364
 365         mutex_unlock(&data->update_lock);
 366
 367         return count;
 368 }
 369
 370 static ssize_t temp_crit_hyst_store(struct device *dev,
 371                                     struct device_attribute *devattr,
 372                                     const char *buf, size_t count)
 373 {
 374         int temp, index = to_sensor_dev_attr(devattr)->index;
 375         struct tmp401_data *data = tmp401_update_device(dev);
 376         long val;
 377         u8 reg;
 378
 379         if (IS_ERR(data))
 380                 return PTR_ERR(data);
 381
 382         if (kstrtol(buf, 10, &val))
 383                 return -EINVAL;
 384
 385         if (data->config & TMP401_CONFIG_RANGE)
 386                 val = clamp_val(val, -64000, 191000);
 387         else
 388                 val = clamp_val(val, 0, 127000);
 389
 390         mutex_lock(&data->update_lock);
 391         temp = tmp401_register_to_temp(data->temp[3][index], data->config);
 392         val = clamp_val(val, temp - 255000, temp);
 393         reg = ((temp - val) + 500) / 1000;
 394
 395         i2c_smbus_write_byte_data(data->client, TMP401_TEMP_CRIT_HYST,
 396                                   reg);
 397
 398         data->temp_crit_hyst = reg;
 399
 400         mutex_unlock(&data->update_lock);
 401
 402         return count;
 403 }
 404
 405 /*
 406  * Resets the historical measurements of minimum and maximum temperatures.
 407  * This is done by writing any value to any of the minimum/maximum registers
 408  * (0x30-0x37).
 409  */
 410 static ssize_t reset_temp_history_store(struct device *dev,
 411                                         struct device_attribute *devattr,
 412                                         const char *buf, size_t count)
 413 {
 414         struct tmp401_data *data = dev_get_drvdata(dev);
 415         struct i2c_client *client = data->client;
 416         long val;
 417
 418         if (kstrtol(buf, 10, &val))
 419                 return -EINVAL;
 420
 421         if (val != 1) {
 422                 dev_err(dev,
 423                         "temp_reset_history value %ld not supported. Use 1 to reset the history!\n",
 424                         val);
 425                 return -EINVAL;
 426         }
 427         mutex_lock(&data->update_lock);
 428         i2c_smbus_write_byte_data(client, TMP401_TEMP_MSB_WRITE[5][0], val);
 429         data->valid = 0;
 430         mutex_unlock(&data->update_lock);
 431
 432         return count;
 433 }
 434
 435 static ssize_t update_interval_show(struct device *dev,
 436                                     struct device_attribute *attr, char *buf)
 437 {
 438         struct tmp401_data *data = dev_get_drvdata(dev);
 439
 440         return sprintf(buf, "%u\n", data->update_interval);
 441 }
 442
 443 static ssize_t update_interval_store(struct device *dev,
 444                                      struct device_attribute *attr,
 445                                      const char *buf, size_t count)
 446 {
 447         struct tmp401_data *data = dev_get_drvdata(dev);
 448         struct i2c_client *client = data->client;
 449         unsigned long val;
 450         int err, rate;
 451
 452         err = kstrtoul(buf, 10, &val);
 453         if (err)
 454                 return err;
 455
 456         /*
 457          * For valid rates, interval can be calculated as
 458          *      interval = (1 << (7 - rate)) * 125;
 459          * Rounded rate is therefore
 460          *      rate = 7 - __fls(interval * 4 / (125 * 3));
 461          * Use clamp_val() to avoid overflows, and to ensure valid input
 462          * for __fls.
 463          */
 464         val = clamp_val(val, 125, 16000);
 465         rate = 7 - __fls(val * 4 / (125 * 3));
 466         mutex_lock(&data->update_lock);
 467         i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, rate);
 468         data->update_interval = (1 << (7 - rate)) * 125;
 469         mutex_unlock(&data->update_lock);
 470
 471         return count;
 472 }
 473
 474 static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, 0, 0);
 475 static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, 1, 0);
 476 static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 2, 0);
 477 static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, 3, 0);
 478 static SENSOR_DEVICE_ATTR_RW(temp1_crit_hyst, temp_crit_hyst, 0);
 479 static SENSOR_DEVICE_ATTR_2_RO(temp1_min_alarm, status, 1,
 480                                TMP432_STATUS_LOCAL);
 481 static SENSOR_DEVICE_ATTR_2_RO(temp1_max_alarm, status, 2,
 482                                TMP432_STATUS_LOCAL);
 483 static SENSOR_DEVICE_ATTR_2_RO(temp1_crit_alarm, status, 3,
 484                                TMP432_STATUS_LOCAL);
 485 static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, 0, 1);
 486 static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, 1, 1);
 487 static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 2, 1);
 488 static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, 3, 1);
 489 static SENSOR_DEVICE_ATTR_RO(temp2_crit_hyst, temp_crit_hyst, 1);
 490 static SENSOR_DEVICE_ATTR_2_RO(temp2_fault, status, 0, TMP432_STATUS_REMOTE1);
 491 static SENSOR_DEVICE_ATTR_2_RO(temp2_min_alarm, status, 1,
 492                                TMP432_STATUS_REMOTE1);
 493 static SENSOR_DEVICE_ATTR_2_RO(temp2_max_alarm, status, 2,
 494                                TMP432_STATUS_REMOTE1);
 495 static SENSOR_DEVICE_ATTR_2_RO(temp2_crit_alarm, status, 3,
 496                                TMP432_STATUS_REMOTE1);
 497
 498 static DEVICE_ATTR_RW(update_interval);
 499
 500 static struct attribute *tmp401_attributes[] = {
 501         &sensor_dev_attr_temp1_input.dev_attr.attr,
 502         &sensor_dev_attr_temp1_min.dev_attr.attr,
 503         &sensor_dev_attr_temp1_max.dev_attr.attr,
 504         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 505         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 506         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 507         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 508         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 509
 510         &sensor_dev_attr_temp2_input.dev_attr.attr,
 511         &sensor_dev_attr_temp2_min.dev_attr.attr,
 512         &sensor_dev_attr_temp2_max.dev_attr.attr,
 513         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 514         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 515         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 516         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 517         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 518         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 519
 520         &dev_attr_update_interval.attr,
 521
 522         NULL
 523 };
 524
 525 static const struct attribute_group tmp401_group = {
 526         .attrs = tmp401_attributes,
 527 };
 528
 529 /*
 530  * Additional features of the TMP411 chip.
 531  * The TMP411 stores the minimum and maximum
 532  * temperature measured since power-on, chip-reset, or
 533  * minimum and maximum register reset for both the local
 534  * and remote channels.
 535  */
 536 static SENSOR_DEVICE_ATTR_2_RO(temp1_lowest, temp, 4, 0);
 537 static SENSOR_DEVICE_ATTR_2_RO(temp1_highest, temp, 5, 0);
 538 static SENSOR_DEVICE_ATTR_2_RO(temp2_lowest, temp, 4, 1);
 539 static SENSOR_DEVICE_ATTR_2_RO(temp2_highest, temp, 5, 1);
 540 static SENSOR_DEVICE_ATTR_WO(temp_reset_history, reset_temp_history, 0);
 541
 542 static struct attribute *tmp411_attributes[] = {
 543         &sensor_dev_attr_temp1_highest.dev_attr.attr,
 544         &sensor_dev_attr_temp1_lowest.dev_attr.attr,
 545         &sensor_dev_attr_temp2_highest.dev_attr.attr,
 546         &sensor_dev_attr_temp2_lowest.dev_attr.attr,
 547         &sensor_dev_attr_temp_reset_history.dev_attr.attr,
 548         NULL
 549 };
 550
 551 static const struct attribute_group tmp411_group = {
 552         .attrs = tmp411_attributes,
 553 };
 554
 555 static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, 0, 2);
 556 static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, 1, 2);
 557 static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 2, 2);
 558 static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, 3, 2);
 559 static SENSOR_DEVICE_ATTR_RO(temp3_crit_hyst, temp_crit_hyst, 2);
 560 static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, status, 0, TMP432_STATUS_REMOTE2);
 561 static SENSOR_DEVICE_ATTR_2_RO(temp3_min_alarm, status, 1,
 562                                TMP432_STATUS_REMOTE2);
 563 static SENSOR_DEVICE_ATTR_2_RO(temp3_max_alarm, status, 2,
 564                                TMP432_STATUS_REMOTE2);
 565 static SENSOR_DEVICE_ATTR_2_RO(temp3_crit_alarm, status, 3,
 566                                TMP432_STATUS_REMOTE2);
 567
 568 static struct attribute *tmp432_attributes[] = {
 569         &sensor_dev_attr_temp3_input.dev_attr.attr,
 570         &sensor_dev_attr_temp3_min.dev_attr.attr,
 571         &sensor_dev_attr_temp3_max.dev_attr.attr,
 572         &sensor_dev_attr_temp3_crit.dev_attr.attr,
 573         &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
 574         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 575         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
 576         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
 577         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
 578
 579         NULL
 580 };
 581
 582 static const struct attribute_group tmp432_group = {
 583         .attrs = tmp432_attributes,
 584 };
 585
 586 /*
 587  * Additional features of the TMP461 chip.
 588  * The TMP461 temperature offset for the remote channel.
 589  */
 590 static SENSOR_DEVICE_ATTR_2_RW(temp2_offset, temp, 6, 1);
 591
 592 static struct attribute *tmp461_attributes[] = {
 593         &sensor_dev_attr_temp2_offset.dev_attr.attr,
 594         NULL
 595 };
 596
 597 static const struct attribute_group tmp461_group = {
 598         .attrs = tmp461_attributes,
 599 };
 600
 601 /*
 602  * Begin non sysfs callback code (aka Real code)
 603  */
 604
 605 static int tmp401_init_client(struct tmp401_data *data,
 606                               struct i2c_client *client)
 607 {
 608         int config, config_orig, status = 0;
 609
 610         /* Set the conversion rate to 2 Hz */
 611         i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, 5);
 612         data->update_interval = 500;
 613
 614         /* Start conversions (disable shutdown if necessary) */
 615         config = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
 616         if (config < 0)
 617                 return config;
 618
 619         config_orig = config;
 620         config &= ~TMP401_CONFIG_SHUTDOWN;
 621
 622         if (config != config_orig)
 623                 status = i2c_smbus_write_byte_data(client,
 624                                                    TMP401_CONFIG_WRITE,
 625                                                    config);
 626
 627         return status;
 628 }
 629
 630 static int tmp401_detect(struct i2c_client *client,
 631                          struct i2c_board_info *info)
 632 {
 633         enum chips kind;
 634         struct i2c_adapter *adapter = client->adapter;
 635         u8 reg;
 636
 637         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 638                 return -ENODEV;
 639
 640         /* Detect and identify the chip */
 641         reg = i2c_smbus_read_byte_data(client, TMP401_MANUFACTURER_ID_REG);
 642         if (reg != TMP401_MANUFACTURER_ID)
 643                 return -ENODEV;
 644
 645         reg = i2c_smbus_read_byte_data(client, TMP401_DEVICE_ID_REG);
 646
 647         switch (reg) {
 648         case TMP401_DEVICE_ID:
 649                 if (client->addr != 0x4c)
 650                         return -ENODEV;
 651                 kind = tmp401;
 652                 break;
 653         case TMP411A_DEVICE_ID:
 654                 if (client->addr != 0x4c)
 655                         return -ENODEV;
 656                 kind = tmp411;
 657                 break;
 658         case TMP411B_DEVICE_ID:
 659                 if (client->addr != 0x4d)
 660                         return -ENODEV;
 661                 kind = tmp411;
 662                 break;
 663         case TMP411C_DEVICE_ID:
 664                 if (client->addr != 0x4e)
 665                         return -ENODEV;
 666                 kind = tmp411;
 667                 break;
 668         case TMP431_DEVICE_ID:
 669                 if (client->addr != 0x4c && client->addr != 0x4d)
 670                         return -ENODEV;
 671                 kind = tmp431;
 672                 break;
 673         case TMP432_DEVICE_ID:
 674                 if (client->addr != 0x4c && client->addr != 0x4d)
 675                         return -ENODEV;
 676                 kind = tmp432;
 677                 break;
 678         case TMP435_DEVICE_ID:
 679                 kind = tmp435;
 680                 break;
 681         default:
 682                 return -ENODEV;
 683         }
 684
 685         reg = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
 686         if (reg & 0x1b)
 687                 return -ENODEV;
 688
 689         reg = i2c_smbus_read_byte_data(client, TMP401_CONVERSION_RATE_READ);
 690         /* Datasheet says: 0x1-0x6 */
 691         if (reg > 15)
 692                 return -ENODEV;
 693
 694         strlcpy(info->type, tmp401_id[kind].name, I2C_NAME_SIZE);
 695
 696         return 0;
 697 }
 698
 699 static int tmp401_probe(struct i2c_client *client,
 700                         const struct i2c_device_id *id)
 701 {
 702         static const char * const names[] = {
 703                 "TMP401", "TMP411", "TMP431", "TMP432", "TMP435", "TMP461"
 704         };
 705         struct device *dev = &client->dev;
 706         struct device *hwmon_dev;
 707         struct tmp401_data *data;
 708         int groups = 0, status;
 709
 710         data = devm_kzalloc(dev, sizeof(struct tmp401_data), GFP_KERNEL);
 711         if (!data)
 712                 return -ENOMEM;
 713
 714         data->client = client;
 715         mutex_init(&data->update_lock);
 716         data->kind = id->driver_data;
 717
 718         /* Initialize the TMP401 chip */
 719         status = tmp401_init_client(data, client);
 720         if (status < 0)
 721                 return status;
 722
 723         /* Register sysfs hooks */
 724         data->groups[groups++] = &tmp401_group;
 725
 726         /* Register additional tmp411 sysfs hooks */
 727         if (data->kind == tmp411)
 728                 data->groups[groups++] = &tmp411_group;
 729
 730         /* Register additional tmp432 sysfs hooks */
 731         if (data->kind == tmp432)
 732                 data->groups[groups++] = &tmp432_group;
 733
 734         if (data->kind == tmp461)
 735                 data->groups[groups++] = &tmp461_group;
 736
 737         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 738                                                            data, data->groups);
 739         if (IS_ERR(hwmon_dev))
 740                 return PTR_ERR(hwmon_dev);
 741
 742         dev_info(dev, "Detected TI %s chip\n", names[data->kind]);
 743
 744         return 0;
 745 }
 746
 747 static struct i2c_driver tmp401_driver = {
 748         .class          = I2C_CLASS_HWMON,
 749         .driver = {
 750                 .name   = "tmp401",
 751         },
 752         .probe          = tmp401_probe,
 753         .id_table       = tmp401_id,
 754         .detect         = tmp401_detect,
 755         .address_list   = normal_i2c,
 756 };
 757
 758 module_i2c_driver(tmp401_driver);
 759
 760 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 761 MODULE_DESCRIPTION("Texas Instruments TMP401 temperature sensor driver");
 762 MODULE_LICENSE("GPL");