| 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; |
| 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 | devm_add_action(dev, lm75_remove, data); |
| 335 | |
| 336 | dev_dbg(dev, "Config %02x\n", new); |
| 337 | |
| 338 | hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, |
| 339 | data, lm75_groups); |
| 340 | if (IS_ERR(hwmon_dev)) |
| 341 | return PTR_ERR(hwmon_dev); |
| 342 | |
| 343 | devm_thermal_zone_of_sensor_register(hwmon_dev, 0, |
| 344 | hwmon_dev, |
| 345 | &lm75_of_thermal_ops); |
| 346 | |
| 347 | dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name); |
| 348 | |
| 349 | return 0; |
| 350 | } |
| 351 | |
| 352 | static const struct i2c_device_id lm75_ids[] = { |
| 353 | { "adt75", adt75, }, |
| 354 | { "ds1775", ds1775, }, |
| 355 | { "ds75", ds75, }, |
| 356 | { "ds7505", ds7505, }, |
| 357 | { "g751", g751, }, |
| 358 | { "lm75", lm75, }, |
| 359 | { "lm75a", lm75a, }, |
| 360 | { "lm75b", lm75b, }, |
| 361 | { "max6625", max6625, }, |
| 362 | { "max6626", max6626, }, |
| 363 | { "mcp980x", mcp980x, }, |
| 364 | { "stds75", stds75, }, |
| 365 | { "tcn75", tcn75, }, |
| 366 | { "tmp100", tmp100, }, |
| 367 | { "tmp101", tmp101, }, |
| 368 | { "tmp105", tmp105, }, |
| 369 | { "tmp112", tmp112, }, |
| 370 | { "tmp175", tmp175, }, |
| 371 | { "tmp275", tmp275, }, |
| 372 | { "tmp75", tmp75, }, |
| 373 | { "tmp75c", tmp75c, }, |
| 374 | { /* LIST END */ } |
| 375 | }; |
| 376 | MODULE_DEVICE_TABLE(i2c, lm75_ids); |
| 377 | |
| 378 | #define LM75A_ID 0xA1 |
| 379 | |
| 380 | /* Return 0 if detection is successful, -ENODEV otherwise */ |
| 381 | static int lm75_detect(struct i2c_client *new_client, |
| 382 | struct i2c_board_info *info) |
| 383 | { |
| 384 | struct i2c_adapter *adapter = new_client->adapter; |
| 385 | int i; |
| 386 | int conf, hyst, os; |
| 387 | bool is_lm75a = 0; |
| 388 | |
| 389 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | |
| 390 | I2C_FUNC_SMBUS_WORD_DATA)) |
| 391 | return -ENODEV; |
| 392 | |
| 393 | /* |
| 394 | * Now, we do the remaining detection. There is no identification- |
| 395 | * dedicated register so we have to rely on several tricks: |
| 396 | * unused bits, registers cycling over 8-address boundaries, |
| 397 | * addresses 0x04-0x07 returning the last read value. |
| 398 | * The cycling+unused addresses combination is not tested, |
| 399 | * since it would significantly slow the detection down and would |
| 400 | * hardly add any value. |
| 401 | * |
| 402 | * The National Semiconductor LM75A is different than earlier |
| 403 | * LM75s. It has an ID byte of 0xaX (where X is the chip |
| 404 | * revision, with 1 being the only revision in existence) in |
| 405 | * register 7, and unused registers return 0xff rather than the |
| 406 | * last read value. |
| 407 | * |
| 408 | * Note that this function only detects the original National |
| 409 | * Semiconductor LM75 and the LM75A. Clones from other vendors |
| 410 | * aren't detected, on purpose, because they are typically never |
| 411 | * found on PC hardware. They are found on embedded designs where |
| 412 | * they can be instantiated explicitly so detection is not needed. |
| 413 | * The absence of identification registers on all these clones |
| 414 | * would make their exhaustive detection very difficult and weak, |
| 415 | * and odds are that the driver would bind to unsupported devices. |
| 416 | */ |
| 417 | |
| 418 | /* Unused bits */ |
| 419 | conf = i2c_smbus_read_byte_data(new_client, 1); |
| 420 | if (conf & 0xe0) |
| 421 | return -ENODEV; |
| 422 | |
| 423 | /* First check for LM75A */ |
| 424 | if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) { |
| 425 | /* LM75A returns 0xff on unused registers so |
| 426 | just to be sure we check for that too. */ |
| 427 | if (i2c_smbus_read_byte_data(new_client, 4) != 0xff |
| 428 | || i2c_smbus_read_byte_data(new_client, 5) != 0xff |
| 429 | || i2c_smbus_read_byte_data(new_client, 6) != 0xff) |
| 430 | return -ENODEV; |
| 431 | is_lm75a = 1; |
| 432 | hyst = i2c_smbus_read_byte_data(new_client, 2); |
| 433 | os = i2c_smbus_read_byte_data(new_client, 3); |
| 434 | } else { /* Traditional style LM75 detection */ |
| 435 | /* Unused addresses */ |
| 436 | hyst = i2c_smbus_read_byte_data(new_client, 2); |
| 437 | if (i2c_smbus_read_byte_data(new_client, 4) != hyst |
| 438 | || i2c_smbus_read_byte_data(new_client, 5) != hyst |
| 439 | || i2c_smbus_read_byte_data(new_client, 6) != hyst |
| 440 | || i2c_smbus_read_byte_data(new_client, 7) != hyst) |
| 441 | return -ENODEV; |
| 442 | os = i2c_smbus_read_byte_data(new_client, 3); |
| 443 | if (i2c_smbus_read_byte_data(new_client, 4) != os |
| 444 | || i2c_smbus_read_byte_data(new_client, 5) != os |
| 445 | || i2c_smbus_read_byte_data(new_client, 6) != os |
| 446 | || i2c_smbus_read_byte_data(new_client, 7) != os) |
| 447 | return -ENODEV; |
| 448 | } |
| 449 | /* |
| 450 | * It is very unlikely that this is a LM75 if both |
| 451 | * hysteresis and temperature limit registers are 0. |
| 452 | */ |
| 453 | if (hyst == 0 && os == 0) |
| 454 | return -ENODEV; |
| 455 | |
| 456 | /* Addresses cycling */ |
| 457 | for (i = 8; i <= 248; i += 40) { |
| 458 | if (i2c_smbus_read_byte_data(new_client, i + 1) != conf |
| 459 | || i2c_smbus_read_byte_data(new_client, i + 2) != hyst |
| 460 | || i2c_smbus_read_byte_data(new_client, i + 3) != os) |
| 461 | return -ENODEV; |
| 462 | if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7) |
| 463 | != LM75A_ID) |
| 464 | return -ENODEV; |
| 465 | } |
| 466 | |
| 467 | strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE); |
| 468 | |
| 469 | return 0; |
| 470 | } |
| 471 | |
| 472 | #ifdef CONFIG_PM |
| 473 | static int lm75_suspend(struct device *dev) |
| 474 | { |
| 475 | int status; |
| 476 | struct i2c_client *client = to_i2c_client(dev); |
| 477 | status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); |
| 478 | if (status < 0) { |
| 479 | dev_dbg(&client->dev, "Can't read config? %d\n", status); |
| 480 | return status; |
| 481 | } |
| 482 | status = status | LM75_SHUTDOWN; |
| 483 | i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); |
| 484 | return 0; |
| 485 | } |
| 486 | |
| 487 | static int lm75_resume(struct device *dev) |
| 488 | { |
| 489 | int status; |
| 490 | struct i2c_client *client = to_i2c_client(dev); |
| 491 | status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); |
| 492 | if (status < 0) { |
| 493 | dev_dbg(&client->dev, "Can't read config? %d\n", status); |
| 494 | return status; |
| 495 | } |
| 496 | status = status & ~LM75_SHUTDOWN; |
| 497 | i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); |
| 498 | return 0; |
| 499 | } |
| 500 | |
| 501 | static const struct dev_pm_ops lm75_dev_pm_ops = { |
| 502 | .suspend = lm75_suspend, |
| 503 | .resume = lm75_resume, |
| 504 | }; |
| 505 | #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops) |
| 506 | #else |
| 507 | #define LM75_DEV_PM_OPS NULL |
| 508 | #endif /* CONFIG_PM */ |
| 509 | |
| 510 | static struct i2c_driver lm75_driver = { |
| 511 | .class = I2C_CLASS_HWMON, |
| 512 | .driver = { |
| 513 | .name = "lm75", |
| 514 | .pm = LM75_DEV_PM_OPS, |
| 515 | }, |
| 516 | .probe = lm75_probe, |
| 517 | .id_table = lm75_ids, |
| 518 | .detect = lm75_detect, |
| 519 | .address_list = normal_i2c, |
| 520 | }; |
| 521 | |
| 522 | module_i2c_driver(lm75_driver); |
| 523 | |
| 524 | MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); |
| 525 | MODULE_DESCRIPTION("LM75 driver"); |
| 526 | MODULE_LICENSE("GPL"); |