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