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 show_temp(struct device *dev,
 292                          struct device_attribute *devattr, 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 show_temp_crit_hyst(struct device *dev,
 306         struct device_attribute *devattr, char *buf)
 307 {
 308         int temp, index = to_sensor_dev_attr(devattr)->index;
 309         struct tmp401_data *data = tmp401_update_device(dev);
 310
 311         if (IS_ERR(data))
 312                 return PTR_ERR(data);
 313
 314         mutex_lock(&data->update_lock);
 315         temp = tmp401_register_to_temp(data->temp[3][index], data->config);
 316         temp -= data->temp_crit_hyst * 1000;
 317         mutex_unlock(&data->update_lock);
 318
 319         return sprintf(buf, "%d\n", temp);
 320 }
 321
 322 static ssize_t show_status(struct device *dev,
 323         struct device_attribute *devattr, char *buf)
 324 {
 325         int nr = to_sensor_dev_attr_2(devattr)->nr;
 326         int mask = to_sensor_dev_attr_2(devattr)->index;
 327         struct tmp401_data *data = tmp401_update_device(dev);
 328
 329         if (IS_ERR(data))
 330                 return PTR_ERR(data);
 331
 332         return sprintf(buf, "%d\n", !!(data->status[nr] & mask));
 333 }
 334
 335 static ssize_t store_temp(struct device *dev, struct device_attribute *devattr,
 336                           const char *buf, size_t count)
 337 {
 338         int nr = to_sensor_dev_attr_2(devattr)->nr;
 339         int index = to_sensor_dev_attr_2(devattr)->index;
 340         struct tmp401_data *data = dev_get_drvdata(dev);
 341         struct i2c_client *client = data->client;
 342         long val;
 343         u16 reg;
 344         u8 regaddr;
 345
 346         if (kstrtol(buf, 10, &val))
 347                 return -EINVAL;
 348
 349         reg = tmp401_temp_to_register(val, data->config, nr == 3 ? 8 : 4);
 350
 351         mutex_lock(&data->update_lock);
 352
 353         regaddr = data->kind == tmp432 ? TMP432_TEMP_MSB_WRITE[nr][index]
 354                                        : TMP401_TEMP_MSB_WRITE[nr][index];
 355         if (nr == 3) { /* crit is msb only */
 356                 i2c_smbus_write_byte_data(client, regaddr, reg >> 8);
 357         } else {
 358                 /* Hardware expects big endian data --> use _swapped */
 359                 i2c_smbus_write_word_swapped(client, regaddr, reg);
 360         }
 361         data->temp[nr][index] = reg;
 362
 363         mutex_unlock(&data->update_lock);
 364
 365         return count;
 366 }
 367
 368 static ssize_t store_temp_crit_hyst(struct device *dev, struct device_attribute
 369         *devattr, const char *buf, size_t count)
 370 {
 371         int temp, index = to_sensor_dev_attr(devattr)->index;
 372         struct tmp401_data *data = tmp401_update_device(dev);
 373         long val;
 374         u8 reg;
 375
 376         if (IS_ERR(data))
 377                 return PTR_ERR(data);
 378
 379         if (kstrtol(buf, 10, &val))
 380                 return -EINVAL;
 381
 382         if (data->config & TMP401_CONFIG_RANGE)
 383                 val = clamp_val(val, -64000, 191000);
 384         else
 385                 val = clamp_val(val, 0, 127000);
 386
 387         mutex_lock(&data->update_lock);
 388         temp = tmp401_register_to_temp(data->temp[3][index], data->config);
 389         val = clamp_val(val, temp - 255000, temp);
 390         reg = ((temp - val) + 500) / 1000;
 391
 392         i2c_smbus_write_byte_data(data->client, TMP401_TEMP_CRIT_HYST,
 393                                   reg);
 394
 395         data->temp_crit_hyst = reg;
 396
 397         mutex_unlock(&data->update_lock);
 398
 399         return count;
 400 }
 401
 402 /*
 403  * Resets the historical measurements of minimum and maximum temperatures.
 404  * This is done by writing any value to any of the minimum/maximum registers
 405  * (0x30-0x37).
 406  */
 407 static ssize_t reset_temp_history(struct device *dev,
 408         struct device_attribute *devattr, const char *buf, size_t count)
 409 {
 410         struct tmp401_data *data = dev_get_drvdata(dev);
 411         struct i2c_client *client = data->client;
 412         long val;
 413
 414         if (kstrtol(buf, 10, &val))
 415                 return -EINVAL;
 416
 417         if (val != 1) {
 418                 dev_err(dev,
 419                         "temp_reset_history value %ld not supported. Use 1 to reset the history!\n",
 420                         val);
 421                 return -EINVAL;
 422         }
 423         mutex_lock(&data->update_lock);
 424         i2c_smbus_write_byte_data(client, TMP401_TEMP_MSB_WRITE[5][0], val);
 425         data->valid = 0;
 426         mutex_unlock(&data->update_lock);
 427
 428         return count;
 429 }
 430
 431 static ssize_t update_interval_show(struct device *dev,
 432                                     struct device_attribute *attr, char *buf)
 433 {
 434         struct tmp401_data *data = dev_get_drvdata(dev);
 435
 436         return sprintf(buf, "%u\n", data->update_interval);
 437 }
 438
 439 static ssize_t update_interval_store(struct device *dev,
 440                                      struct device_attribute *attr,
 441                                      const char *buf, size_t count)
 442 {
 443         struct tmp401_data *data = dev_get_drvdata(dev);
 444         struct i2c_client *client = data->client;
 445         unsigned long val;
 446         int err, rate;
 447
 448         err = kstrtoul(buf, 10, &val);
 449         if (err)
 450                 return err;
 451
 452         /*
 453          * For valid rates, interval can be calculated as
 454          *      interval = (1 << (7 - rate)) * 125;
 455          * Rounded rate is therefore
 456          *      rate = 7 - __fls(interval * 4 / (125 * 3));
 457          * Use clamp_val() to avoid overflows, and to ensure valid input
 458          * for __fls.
 459          */
 460         val = clamp_val(val, 125, 16000);
 461         rate = 7 - __fls(val * 4 / (125 * 3));
 462         mutex_lock(&data->update_lock);
 463         i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, rate);
 464         data->update_interval = (1 << (7 - rate)) * 125;
 465         mutex_unlock(&data->update_lock);
 466
 467         return count;
 468 }
 469
 470 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0);
 471 static SENSOR_DEVICE_ATTR_2(temp1_min, S_IWUSR | S_IRUGO, show_temp,
 472                             store_temp, 1, 0);
 473 static SENSOR_DEVICE_ATTR_2(temp1_max, S_IWUSR | S_IRUGO, show_temp,
 474                             store_temp, 2, 0);
 475 static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IWUSR | S_IRUGO, show_temp,
 476                             store_temp, 3, 0);
 477 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO,
 478                           show_temp_crit_hyst, store_temp_crit_hyst, 0);
 479 static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, show_status, NULL,
 480                             1, TMP432_STATUS_LOCAL);
 481 static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, show_status, NULL,
 482                             2, TMP432_STATUS_LOCAL);
 483 static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, show_status, NULL,
 484                             3, TMP432_STATUS_LOCAL);
 485 static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0, 1);
 486 static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp,
 487                             store_temp, 1, 1);
 488 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp,
 489                             store_temp, 2, 1);
 490 static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IWUSR | S_IRUGO, show_temp,
 491                             store_temp, 3, 1);
 492 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temp_crit_hyst,
 493                           NULL, 1);
 494 static SENSOR_DEVICE_ATTR_2(temp2_fault, S_IRUGO, show_status, NULL,
 495                             0, TMP432_STATUS_REMOTE1);
 496 static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, show_status, NULL,
 497                             1, TMP432_STATUS_REMOTE1);
 498 static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, show_status, NULL,
 499                             2, TMP432_STATUS_REMOTE1);
 500 static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, show_status, NULL,
 501                             3, TMP432_STATUS_REMOTE1);
 502
 503 static DEVICE_ATTR_RW(update_interval);
 504
 505 static struct attribute *tmp401_attributes[] = {
 506         &sensor_dev_attr_temp1_input.dev_attr.attr,
 507         &sensor_dev_attr_temp1_min.dev_attr.attr,
 508         &sensor_dev_attr_temp1_max.dev_attr.attr,
 509         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 510         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 511         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 512         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 513         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 514
 515         &sensor_dev_attr_temp2_input.dev_attr.attr,
 516         &sensor_dev_attr_temp2_min.dev_attr.attr,
 517         &sensor_dev_attr_temp2_max.dev_attr.attr,
 518         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 519         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 520         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 521         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 522         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 523         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 524
 525         &dev_attr_update_interval.attr,
 526
 527         NULL
 528 };
 529
 530 static const struct attribute_group tmp401_group = {
 531         .attrs = tmp401_attributes,
 532 };
 533
 534 /*
 535  * Additional features of the TMP411 chip.
 536  * The TMP411 stores the minimum and maximum
 537  * temperature measured since power-on, chip-reset, or
 538  * minimum and maximum register reset for both the local
 539  * and remote channels.
 540  */
 541 static SENSOR_DEVICE_ATTR_2(temp1_lowest, S_IRUGO, show_temp, NULL, 4, 0);
 542 static SENSOR_DEVICE_ATTR_2(temp1_highest, S_IRUGO, show_temp, NULL, 5, 0);
 543 static SENSOR_DEVICE_ATTR_2(temp2_lowest, S_IRUGO, show_temp, NULL, 4, 1);
 544 static SENSOR_DEVICE_ATTR_2(temp2_highest, S_IRUGO, show_temp, NULL, 5, 1);
 545 static SENSOR_DEVICE_ATTR(temp_reset_history, S_IWUSR, NULL, reset_temp_history,
 546                           0);
 547
 548 static struct attribute *tmp411_attributes[] = {
 549         &sensor_dev_attr_temp1_highest.dev_attr.attr,
 550         &sensor_dev_attr_temp1_lowest.dev_attr.attr,
 551         &sensor_dev_attr_temp2_highest.dev_attr.attr,
 552         &sensor_dev_attr_temp2_lowest.dev_attr.attr,
 553         &sensor_dev_attr_temp_reset_history.dev_attr.attr,
 554         NULL
 555 };
 556
 557 static const struct attribute_group tmp411_group = {
 558         .attrs = tmp411_attributes,
 559 };
 560
 561 static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 0, 2);
 562 static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp,
 563                             store_temp, 1, 2);
 564 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp,
 565                             store_temp, 2, 2);
 566 static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IWUSR | S_IRUGO, show_temp,
 567                             store_temp, 3, 2);
 568 static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temp_crit_hyst,
 569                           NULL, 2);
 570 static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_status, NULL,
 571                             0, TMP432_STATUS_REMOTE2);
 572 static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, show_status, NULL,
 573                             1, TMP432_STATUS_REMOTE2);
 574 static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, show_status, NULL,
 575                             2, TMP432_STATUS_REMOTE2);
 576 static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, show_status, NULL,
 577                             3, TMP432_STATUS_REMOTE2);
 578
 579 static struct attribute *tmp432_attributes[] = {
 580         &sensor_dev_attr_temp3_input.dev_attr.attr,
 581         &sensor_dev_attr_temp3_min.dev_attr.attr,
 582         &sensor_dev_attr_temp3_max.dev_attr.attr,
 583         &sensor_dev_attr_temp3_crit.dev_attr.attr,
 584         &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
 585         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 586         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
 587         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
 588         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
 589
 590         NULL
 591 };
 592
 593 static const struct attribute_group tmp432_group = {
 594         .attrs = tmp432_attributes,
 595 };
 596
 597 /*
 598  * Additional features of the TMP461 chip.
 599  * The TMP461 temperature offset for the remote channel.
 600  */
 601 static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp,
 602                             store_temp, 6, 1);
 603
 604 static struct attribute *tmp461_attributes[] = {
 605         &sensor_dev_attr_temp2_offset.dev_attr.attr,
 606         NULL
 607 };
 608
 609 static const struct attribute_group tmp461_group = {
 610         .attrs = tmp461_attributes,
 611 };
 612
 613 /*
 614  * Begin non sysfs callback code (aka Real code)
 615  */
 616
 617 static int tmp401_init_client(struct tmp401_data *data,
 618                               struct i2c_client *client)
 619 {
 620         int config, config_orig, status = 0;
 621
 622         /* Set the conversion rate to 2 Hz */
 623         i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, 5);
 624         data->update_interval = 500;
 625
 626         /* Start conversions (disable shutdown if necessary) */
 627         config = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
 628         if (config < 0)
 629                 return config;
 630
 631         config_orig = config;
 632         config &= ~TMP401_CONFIG_SHUTDOWN;
 633
 634         if (config != config_orig)
 635                 status = i2c_smbus_write_byte_data(client,
 636                                                    TMP401_CONFIG_WRITE,
 637                                                    config);
 638
 639         return status;
 640 }
 641
 642 static int tmp401_detect(struct i2c_client *client,
 643                          struct i2c_board_info *info)
 644 {
 645         enum chips kind;
 646         struct i2c_adapter *adapter = client->adapter;
 647         u8 reg;
 648
 649         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 650                 return -ENODEV;
 651
 652         /* Detect and identify the chip */
 653         reg = i2c_smbus_read_byte_data(client, TMP401_MANUFACTURER_ID_REG);
 654         if (reg != TMP401_MANUFACTURER_ID)
 655                 return -ENODEV;
 656
 657         reg = i2c_smbus_read_byte_data(client, TMP401_DEVICE_ID_REG);
 658
 659         switch (reg) {
 660         case TMP401_DEVICE_ID:
 661                 if (client->addr != 0x4c)
 662                         return -ENODEV;
 663                 kind = tmp401;
 664                 break;
 665         case TMP411A_DEVICE_ID:
 666                 if (client->addr != 0x4c)
 667                         return -ENODEV;
 668                 kind = tmp411;
 669                 break;
 670         case TMP411B_DEVICE_ID:
 671                 if (client->addr != 0x4d)
 672                         return -ENODEV;
 673                 kind = tmp411;
 674                 break;
 675         case TMP411C_DEVICE_ID:
 676                 if (client->addr != 0x4e)
 677                         return -ENODEV;
 678                 kind = tmp411;
 679                 break;
 680         case TMP431_DEVICE_ID:
 681                 if (client->addr != 0x4c && client->addr != 0x4d)
 682                         return -ENODEV;
 683                 kind = tmp431;
 684                 break;
 685         case TMP432_DEVICE_ID:
 686                 if (client->addr != 0x4c && client->addr != 0x4d)
 687                         return -ENODEV;
 688                 kind = tmp432;
 689                 break;
 690         case TMP435_DEVICE_ID:
 691                 kind = tmp435;
 692                 break;
 693         default:
 694                 return -ENODEV;
 695         }
 696
 697         reg = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
 698         if (reg & 0x1b)
 699                 return -ENODEV;
 700
 701         reg = i2c_smbus_read_byte_data(client, TMP401_CONVERSION_RATE_READ);
 702         /* Datasheet says: 0x1-0x6 */
 703         if (reg > 15)
 704                 return -ENODEV;
 705
 706         strlcpy(info->type, tmp401_id[kind].name, I2C_NAME_SIZE);
 707
 708         return 0;
 709 }
 710
 711 static int tmp401_probe(struct i2c_client *client,
 712                         const struct i2c_device_id *id)
 713 {
 714         static const char * const names[] = {
 715                 "TMP401", "TMP411", "TMP431", "TMP432", "TMP435", "TMP461"
 716         };
 717         struct device *dev = &client->dev;
 718         struct device *hwmon_dev;
 719         struct tmp401_data *data;
 720         int groups = 0, status;
 721
 722         data = devm_kzalloc(dev, sizeof(struct tmp401_data), GFP_KERNEL);
 723         if (!data)
 724                 return -ENOMEM;
 725
 726         data->client = client;
 727         mutex_init(&data->update_lock);
 728         data->kind = id->driver_data;
 729
 730         /* Initialize the TMP401 chip */
 731         status = tmp401_init_client(data, client);
 732         if (status < 0)
 733                 return status;
 734
 735         /* Register sysfs hooks */
 736         data->groups[groups++] = &tmp401_group;
 737
 738         /* Register additional tmp411 sysfs hooks */
 739         if (data->kind == tmp411)
 740                 data->groups[groups++] = &tmp411_group;
 741
 742         /* Register additional tmp432 sysfs hooks */
 743         if (data->kind == tmp432)
 744                 data->groups[groups++] = &tmp432_group;
 745
 746         if (data->kind == tmp461)
 747                 data->groups[groups++] = &tmp461_group;
 748
 749         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 750                                                            data, data->groups);
 751         if (IS_ERR(hwmon_dev))
 752                 return PTR_ERR(hwmon_dev);
 753
 754         dev_info(dev, "Detected TI %s chip\n", names[data->kind]);
 755
 756         return 0;
 757 }
 758
 759 static struct i2c_driver tmp401_driver = {
 760         .class          = I2C_CLASS_HWMON,
 761         .driver = {
 762                 .name   = "tmp401",
 763         },
 764         .probe          = tmp401_probe,
 765         .id_table       = tmp401_id,
 766         .detect         = tmp401_detect,
 767         .address_list   = normal_i2c,
 768 };
 769
 770 module_i2c_driver(tmp401_driver);
 771
 772 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 773 MODULE_DESCRIPTION("Texas Instruments TMP401 temperature sensor driver");
 774 MODULE_LICENSE("GPL");