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