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