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