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[] = { 0x4c, 0x4d, 0x4e, I2C_CLIENT_END }; 48 49 enum chips { tmp401, tmp411, tmp431, tmp432 }; 50 51 /* 52 * The TMP401 registers, note some registers have different addresses for 53 * reading and writing 54 */ 55 #define TMP401_STATUS 0x02 56 #define TMP401_CONFIG_READ 0x03 57 #define TMP401_CONFIG_WRITE 0x09 58 #define TMP401_CONVERSION_RATE_READ 0x04 59 #define TMP401_CONVERSION_RATE_WRITE 0x0A 60 #define TMP401_TEMP_CRIT_HYST 0x21 61 #define TMP401_MANUFACTURER_ID_REG 0xFE 62 #define TMP401_DEVICE_ID_REG 0xFF 63 64 static const u8 TMP401_TEMP_MSB_READ[6][2] = { 65 { 0x00, 0x01 }, /* temp */ 66 { 0x06, 0x08 }, /* low limit */ 67 { 0x05, 0x07 }, /* high limit */ 68 { 0x20, 0x19 }, /* therm (crit) limit */ 69 { 0x30, 0x34 }, /* lowest */ 70 { 0x32, 0x36 }, /* highest */ 71 }; 72 73 static const u8 TMP401_TEMP_MSB_WRITE[6][2] = { 74 { 0, 0 }, /* temp (unused) */ 75 { 0x0C, 0x0E }, /* low limit */ 76 { 0x0B, 0x0D }, /* high limit */ 77 { 0x20, 0x19 }, /* therm (crit) limit */ 78 { 0x30, 0x34 }, /* lowest */ 79 { 0x32, 0x36 }, /* highest */ 80 }; 81 82 static const u8 TMP401_TEMP_LSB[6][2] = { 83 { 0x15, 0x10 }, /* temp */ 84 { 0x17, 0x14 }, /* low limit */ 85 { 0x16, 0x13 }, /* high limit */ 86 { 0, 0 }, /* therm (crit) limit (unused) */ 87 { 0x31, 0x35 }, /* lowest */ 88 { 0x33, 0x37 }, /* highest */ 89 }; 90 91 static const u8 TMP432_TEMP_MSB_READ[4][3] = { 92 { 0x00, 0x01, 0x23 }, /* temp */ 93 { 0x06, 0x08, 0x16 }, /* low limit */ 94 { 0x05, 0x07, 0x15 }, /* high limit */ 95 { 0x20, 0x19, 0x1A }, /* therm (crit) limit */ 96 }; 97 98 static const u8 TMP432_TEMP_MSB_WRITE[4][3] = { 99 { 0, 0, 0 }, /* temp - unused */ 100 { 0x0C, 0x0E, 0x16 }, /* low limit */ 101 { 0x0B, 0x0D, 0x15 }, /* high limit */ 102 { 0x20, 0x19, 0x1A }, /* therm (crit) limit */ 103 }; 104 105 static const u8 TMP432_TEMP_LSB[3][3] = { 106 { 0x29, 0x10, 0x24 }, /* temp */ 107 { 0x3E, 0x14, 0x18 }, /* low limit */ 108 { 0x3D, 0x13, 0x17 }, /* high limit */ 109 }; 110 111 /* [0] = fault, [1] = low, [2] = high, [3] = therm/crit */ 112 static const u8 TMP432_STATUS_REG[] = { 113 0x1b, 0x36, 0x35, 0x37 }; 114 115 /* Flags */ 116 #define TMP401_CONFIG_RANGE BIT(2) 117 #define TMP401_CONFIG_SHUTDOWN BIT(6) 118 #define TMP401_STATUS_LOCAL_CRIT BIT(0) 119 #define TMP401_STATUS_REMOTE_CRIT BIT(1) 120 #define TMP401_STATUS_REMOTE_OPEN BIT(2) 121 #define TMP401_STATUS_REMOTE_LOW BIT(3) 122 #define TMP401_STATUS_REMOTE_HIGH BIT(4) 123 #define TMP401_STATUS_LOCAL_LOW BIT(5) 124 #define TMP401_STATUS_LOCAL_HIGH BIT(6) 125 126 /* On TMP432, each status has its own register */ 127 #define TMP432_STATUS_LOCAL BIT(0) 128 #define TMP432_STATUS_REMOTE1 BIT(1) 129 #define TMP432_STATUS_REMOTE2 BIT(2) 130 131 /* Manufacturer / Device ID's */ 132 #define TMP401_MANUFACTURER_ID 0x55 133 #define TMP401_DEVICE_ID 0x11 134 #define TMP411A_DEVICE_ID 0x12 135 #define TMP411B_DEVICE_ID 0x13 136 #define TMP411C_DEVICE_ID 0x10 137 #define TMP431_DEVICE_ID 0x31 138 #define TMP432_DEVICE_ID 0x32 139 140 /* 141 * Driver data (common to all clients) 142 */ 143 144 static const struct i2c_device_id tmp401_id[] = { 145 { "tmp401", tmp401 }, 146 { "tmp411", tmp411 }, 147 { "tmp431", tmp431 }, 148 { "tmp432", tmp432 }, 149 { } 150 }; 151 MODULE_DEVICE_TABLE(i2c, tmp401_id); 152 153 /* 154 * Client data (each client gets its own) 155 */ 156 157 struct tmp401_data { 158 struct device *hwmon_dev; 159 struct mutex update_lock; 160 char valid; /* zero until following fields are valid */ 161 unsigned long last_updated; /* in jiffies */ 162 enum chips kind; 163 164 unsigned int update_interval; /* in milliseconds */ 165 166 /* register values */ 167 u8 status[4]; 168 u8 config; 169 u16 temp[6][3]; 170 u8 temp_crit_hyst; 171 }; 172 173 /* 174 * Sysfs attr show / store functions 175 */ 176 177 static int tmp401_register_to_temp(u16 reg, u8 config) 178 { 179 int temp = reg; 180 181 if (config & TMP401_CONFIG_RANGE) 182 temp -= 64 * 256; 183 184 return DIV_ROUND_CLOSEST(temp * 125, 32); 185 } 186 187 static u16 tmp401_temp_to_register(long temp, u8 config, int zbits) 188 { 189 if (config & TMP401_CONFIG_RANGE) { 190 temp = clamp_val(temp, -64000, 191000); 191 temp += 64000; 192 } else 193 temp = clamp_val(temp, 0, 127000); 194 195 return DIV_ROUND_CLOSEST(temp * (1 << (8 - zbits)), 1000) << zbits; 196 } 197 198 static int tmp401_update_device_reg16(struct i2c_client *client, 199 struct tmp401_data *data) 200 { 201 int i, j, val; 202 int num_regs = data->kind == tmp411 ? 6 : 4; 203 int num_sensors = data->kind == tmp432 ? 3 : 2; 204 205 for (i = 0; i < num_sensors; i++) { /* local / r1 / r2 */ 206 for (j = 0; j < num_regs; j++) { /* temp / low / ... */ 207 u8 regaddr; 208 /* 209 * High byte must be read first immediately followed 210 * by the low byte 211 */ 212 regaddr = data->kind == tmp432 ? 213 TMP432_TEMP_MSB_READ[j][i] : 214 TMP401_TEMP_MSB_READ[j][i]; 215 val = i2c_smbus_read_byte_data(client, regaddr); 216 if (val < 0) 217 return val; 218 data->temp[j][i] = val << 8; 219 if (j == 3) /* crit is msb only */ 220 continue; 221 regaddr = data->kind == tmp432 ? TMP432_TEMP_LSB[j][i] 222 : TMP401_TEMP_LSB[j][i]; 223 val = i2c_smbus_read_byte_data(client, regaddr); 224 if (val < 0) 225 return val; 226 data->temp[j][i] |= val; 227 } 228 } 229 return 0; 230 } 231 232 static struct tmp401_data *tmp401_update_device(struct device *dev) 233 { 234 struct i2c_client *client = to_i2c_client(dev); 235 struct tmp401_data *data = i2c_get_clientdata(client); 236 struct tmp401_data *ret = data; 237 int i, val; 238 unsigned long next_update; 239 240 mutex_lock(&data->update_lock); 241 242 next_update = data->last_updated + 243 msecs_to_jiffies(data->update_interval); 244 if (time_after(jiffies, next_update) || !data->valid) { 245 if (data->kind != tmp432) { 246 /* 247 * The driver uses the TMP432 status format internally. 248 * Convert status to TMP432 format for other chips. 249 */ 250 val = i2c_smbus_read_byte_data(client, TMP401_STATUS); 251 if (val < 0) { 252 ret = ERR_PTR(val); 253 goto abort; 254 } 255 data->status[0] = 256 (val & TMP401_STATUS_REMOTE_OPEN) >> 1; 257 data->status[1] = 258 ((val & TMP401_STATUS_REMOTE_LOW) >> 2) | 259 ((val & TMP401_STATUS_LOCAL_LOW) >> 5); 260 data->status[2] = 261 ((val & TMP401_STATUS_REMOTE_HIGH) >> 3) | 262 ((val & TMP401_STATUS_LOCAL_HIGH) >> 6); 263 data->status[3] = val & (TMP401_STATUS_LOCAL_CRIT 264 | TMP401_STATUS_REMOTE_CRIT); 265 } else { 266 for (i = 0; i < ARRAY_SIZE(data->status); i++) { 267 val = i2c_smbus_read_byte_data(client, 268 TMP432_STATUS_REG[i]); 269 if (val < 0) { 270 ret = ERR_PTR(val); 271 goto abort; 272 } 273 data->status[i] = val; 274 } 275 } 276 277 val = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ); 278 if (val < 0) { 279 ret = ERR_PTR(val); 280 goto abort; 281 } 282 data->config = val; 283 val = tmp401_update_device_reg16(client, data); 284 if (val < 0) { 285 ret = ERR_PTR(val); 286 goto abort; 287 } 288 val = i2c_smbus_read_byte_data(client, TMP401_TEMP_CRIT_HYST); 289 if (val < 0) { 290 ret = ERR_PTR(val); 291 goto abort; 292 } 293 data->temp_crit_hyst = val; 294 295 data->last_updated = jiffies; 296 data->valid = 1; 297 } 298 299 abort: 300 mutex_unlock(&data->update_lock); 301 return ret; 302 } 303 304 static ssize_t show_temp(struct device *dev, 305 struct device_attribute *devattr, char *buf) 306 { 307 int nr = to_sensor_dev_attr_2(devattr)->nr; 308 int index = to_sensor_dev_attr_2(devattr)->index; 309 struct tmp401_data *data = tmp401_update_device(dev); 310 311 if (IS_ERR(data)) 312 return PTR_ERR(data); 313 314 return sprintf(buf, "%d\n", 315 tmp401_register_to_temp(data->temp[nr][index], data->config)); 316 } 317 318 static ssize_t show_temp_crit_hyst(struct device *dev, 319 struct device_attribute *devattr, char *buf) 320 { 321 int temp, index = to_sensor_dev_attr(devattr)->index; 322 struct tmp401_data *data = tmp401_update_device(dev); 323 324 if (IS_ERR(data)) 325 return PTR_ERR(data); 326 327 mutex_lock(&data->update_lock); 328 temp = tmp401_register_to_temp(data->temp[3][index], data->config); 329 temp -= data->temp_crit_hyst * 1000; 330 mutex_unlock(&data->update_lock); 331 332 return sprintf(buf, "%d\n", temp); 333 } 334 335 static ssize_t show_status(struct device *dev, 336 struct device_attribute *devattr, char *buf) 337 { 338 int nr = to_sensor_dev_attr_2(devattr)->nr; 339 int mask = to_sensor_dev_attr_2(devattr)->index; 340 struct tmp401_data *data = tmp401_update_device(dev); 341 342 if (IS_ERR(data)) 343 return PTR_ERR(data); 344 345 return sprintf(buf, "%d\n", !!(data->status[nr] & mask)); 346 } 347 348 static ssize_t store_temp(struct device *dev, struct device_attribute *devattr, 349 const char *buf, size_t count) 350 { 351 int nr = to_sensor_dev_attr_2(devattr)->nr; 352 int index = to_sensor_dev_attr_2(devattr)->index; 353 struct i2c_client *client = to_i2c_client(dev); 354 struct tmp401_data *data = tmp401_update_device(dev); 355 long val; 356 u16 reg; 357 u8 regaddr; 358 359 if (IS_ERR(data)) 360 return PTR_ERR(data); 361 362 if (kstrtol(buf, 10, &val)) 363 return -EINVAL; 364 365 reg = tmp401_temp_to_register(val, data->config, nr == 3 ? 8 : 4); 366 367 mutex_lock(&data->update_lock); 368 369 regaddr = data->kind == tmp432 ? TMP432_TEMP_MSB_WRITE[nr][index] 370 : TMP401_TEMP_MSB_WRITE[nr][index]; 371 i2c_smbus_write_byte_data(client, regaddr, reg >> 8); 372 if (nr != 3) { 373 regaddr = data->kind == tmp432 ? TMP432_TEMP_LSB[nr][index] 374 : TMP401_TEMP_LSB[nr][index]; 375 i2c_smbus_write_byte_data(client, regaddr, reg & 0xFF); 376 } 377 data->temp[nr][index] = reg; 378 379 mutex_unlock(&data->update_lock); 380 381 return count; 382 } 383 384 static ssize_t store_temp_crit_hyst(struct device *dev, struct device_attribute 385 *devattr, const char *buf, size_t count) 386 { 387 int temp, index = to_sensor_dev_attr(devattr)->index; 388 struct tmp401_data *data = tmp401_update_device(dev); 389 long val; 390 u8 reg; 391 392 if (IS_ERR(data)) 393 return PTR_ERR(data); 394 395 if (kstrtol(buf, 10, &val)) 396 return -EINVAL; 397 398 if (data->config & TMP401_CONFIG_RANGE) 399 val = clamp_val(val, -64000, 191000); 400 else 401 val = clamp_val(val, 0, 127000); 402 403 mutex_lock(&data->update_lock); 404 temp = tmp401_register_to_temp(data->temp[3][index], data->config); 405 val = clamp_val(val, temp - 255000, temp); 406 reg = ((temp - val) + 500) / 1000; 407 408 i2c_smbus_write_byte_data(to_i2c_client(dev), TMP401_TEMP_CRIT_HYST, 409 reg); 410 411 data->temp_crit_hyst = reg; 412 413 mutex_unlock(&data->update_lock); 414 415 return count; 416 } 417 418 /* 419 * Resets the historical measurements of minimum and maximum temperatures. 420 * This is done by writing any value to any of the minimum/maximum registers 421 * (0x30-0x37). 422 */ 423 static ssize_t reset_temp_history(struct device *dev, 424 struct device_attribute *devattr, const char *buf, size_t count) 425 { 426 struct i2c_client *client = to_i2c_client(dev); 427 struct tmp401_data *data = i2c_get_clientdata(client); 428 long val; 429 430 if (kstrtol(buf, 10, &val)) 431 return -EINVAL; 432 433 if (val != 1) { 434 dev_err(dev, 435 "temp_reset_history value %ld not supported. Use 1 to reset the history!\n", 436 val); 437 return -EINVAL; 438 } 439 mutex_lock(&data->update_lock); 440 i2c_smbus_write_byte_data(client, TMP401_TEMP_MSB_WRITE[5][0], val); 441 data->valid = 0; 442 mutex_unlock(&data->update_lock); 443 444 return count; 445 } 446 447 static ssize_t show_update_interval(struct device *dev, 448 struct device_attribute *attr, char *buf) 449 { 450 struct i2c_client *client = to_i2c_client(dev); 451 struct tmp401_data *data = i2c_get_clientdata(client); 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 i2c_client *client = to_i2c_client(dev); 461 struct tmp401_data *data = i2c_get_clientdata(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 void tmp401_init_client(struct i2c_client *client) 620 { 621 int config, config_orig; 622 struct tmp401_data *data = i2c_get_clientdata(client); 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 dev_warn(&client->dev, "Initialization failed!\n"); 632 return; 633 } 634 635 config_orig = config; 636 config &= ~TMP401_CONFIG_SHUTDOWN; 637 638 if (config != config_orig) 639 i2c_smbus_write_byte_data(client, TMP401_CONFIG_WRITE, config); 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 == 0x4e) 682 return -ENODEV; 683 kind = tmp431; 684 break; 685 case TMP432_DEVICE_ID: 686 if (client->addr == 0x4e) 687 return -ENODEV; 688 kind = tmp432; 689 break; 690 default: 691 return -ENODEV; 692 } 693 694 reg = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ); 695 if (reg & 0x1b) 696 return -ENODEV; 697 698 reg = i2c_smbus_read_byte_data(client, TMP401_CONVERSION_RATE_READ); 699 /* Datasheet says: 0x1-0x6 */ 700 if (reg > 15) 701 return -ENODEV; 702 703 strlcpy(info->type, tmp401_id[kind].name, I2C_NAME_SIZE); 704 705 return 0; 706 } 707 708 static int tmp401_remove(struct i2c_client *client) 709 { 710 struct device *dev = &client->dev; 711 struct tmp401_data *data = i2c_get_clientdata(client); 712 713 if (data->hwmon_dev) 714 hwmon_device_unregister(data->hwmon_dev); 715 716 sysfs_remove_group(&dev->kobj, &tmp401_group); 717 718 if (data->kind == tmp411) 719 sysfs_remove_group(&dev->kobj, &tmp411_group); 720 721 if (data->kind == tmp432) 722 sysfs_remove_group(&dev->kobj, &tmp432_group); 723 724 return 0; 725 } 726 727 static int tmp401_probe(struct i2c_client *client, 728 const struct i2c_device_id *id) 729 { 730 struct device *dev = &client->dev; 731 int err; 732 struct tmp401_data *data; 733 const char *names[] = { "TMP401", "TMP411", "TMP431", "TMP432" }; 734 735 data = devm_kzalloc(dev, sizeof(struct tmp401_data), GFP_KERNEL); 736 if (!data) 737 return -ENOMEM; 738 739 i2c_set_clientdata(client, data); 740 mutex_init(&data->update_lock); 741 data->kind = id->driver_data; 742 743 /* Initialize the TMP401 chip */ 744 tmp401_init_client(client); 745 746 /* Register sysfs hooks */ 747 err = sysfs_create_group(&dev->kobj, &tmp401_group); 748 if (err) 749 return err; 750 751 /* Register additional tmp411 sysfs hooks */ 752 if (data->kind == tmp411) { 753 err = sysfs_create_group(&dev->kobj, &tmp411_group); 754 if (err) 755 goto exit_remove; 756 } 757 758 /* Register additional tmp432 sysfs hooks */ 759 if (data->kind == tmp432) { 760 err = sysfs_create_group(&dev->kobj, &tmp432_group); 761 if (err) 762 goto exit_remove; 763 } 764 765 data->hwmon_dev = hwmon_device_register(dev); 766 if (IS_ERR(data->hwmon_dev)) { 767 err = PTR_ERR(data->hwmon_dev); 768 data->hwmon_dev = NULL; 769 goto exit_remove; 770 } 771 772 dev_info(dev, "Detected TI %s chip\n", names[data->kind]); 773 774 return 0; 775 776 exit_remove: 777 tmp401_remove(client); 778 return err; 779 } 780 781 static struct i2c_driver tmp401_driver = { 782 .class = I2C_CLASS_HWMON, 783 .driver = { 784 .name = "tmp401", 785 }, 786 .probe = tmp401_probe, 787 .remove = tmp401_remove, 788 .id_table = tmp401_id, 789 .detect = tmp401_detect, 790 .address_list = normal_i2c, 791 }; 792 793 module_i2c_driver(tmp401_driver); 794 795 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 796 MODULE_DESCRIPTION("Texas Instruments TMP401 temperature sensor driver"); 797 MODULE_LICENSE("GPL"); 798