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