1 /* 2 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 #include <linux/module.h> 22 #include <linux/init.h> 23 #include <linux/slab.h> 24 #include <linux/jiffies.h> 25 #include <linux/i2c.h> 26 #include <linux/hwmon.h> 27 #include <linux/hwmon-sysfs.h> 28 #include <linux/err.h> 29 #include <linux/mutex.h> 30 #include <linux/of.h> 31 #include <linux/thermal.h> 32 #include "lm75.h" 33 34 35 /* 36 * This driver handles the LM75 and compatible digital temperature sensors. 37 */ 38 39 enum lm75_type { /* keep sorted in alphabetical order */ 40 adt75, 41 ds1775, 42 ds75, 43 ds7505, 44 g751, 45 lm75, 46 lm75a, 47 lm75b, 48 max6625, 49 max6626, 50 mcp980x, 51 stds75, 52 tcn75, 53 tmp100, 54 tmp101, 55 tmp105, 56 tmp112, 57 tmp175, 58 tmp275, 59 tmp75, 60 }; 61 62 /* Addresses scanned */ 63 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 64 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 65 66 67 /* The LM75 registers */ 68 #define LM75_REG_CONF 0x01 69 static const u8 LM75_REG_TEMP[3] = { 70 0x00, /* input */ 71 0x03, /* max */ 72 0x02, /* hyst */ 73 }; 74 75 /* Each client has this additional data */ 76 struct lm75_data { 77 struct i2c_client *client; 78 struct device *hwmon_dev; 79 struct thermal_zone_device *tz; 80 struct mutex update_lock; 81 u8 orig_conf; 82 u8 resolution; /* In bits, between 9 and 12 */ 83 u8 resolution_limits; 84 char valid; /* !=0 if registers are valid */ 85 unsigned long last_updated; /* In jiffies */ 86 unsigned long sample_time; /* In jiffies */ 87 s16 temp[3]; /* Register values, 88 0 = input 89 1 = max 90 2 = hyst */ 91 }; 92 93 static int lm75_read_value(struct i2c_client *client, u8 reg); 94 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value); 95 static struct lm75_data *lm75_update_device(struct device *dev); 96 97 98 /*-----------------------------------------------------------------------*/ 99 100 static inline long lm75_reg_to_mc(s16 temp, u8 resolution) 101 { 102 return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8); 103 } 104 105 /* sysfs attributes for hwmon */ 106 107 static int lm75_read_temp(void *dev, long *temp) 108 { 109 struct lm75_data *data = lm75_update_device(dev); 110 111 if (IS_ERR(data)) 112 return PTR_ERR(data); 113 114 *temp = lm75_reg_to_mc(data->temp[0], data->resolution); 115 116 return 0; 117 } 118 119 static ssize_t show_temp(struct device *dev, struct device_attribute *da, 120 char *buf) 121 { 122 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 123 struct lm75_data *data = lm75_update_device(dev); 124 125 if (IS_ERR(data)) 126 return PTR_ERR(data); 127 128 return sprintf(buf, "%ld\n", lm75_reg_to_mc(data->temp[attr->index], 129 data->resolution)); 130 } 131 132 static ssize_t set_temp(struct device *dev, struct device_attribute *da, 133 const char *buf, size_t count) 134 { 135 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 136 struct lm75_data *data = dev_get_drvdata(dev); 137 struct i2c_client *client = data->client; 138 int nr = attr->index; 139 long temp; 140 int error; 141 u8 resolution; 142 143 error = kstrtol(buf, 10, &temp); 144 if (error) 145 return error; 146 147 /* 148 * Resolution of limit registers is assumed to be the same as the 149 * temperature input register resolution unless given explicitly. 150 */ 151 if (attr->index && data->resolution_limits) 152 resolution = data->resolution_limits; 153 else 154 resolution = data->resolution; 155 156 mutex_lock(&data->update_lock); 157 temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX); 158 data->temp[nr] = DIV_ROUND_CLOSEST(temp << (resolution - 8), 159 1000) << (16 - resolution); 160 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]); 161 mutex_unlock(&data->update_lock); 162 return count; 163 } 164 165 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, 166 show_temp, set_temp, 1); 167 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, 168 show_temp, set_temp, 2); 169 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 170 171 static struct attribute *lm75_attrs[] = { 172 &sensor_dev_attr_temp1_input.dev_attr.attr, 173 &sensor_dev_attr_temp1_max.dev_attr.attr, 174 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 175 176 NULL 177 }; 178 ATTRIBUTE_GROUPS(lm75); 179 180 /*-----------------------------------------------------------------------*/ 181 182 /* device probe and removal */ 183 184 static int 185 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id) 186 { 187 struct device *dev = &client->dev; 188 struct lm75_data *data; 189 int status; 190 u8 set_mask, clr_mask; 191 int new; 192 enum lm75_type kind = id->driver_data; 193 194 if (!i2c_check_functionality(client->adapter, 195 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 196 return -EIO; 197 198 data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL); 199 if (!data) 200 return -ENOMEM; 201 202 data->client = client; 203 i2c_set_clientdata(client, data); 204 mutex_init(&data->update_lock); 205 206 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range. 207 * Then tweak to be more precise when appropriate. 208 */ 209 set_mask = 0; 210 clr_mask = LM75_SHUTDOWN; /* continuous conversions */ 211 212 switch (kind) { 213 case adt75: 214 clr_mask |= 1 << 5; /* not one-shot mode */ 215 data->resolution = 12; 216 data->sample_time = HZ / 8; 217 break; 218 case ds1775: 219 case ds75: 220 case stds75: 221 clr_mask |= 3 << 5; 222 set_mask |= 2 << 5; /* 11-bit mode */ 223 data->resolution = 11; 224 data->sample_time = HZ; 225 break; 226 case ds7505: 227 set_mask |= 3 << 5; /* 12-bit mode */ 228 data->resolution = 12; 229 data->sample_time = HZ / 4; 230 break; 231 case g751: 232 case lm75: 233 case lm75a: 234 data->resolution = 9; 235 data->sample_time = HZ / 2; 236 break; 237 case lm75b: 238 data->resolution = 11; 239 data->sample_time = HZ / 4; 240 break; 241 case max6625: 242 data->resolution = 9; 243 data->sample_time = HZ / 4; 244 break; 245 case max6626: 246 data->resolution = 12; 247 data->resolution_limits = 9; 248 data->sample_time = HZ / 4; 249 break; 250 case tcn75: 251 data->resolution = 9; 252 data->sample_time = HZ / 8; 253 break; 254 case mcp980x: 255 data->resolution_limits = 9; 256 /* fall through */ 257 case tmp100: 258 case tmp101: 259 set_mask |= 3 << 5; /* 12-bit mode */ 260 data->resolution = 12; 261 data->sample_time = HZ; 262 clr_mask |= 1 << 7; /* not one-shot mode */ 263 break; 264 case tmp112: 265 set_mask |= 3 << 5; /* 12-bit mode */ 266 clr_mask |= 1 << 7; /* not one-shot mode */ 267 data->resolution = 12; 268 data->sample_time = HZ / 4; 269 break; 270 case tmp105: 271 case tmp175: 272 case tmp275: 273 case tmp75: 274 set_mask |= 3 << 5; /* 12-bit mode */ 275 clr_mask |= 1 << 7; /* not one-shot mode */ 276 data->resolution = 12; 277 data->sample_time = HZ / 2; 278 break; 279 } 280 281 /* configure as specified */ 282 status = lm75_read_value(client, LM75_REG_CONF); 283 if (status < 0) { 284 dev_dbg(dev, "Can't read config? %d\n", status); 285 return status; 286 } 287 data->orig_conf = status; 288 new = status & ~clr_mask; 289 new |= set_mask; 290 if (status != new) 291 lm75_write_value(client, LM75_REG_CONF, new); 292 dev_dbg(dev, "Config %02x\n", new); 293 294 data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name, 295 data, lm75_groups); 296 if (IS_ERR(data->hwmon_dev)) 297 return PTR_ERR(data->hwmon_dev); 298 299 data->tz = thermal_zone_of_sensor_register(data->hwmon_dev, 300 0, 301 data->hwmon_dev, 302 lm75_read_temp, NULL); 303 if (IS_ERR(data->tz)) 304 data->tz = NULL; 305 306 dev_info(dev, "%s: sensor '%s'\n", 307 dev_name(data->hwmon_dev), client->name); 308 309 return 0; 310 } 311 312 static int lm75_remove(struct i2c_client *client) 313 { 314 struct lm75_data *data = i2c_get_clientdata(client); 315 316 thermal_zone_of_sensor_unregister(data->hwmon_dev, data->tz); 317 hwmon_device_unregister(data->hwmon_dev); 318 lm75_write_value(client, LM75_REG_CONF, data->orig_conf); 319 return 0; 320 } 321 322 static const struct i2c_device_id lm75_ids[] = { 323 { "adt75", adt75, }, 324 { "ds1775", ds1775, }, 325 { "ds75", ds75, }, 326 { "ds7505", ds7505, }, 327 { "g751", g751, }, 328 { "lm75", lm75, }, 329 { "lm75a", lm75a, }, 330 { "lm75b", lm75b, }, 331 { "max6625", max6625, }, 332 { "max6626", max6626, }, 333 { "mcp980x", mcp980x, }, 334 { "stds75", stds75, }, 335 { "tcn75", tcn75, }, 336 { "tmp100", tmp100, }, 337 { "tmp101", tmp101, }, 338 { "tmp105", tmp105, }, 339 { "tmp112", tmp112, }, 340 { "tmp175", tmp175, }, 341 { "tmp275", tmp275, }, 342 { "tmp75", tmp75, }, 343 { /* LIST END */ } 344 }; 345 MODULE_DEVICE_TABLE(i2c, lm75_ids); 346 347 #define LM75A_ID 0xA1 348 349 /* Return 0 if detection is successful, -ENODEV otherwise */ 350 static int lm75_detect(struct i2c_client *new_client, 351 struct i2c_board_info *info) 352 { 353 struct i2c_adapter *adapter = new_client->adapter; 354 int i; 355 int conf, hyst, os; 356 bool is_lm75a = 0; 357 358 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 359 I2C_FUNC_SMBUS_WORD_DATA)) 360 return -ENODEV; 361 362 /* 363 * Now, we do the remaining detection. There is no identification- 364 * dedicated register so we have to rely on several tricks: 365 * unused bits, registers cycling over 8-address boundaries, 366 * addresses 0x04-0x07 returning the last read value. 367 * The cycling+unused addresses combination is not tested, 368 * since it would significantly slow the detection down and would 369 * hardly add any value. 370 * 371 * The National Semiconductor LM75A is different than earlier 372 * LM75s. It has an ID byte of 0xaX (where X is the chip 373 * revision, with 1 being the only revision in existence) in 374 * register 7, and unused registers return 0xff rather than the 375 * last read value. 376 * 377 * Note that this function only detects the original National 378 * Semiconductor LM75 and the LM75A. Clones from other vendors 379 * aren't detected, on purpose, because they are typically never 380 * found on PC hardware. They are found on embedded designs where 381 * they can be instantiated explicitly so detection is not needed. 382 * The absence of identification registers on all these clones 383 * would make their exhaustive detection very difficult and weak, 384 * and odds are that the driver would bind to unsupported devices. 385 */ 386 387 /* Unused bits */ 388 conf = i2c_smbus_read_byte_data(new_client, 1); 389 if (conf & 0xe0) 390 return -ENODEV; 391 392 /* First check for LM75A */ 393 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) { 394 /* LM75A returns 0xff on unused registers so 395 just to be sure we check for that too. */ 396 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff 397 || i2c_smbus_read_byte_data(new_client, 5) != 0xff 398 || i2c_smbus_read_byte_data(new_client, 6) != 0xff) 399 return -ENODEV; 400 is_lm75a = 1; 401 hyst = i2c_smbus_read_byte_data(new_client, 2); 402 os = i2c_smbus_read_byte_data(new_client, 3); 403 } else { /* Traditional style LM75 detection */ 404 /* Unused addresses */ 405 hyst = i2c_smbus_read_byte_data(new_client, 2); 406 if (i2c_smbus_read_byte_data(new_client, 4) != hyst 407 || i2c_smbus_read_byte_data(new_client, 5) != hyst 408 || i2c_smbus_read_byte_data(new_client, 6) != hyst 409 || i2c_smbus_read_byte_data(new_client, 7) != hyst) 410 return -ENODEV; 411 os = i2c_smbus_read_byte_data(new_client, 3); 412 if (i2c_smbus_read_byte_data(new_client, 4) != os 413 || i2c_smbus_read_byte_data(new_client, 5) != os 414 || i2c_smbus_read_byte_data(new_client, 6) != os 415 || i2c_smbus_read_byte_data(new_client, 7) != os) 416 return -ENODEV; 417 } 418 /* 419 * It is very unlikely that this is a LM75 if both 420 * hysteresis and temperature limit registers are 0. 421 */ 422 if (hyst == 0 && os == 0) 423 return -ENODEV; 424 425 /* Addresses cycling */ 426 for (i = 8; i <= 248; i += 40) { 427 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf 428 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst 429 || i2c_smbus_read_byte_data(new_client, i + 3) != os) 430 return -ENODEV; 431 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7) 432 != LM75A_ID) 433 return -ENODEV; 434 } 435 436 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE); 437 438 return 0; 439 } 440 441 #ifdef CONFIG_PM 442 static int lm75_suspend(struct device *dev) 443 { 444 int status; 445 struct i2c_client *client = to_i2c_client(dev); 446 status = lm75_read_value(client, LM75_REG_CONF); 447 if (status < 0) { 448 dev_dbg(&client->dev, "Can't read config? %d\n", status); 449 return status; 450 } 451 status = status | LM75_SHUTDOWN; 452 lm75_write_value(client, LM75_REG_CONF, status); 453 return 0; 454 } 455 456 static int lm75_resume(struct device *dev) 457 { 458 int status; 459 struct i2c_client *client = to_i2c_client(dev); 460 status = lm75_read_value(client, LM75_REG_CONF); 461 if (status < 0) { 462 dev_dbg(&client->dev, "Can't read config? %d\n", status); 463 return status; 464 } 465 status = status & ~LM75_SHUTDOWN; 466 lm75_write_value(client, LM75_REG_CONF, status); 467 return 0; 468 } 469 470 static const struct dev_pm_ops lm75_dev_pm_ops = { 471 .suspend = lm75_suspend, 472 .resume = lm75_resume, 473 }; 474 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops) 475 #else 476 #define LM75_DEV_PM_OPS NULL 477 #endif /* CONFIG_PM */ 478 479 static struct i2c_driver lm75_driver = { 480 .class = I2C_CLASS_HWMON, 481 .driver = { 482 .name = "lm75", 483 .pm = LM75_DEV_PM_OPS, 484 }, 485 .probe = lm75_probe, 486 .remove = lm75_remove, 487 .id_table = lm75_ids, 488 .detect = lm75_detect, 489 .address_list = normal_i2c, 490 }; 491 492 /*-----------------------------------------------------------------------*/ 493 494 /* register access */ 495 496 /* 497 * All registers are word-sized, except for the configuration register. 498 * LM75 uses a high-byte first convention, which is exactly opposite to 499 * the SMBus standard. 500 */ 501 static int lm75_read_value(struct i2c_client *client, u8 reg) 502 { 503 if (reg == LM75_REG_CONF) 504 return i2c_smbus_read_byte_data(client, reg); 505 else 506 return i2c_smbus_read_word_swapped(client, reg); 507 } 508 509 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value) 510 { 511 if (reg == LM75_REG_CONF) 512 return i2c_smbus_write_byte_data(client, reg, value); 513 else 514 return i2c_smbus_write_word_swapped(client, reg, value); 515 } 516 517 static struct lm75_data *lm75_update_device(struct device *dev) 518 { 519 struct lm75_data *data = dev_get_drvdata(dev); 520 struct i2c_client *client = data->client; 521 struct lm75_data *ret = data; 522 523 mutex_lock(&data->update_lock); 524 525 if (time_after(jiffies, data->last_updated + data->sample_time) 526 || !data->valid) { 527 int i; 528 dev_dbg(&client->dev, "Starting lm75 update\n"); 529 530 for (i = 0; i < ARRAY_SIZE(data->temp); i++) { 531 int status; 532 533 status = lm75_read_value(client, LM75_REG_TEMP[i]); 534 if (unlikely(status < 0)) { 535 dev_dbg(dev, 536 "LM75: Failed to read value: reg %d, error %d\n", 537 LM75_REG_TEMP[i], status); 538 ret = ERR_PTR(status); 539 data->valid = 0; 540 goto abort; 541 } 542 data->temp[i] = status; 543 } 544 data->last_updated = jiffies; 545 data->valid = 1; 546 } 547 548 abort: 549 mutex_unlock(&data->update_lock); 550 return ret; 551 } 552 553 module_i2c_driver(lm75_driver); 554 555 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 556 MODULE_DESCRIPTION("LM75 driver"); 557 MODULE_LICENSE("GPL"); 558