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