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 "lm75.h" 31 32 33 /* 34 * This driver handles the LM75 and compatible digital temperature sensors. 35 */ 36 37 enum lm75_type { /* keep sorted in alphabetical order */ 38 ds1775, 39 ds75, 40 lm75, 41 lm75a, 42 max6625, 43 max6626, 44 mcp980x, 45 stds75, 46 tcn75, 47 tmp100, 48 tmp101, 49 tmp105, 50 tmp175, 51 tmp275, 52 tmp75, 53 }; 54 55 /* Addresses scanned */ 56 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 57 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 58 59 60 /* The LM75 registers */ 61 #define LM75_REG_CONF 0x01 62 static const u8 LM75_REG_TEMP[3] = { 63 0x00, /* input */ 64 0x03, /* max */ 65 0x02, /* hyst */ 66 }; 67 68 /* Each client has this additional data */ 69 struct lm75_data { 70 struct device *hwmon_dev; 71 struct mutex update_lock; 72 u8 orig_conf; 73 char valid; /* !=0 if registers are valid */ 74 unsigned long last_updated; /* In jiffies */ 75 u16 temp[3]; /* Register values, 76 0 = input 77 1 = max 78 2 = hyst */ 79 }; 80 81 static int lm75_read_value(struct i2c_client *client, u8 reg); 82 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value); 83 static struct lm75_data *lm75_update_device(struct device *dev); 84 85 86 /*-----------------------------------------------------------------------*/ 87 88 /* sysfs attributes for hwmon */ 89 90 static ssize_t show_temp(struct device *dev, struct device_attribute *da, 91 char *buf) 92 { 93 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 94 struct lm75_data *data = lm75_update_device(dev); 95 return sprintf(buf, "%d\n", 96 LM75_TEMP_FROM_REG(data->temp[attr->index])); 97 } 98 99 static ssize_t set_temp(struct device *dev, struct device_attribute *da, 100 const char *buf, size_t count) 101 { 102 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 103 struct i2c_client *client = to_i2c_client(dev); 104 struct lm75_data *data = i2c_get_clientdata(client); 105 int nr = attr->index; 106 long temp; 107 int error; 108 109 error = strict_strtol(buf, 10, &temp); 110 if (error) 111 return error; 112 113 mutex_lock(&data->update_lock); 114 data->temp[nr] = LM75_TEMP_TO_REG(temp); 115 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]); 116 mutex_unlock(&data->update_lock); 117 return count; 118 } 119 120 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, 121 show_temp, set_temp, 1); 122 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, 123 show_temp, set_temp, 2); 124 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 125 126 static struct attribute *lm75_attributes[] = { 127 &sensor_dev_attr_temp1_input.dev_attr.attr, 128 &sensor_dev_attr_temp1_max.dev_attr.attr, 129 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 130 131 NULL 132 }; 133 134 static const struct attribute_group lm75_group = { 135 .attrs = lm75_attributes, 136 }; 137 138 /*-----------------------------------------------------------------------*/ 139 140 /* device probe and removal */ 141 142 static int 143 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id) 144 { 145 struct lm75_data *data; 146 int status; 147 u8 set_mask, clr_mask; 148 int new; 149 150 if (!i2c_check_functionality(client->adapter, 151 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 152 return -EIO; 153 154 data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL); 155 if (!data) 156 return -ENOMEM; 157 158 i2c_set_clientdata(client, data); 159 mutex_init(&data->update_lock); 160 161 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range. 162 * Then tweak to be more precise when appropriate. 163 */ 164 set_mask = 0; 165 clr_mask = (1 << 0) /* continuous conversions */ 166 | (1 << 6) | (1 << 5); /* 9-bit mode */ 167 168 /* configure as specified */ 169 status = lm75_read_value(client, LM75_REG_CONF); 170 if (status < 0) { 171 dev_dbg(&client->dev, "Can't read config? %d\n", status); 172 goto exit_free; 173 } 174 data->orig_conf = status; 175 new = status & ~clr_mask; 176 new |= set_mask; 177 if (status != new) 178 lm75_write_value(client, LM75_REG_CONF, new); 179 dev_dbg(&client->dev, "Config %02x\n", new); 180 181 /* Register sysfs hooks */ 182 status = sysfs_create_group(&client->dev.kobj, &lm75_group); 183 if (status) 184 goto exit_free; 185 186 data->hwmon_dev = hwmon_device_register(&client->dev); 187 if (IS_ERR(data->hwmon_dev)) { 188 status = PTR_ERR(data->hwmon_dev); 189 goto exit_remove; 190 } 191 192 dev_info(&client->dev, "%s: sensor '%s'\n", 193 dev_name(data->hwmon_dev), client->name); 194 195 return 0; 196 197 exit_remove: 198 sysfs_remove_group(&client->dev.kobj, &lm75_group); 199 exit_free: 200 kfree(data); 201 return status; 202 } 203 204 static int lm75_remove(struct i2c_client *client) 205 { 206 struct lm75_data *data = i2c_get_clientdata(client); 207 208 hwmon_device_unregister(data->hwmon_dev); 209 sysfs_remove_group(&client->dev.kobj, &lm75_group); 210 lm75_write_value(client, LM75_REG_CONF, data->orig_conf); 211 kfree(data); 212 return 0; 213 } 214 215 static const struct i2c_device_id lm75_ids[] = { 216 { "ds1775", ds1775, }, 217 { "ds75", ds75, }, 218 { "lm75", lm75, }, 219 { "lm75a", lm75a, }, 220 { "max6625", max6625, }, 221 { "max6626", max6626, }, 222 { "mcp980x", mcp980x, }, 223 { "stds75", stds75, }, 224 { "tcn75", tcn75, }, 225 { "tmp100", tmp100, }, 226 { "tmp101", tmp101, }, 227 { "tmp105", tmp105, }, 228 { "tmp175", tmp175, }, 229 { "tmp275", tmp275, }, 230 { "tmp75", tmp75, }, 231 { /* LIST END */ } 232 }; 233 MODULE_DEVICE_TABLE(i2c, lm75_ids); 234 235 #define LM75A_ID 0xA1 236 237 /* Return 0 if detection is successful, -ENODEV otherwise */ 238 static int lm75_detect(struct i2c_client *new_client, 239 struct i2c_board_info *info) 240 { 241 struct i2c_adapter *adapter = new_client->adapter; 242 int i; 243 int conf, hyst, os; 244 bool is_lm75a = 0; 245 246 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 247 I2C_FUNC_SMBUS_WORD_DATA)) 248 return -ENODEV; 249 250 /* Now, we do the remaining detection. There is no identification- 251 dedicated register so we have to rely on several tricks: 252 unused bits, registers cycling over 8-address boundaries, 253 addresses 0x04-0x07 returning the last read value. 254 The cycling+unused addresses combination is not tested, 255 since it would significantly slow the detection down and would 256 hardly add any value. 257 258 The National Semiconductor LM75A is different than earlier 259 LM75s. It has an ID byte of 0xaX (where X is the chip 260 revision, with 1 being the only revision in existence) in 261 register 7, and unused registers return 0xff rather than the 262 last read value. */ 263 264 /* Unused bits */ 265 conf = i2c_smbus_read_byte_data(new_client, 1); 266 if (conf & 0xe0) 267 return -ENODEV; 268 269 /* First check for LM75A */ 270 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) { 271 /* LM75A returns 0xff on unused registers so 272 just to be sure we check for that too. */ 273 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff 274 || i2c_smbus_read_byte_data(new_client, 5) != 0xff 275 || i2c_smbus_read_byte_data(new_client, 6) != 0xff) 276 return -ENODEV; 277 is_lm75a = 1; 278 hyst = i2c_smbus_read_byte_data(new_client, 2); 279 os = i2c_smbus_read_byte_data(new_client, 3); 280 } else { /* Traditional style LM75 detection */ 281 /* Unused addresses */ 282 hyst = i2c_smbus_read_byte_data(new_client, 2); 283 if (i2c_smbus_read_byte_data(new_client, 4) != hyst 284 || i2c_smbus_read_byte_data(new_client, 5) != hyst 285 || i2c_smbus_read_byte_data(new_client, 6) != hyst 286 || i2c_smbus_read_byte_data(new_client, 7) != hyst) 287 return -ENODEV; 288 os = i2c_smbus_read_byte_data(new_client, 3); 289 if (i2c_smbus_read_byte_data(new_client, 4) != os 290 || i2c_smbus_read_byte_data(new_client, 5) != os 291 || i2c_smbus_read_byte_data(new_client, 6) != os 292 || i2c_smbus_read_byte_data(new_client, 7) != os) 293 return -ENODEV; 294 } 295 296 /* Addresses cycling */ 297 for (i = 8; i <= 248; i += 40) { 298 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf 299 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst 300 || i2c_smbus_read_byte_data(new_client, i + 3) != os) 301 return -ENODEV; 302 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7) 303 != LM75A_ID) 304 return -ENODEV; 305 } 306 307 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE); 308 309 return 0; 310 } 311 312 #ifdef CONFIG_PM 313 static int lm75_suspend(struct device *dev) 314 { 315 int status; 316 struct i2c_client *client = to_i2c_client(dev); 317 status = lm75_read_value(client, LM75_REG_CONF); 318 if (status < 0) { 319 dev_dbg(&client->dev, "Can't read config? %d\n", status); 320 return status; 321 } 322 status = status | LM75_SHUTDOWN; 323 lm75_write_value(client, LM75_REG_CONF, status); 324 return 0; 325 } 326 327 static int lm75_resume(struct device *dev) 328 { 329 int status; 330 struct i2c_client *client = to_i2c_client(dev); 331 status = lm75_read_value(client, LM75_REG_CONF); 332 if (status < 0) { 333 dev_dbg(&client->dev, "Can't read config? %d\n", status); 334 return status; 335 } 336 status = status & ~LM75_SHUTDOWN; 337 lm75_write_value(client, LM75_REG_CONF, status); 338 return 0; 339 } 340 341 static const struct dev_pm_ops lm75_dev_pm_ops = { 342 .suspend = lm75_suspend, 343 .resume = lm75_resume, 344 }; 345 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops) 346 #else 347 #define LM75_DEV_PM_OPS NULL 348 #endif /* CONFIG_PM */ 349 350 static struct i2c_driver lm75_driver = { 351 .class = I2C_CLASS_HWMON, 352 .driver = { 353 .name = "lm75", 354 .pm = LM75_DEV_PM_OPS, 355 }, 356 .probe = lm75_probe, 357 .remove = lm75_remove, 358 .id_table = lm75_ids, 359 .detect = lm75_detect, 360 .address_list = normal_i2c, 361 }; 362 363 /*-----------------------------------------------------------------------*/ 364 365 /* register access */ 366 367 /* 368 * All registers are word-sized, except for the configuration register. 369 * LM75 uses a high-byte first convention, which is exactly opposite to 370 * the SMBus standard. 371 */ 372 static int lm75_read_value(struct i2c_client *client, u8 reg) 373 { 374 int value; 375 376 if (reg == LM75_REG_CONF) 377 return i2c_smbus_read_byte_data(client, reg); 378 379 value = i2c_smbus_read_word_data(client, reg); 380 return (value < 0) ? value : swab16(value); 381 } 382 383 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value) 384 { 385 if (reg == LM75_REG_CONF) 386 return i2c_smbus_write_byte_data(client, reg, value); 387 else 388 return i2c_smbus_write_word_data(client, reg, swab16(value)); 389 } 390 391 static struct lm75_data *lm75_update_device(struct device *dev) 392 { 393 struct i2c_client *client = to_i2c_client(dev); 394 struct lm75_data *data = i2c_get_clientdata(client); 395 396 mutex_lock(&data->update_lock); 397 398 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 399 || !data->valid) { 400 int i; 401 dev_dbg(&client->dev, "Starting lm75 update\n"); 402 403 for (i = 0; i < ARRAY_SIZE(data->temp); i++) { 404 int status; 405 406 status = lm75_read_value(client, LM75_REG_TEMP[i]); 407 if (status < 0) 408 dev_dbg(&client->dev, "reg %d, err %d\n", 409 LM75_REG_TEMP[i], status); 410 else 411 data->temp[i] = status; 412 } 413 data->last_updated = jiffies; 414 data->valid = 1; 415 } 416 417 mutex_unlock(&data->update_lock); 418 419 return data; 420 } 421 422 /*-----------------------------------------------------------------------*/ 423 424 /* module glue */ 425 426 static int __init sensors_lm75_init(void) 427 { 428 return i2c_add_driver(&lm75_driver); 429 } 430 431 static void __exit sensors_lm75_exit(void) 432 { 433 i2c_del_driver(&lm75_driver); 434 } 435 436 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 437 MODULE_DESCRIPTION("LM75 driver"); 438 MODULE_LICENSE("GPL"); 439 440 module_init(sensors_lm75_init); 441 module_exit(sensors_lm75_exit); 442