1 /* 2 * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com> 3 * 4 * The LM95241 is a sensor chip made by National Semiconductors. 5 * It reports up to three temperatures (its own plus up to two external ones). 6 * Complete datasheet can be obtained from National's website at: 7 * http://www.national.com/ds.cgi/LM/LM95241.pdf 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/jiffies.h> 28 #include <linux/i2c.h> 29 #include <linux/hwmon.h> 30 #include <linux/hwmon-sysfs.h> 31 #include <linux/err.h> 32 #include <linux/mutex.h> 33 #include <linux/sysfs.h> 34 35 #define DEVNAME "lm95241" 36 37 static const unsigned short normal_i2c[] = { 38 0x19, 0x2a, 0x2b, I2C_CLIENT_END }; 39 40 /* LM95241 registers */ 41 #define LM95241_REG_R_MAN_ID 0xFE 42 #define LM95241_REG_R_CHIP_ID 0xFF 43 #define LM95241_REG_R_STATUS 0x02 44 #define LM95241_REG_RW_CONFIG 0x03 45 #define LM95241_REG_RW_REM_FILTER 0x06 46 #define LM95241_REG_RW_TRUTHERM 0x07 47 #define LM95241_REG_W_ONE_SHOT 0x0F 48 #define LM95241_REG_R_LOCAL_TEMPH 0x10 49 #define LM95241_REG_R_REMOTE1_TEMPH 0x11 50 #define LM95241_REG_R_REMOTE2_TEMPH 0x12 51 #define LM95241_REG_R_LOCAL_TEMPL 0x20 52 #define LM95241_REG_R_REMOTE1_TEMPL 0x21 53 #define LM95241_REG_R_REMOTE2_TEMPL 0x22 54 #define LM95241_REG_RW_REMOTE_MODEL 0x30 55 56 /* LM95241 specific bitfields */ 57 #define CFG_STOP 0x40 58 #define CFG_CR0076 0x00 59 #define CFG_CR0182 0x10 60 #define CFG_CR1000 0x20 61 #define CFG_CR2700 0x30 62 #define R1MS_SHIFT 0 63 #define R2MS_SHIFT 2 64 #define R1MS_MASK (0x01 << (R1MS_SHIFT)) 65 #define R2MS_MASK (0x01 << (R2MS_SHIFT)) 66 #define R1DF_SHIFT 1 67 #define R2DF_SHIFT 2 68 #define R1DF_MASK (0x01 << (R1DF_SHIFT)) 69 #define R2DF_MASK (0x01 << (R2DF_SHIFT)) 70 #define R1FE_MASK 0x01 71 #define R2FE_MASK 0x05 72 #define TT1_SHIFT 0 73 #define TT2_SHIFT 4 74 #define TT_OFF 0 75 #define TT_ON 1 76 #define TT_MASK 7 77 #define MANUFACTURER_ID 0x01 78 #define DEFAULT_REVISION 0xA4 79 80 static const u8 lm95241_reg_address[] = { 81 LM95241_REG_R_LOCAL_TEMPH, 82 LM95241_REG_R_LOCAL_TEMPL, 83 LM95241_REG_R_REMOTE1_TEMPH, 84 LM95241_REG_R_REMOTE1_TEMPL, 85 LM95241_REG_R_REMOTE2_TEMPH, 86 LM95241_REG_R_REMOTE2_TEMPL 87 }; 88 89 /* Client data (each client gets its own) */ 90 struct lm95241_data { 91 struct device *hwmon_dev; 92 struct mutex update_lock; 93 unsigned long last_updated, interval; /* in jiffies */ 94 char valid; /* zero until following fields are valid */ 95 /* registers values */ 96 u8 temp[ARRAY_SIZE(lm95241_reg_address)]; 97 u8 config, model, trutherm; 98 }; 99 100 /* Conversions */ 101 static int TempFromReg(u8 val_h, u8 val_l) 102 { 103 if (val_h & 0x80) 104 return val_h - 0x100; 105 return val_h * 1000 + val_l * 1000 / 256; 106 } 107 108 static struct lm95241_data *lm95241_update_device(struct device *dev) 109 { 110 struct i2c_client *client = to_i2c_client(dev); 111 struct lm95241_data *data = i2c_get_clientdata(client); 112 113 mutex_lock(&data->update_lock); 114 115 if (time_after(jiffies, data->last_updated + data->interval) || 116 !data->valid) { 117 int i; 118 119 dev_dbg(&client->dev, "Updating lm95241 data.\n"); 120 for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++) 121 data->temp[i] 122 = i2c_smbus_read_byte_data(client, 123 lm95241_reg_address[i]); 124 data->last_updated = jiffies; 125 data->valid = 1; 126 } 127 128 mutex_unlock(&data->update_lock); 129 130 return data; 131 } 132 133 /* Sysfs stuff */ 134 static ssize_t show_input(struct device *dev, struct device_attribute *attr, 135 char *buf) 136 { 137 struct lm95241_data *data = lm95241_update_device(dev); 138 139 return snprintf(buf, PAGE_SIZE - 1, "%d\n", 140 TempFromReg(data->temp[to_sensor_dev_attr(attr)->index], 141 data->temp[to_sensor_dev_attr(attr)->index + 1])); 142 } 143 144 static ssize_t show_type(struct device *dev, struct device_attribute *attr, 145 char *buf) 146 { 147 struct i2c_client *client = to_i2c_client(dev); 148 struct lm95241_data *data = i2c_get_clientdata(client); 149 150 return snprintf(buf, PAGE_SIZE - 1, 151 data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n"); 152 } 153 154 static ssize_t set_type(struct device *dev, struct device_attribute *attr, 155 const char *buf, size_t count) 156 { 157 struct i2c_client *client = to_i2c_client(dev); 158 struct lm95241_data *data = i2c_get_clientdata(client); 159 unsigned long val; 160 int shift; 161 u8 mask = to_sensor_dev_attr(attr)->index; 162 163 if (strict_strtoul(buf, 10, &val) < 0) 164 return -EINVAL; 165 if (val != 1 && val != 2) 166 return -EINVAL; 167 168 shift = mask == R1MS_MASK ? TT1_SHIFT : TT2_SHIFT; 169 170 mutex_lock(&data->update_lock); 171 172 data->trutherm &= ~(TT_MASK << shift); 173 if (val == 1) { 174 data->model |= mask; 175 data->trutherm |= (TT_ON << shift); 176 } else { 177 data->model &= ~mask; 178 data->trutherm |= (TT_OFF << shift); 179 } 180 data->valid = 0; 181 182 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, 183 data->model); 184 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, 185 data->trutherm); 186 187 mutex_unlock(&data->update_lock); 188 189 return count; 190 } 191 192 static ssize_t show_min(struct device *dev, struct device_attribute *attr, 193 char *buf) 194 { 195 struct i2c_client *client = to_i2c_client(dev); 196 struct lm95241_data *data = i2c_get_clientdata(client); 197 198 return snprintf(buf, PAGE_SIZE - 1, 199 data->config & to_sensor_dev_attr(attr)->index ? 200 "-127000\n" : "0\n"); 201 } 202 203 static ssize_t set_min(struct device *dev, struct device_attribute *attr, 204 const char *buf, size_t count) 205 { 206 struct i2c_client *client = to_i2c_client(dev); 207 struct lm95241_data *data = i2c_get_clientdata(client); 208 long val; 209 210 if (strict_strtol(buf, 10, &val) < 0) 211 return -EINVAL; 212 if (val < -128000) 213 return -EINVAL; 214 215 mutex_lock(&data->update_lock); 216 217 if (val < 0) 218 data->config |= to_sensor_dev_attr(attr)->index; 219 else 220 data->config &= ~to_sensor_dev_attr(attr)->index; 221 data->valid = 0; 222 223 i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config); 224 225 mutex_unlock(&data->update_lock); 226 227 return count; 228 } 229 230 static ssize_t show_max(struct device *dev, struct device_attribute *attr, 231 char *buf) 232 { 233 struct i2c_client *client = to_i2c_client(dev); 234 struct lm95241_data *data = i2c_get_clientdata(client); 235 236 return snprintf(buf, PAGE_SIZE - 1, 237 data->config & to_sensor_dev_attr(attr)->index ? 238 "127000\n" : "255000\n"); 239 } 240 241 static ssize_t set_max(struct device *dev, struct device_attribute *attr, 242 const char *buf, size_t count) 243 { 244 struct i2c_client *client = to_i2c_client(dev); 245 struct lm95241_data *data = i2c_get_clientdata(client); 246 long val; 247 248 if (strict_strtol(buf, 10, &val) < 0) 249 return -EINVAL; 250 if (val >= 256000) 251 return -EINVAL; 252 253 mutex_lock(&data->update_lock); 254 255 if (val <= 127000) 256 data->config |= to_sensor_dev_attr(attr)->index; 257 else 258 data->config &= ~to_sensor_dev_attr(attr)->index; 259 data->valid = 0; 260 261 i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config); 262 263 mutex_unlock(&data->update_lock); 264 265 return count; 266 } 267 268 static ssize_t show_interval(struct device *dev, struct device_attribute *attr, 269 char *buf) 270 { 271 struct lm95241_data *data = lm95241_update_device(dev); 272 273 return snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->interval 274 / HZ); 275 } 276 277 static ssize_t set_interval(struct device *dev, struct device_attribute *attr, 278 const char *buf, size_t count) 279 { 280 struct i2c_client *client = to_i2c_client(dev); 281 struct lm95241_data *data = i2c_get_clientdata(client); 282 unsigned long val; 283 284 if (strict_strtoul(buf, 10, &val) < 0) 285 return -EINVAL; 286 287 data->interval = val * HZ / 1000; 288 289 return count; 290 } 291 292 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0); 293 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2); 294 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 4); 295 static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type, 296 R1MS_MASK); 297 static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type, 298 R2MS_MASK); 299 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min, 300 R1DF_MASK); 301 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min, 302 R2DF_MASK); 303 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max, 304 R1DF_MASK); 305 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max, 306 R2DF_MASK); 307 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval, 308 set_interval); 309 310 static struct attribute *lm95241_attributes[] = { 311 &sensor_dev_attr_temp1_input.dev_attr.attr, 312 &sensor_dev_attr_temp2_input.dev_attr.attr, 313 &sensor_dev_attr_temp3_input.dev_attr.attr, 314 &sensor_dev_attr_temp2_type.dev_attr.attr, 315 &sensor_dev_attr_temp3_type.dev_attr.attr, 316 &sensor_dev_attr_temp2_min.dev_attr.attr, 317 &sensor_dev_attr_temp3_min.dev_attr.attr, 318 &sensor_dev_attr_temp2_max.dev_attr.attr, 319 &sensor_dev_attr_temp3_max.dev_attr.attr, 320 &dev_attr_update_interval.attr, 321 NULL 322 }; 323 324 static const struct attribute_group lm95241_group = { 325 .attrs = lm95241_attributes, 326 }; 327 328 /* Return 0 if detection is successful, -ENODEV otherwise */ 329 static int lm95241_detect(struct i2c_client *new_client, 330 struct i2c_board_info *info) 331 { 332 struct i2c_adapter *adapter = new_client->adapter; 333 int address = new_client->addr; 334 const char *name; 335 336 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 337 return -ENODEV; 338 339 if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID) 340 == MANUFACTURER_ID) 341 && (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID) 342 >= DEFAULT_REVISION)) { 343 name = DEVNAME; 344 } else { 345 dev_dbg(&adapter->dev, "LM95241 detection failed at 0x%02x\n", 346 address); 347 return -ENODEV; 348 } 349 350 /* Fill the i2c board info */ 351 strlcpy(info->type, name, I2C_NAME_SIZE); 352 return 0; 353 } 354 355 static void lm95241_init_client(struct i2c_client *client) 356 { 357 struct lm95241_data *data = i2c_get_clientdata(client); 358 359 data->interval = HZ; /* 1 sec default */ 360 data->valid = 0; 361 data->config = CFG_CR0076; 362 data->model = 0; 363 data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT); 364 365 i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config); 366 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER, 367 R1FE_MASK | R2FE_MASK); 368 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, 369 data->trutherm); 370 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, 371 data->model); 372 } 373 374 static int lm95241_probe(struct i2c_client *new_client, 375 const struct i2c_device_id *id) 376 { 377 struct lm95241_data *data; 378 int err; 379 380 data = kzalloc(sizeof(struct lm95241_data), GFP_KERNEL); 381 if (!data) { 382 err = -ENOMEM; 383 goto exit; 384 } 385 386 i2c_set_clientdata(new_client, data); 387 mutex_init(&data->update_lock); 388 389 /* Initialize the LM95241 chip */ 390 lm95241_init_client(new_client); 391 392 /* Register sysfs hooks */ 393 err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group); 394 if (err) 395 goto exit_free; 396 397 data->hwmon_dev = hwmon_device_register(&new_client->dev); 398 if (IS_ERR(data->hwmon_dev)) { 399 err = PTR_ERR(data->hwmon_dev); 400 goto exit_remove_files; 401 } 402 403 return 0; 404 405 exit_remove_files: 406 sysfs_remove_group(&new_client->dev.kobj, &lm95241_group); 407 exit_free: 408 kfree(data); 409 exit: 410 return err; 411 } 412 413 static int lm95241_remove(struct i2c_client *client) 414 { 415 struct lm95241_data *data = i2c_get_clientdata(client); 416 417 hwmon_device_unregister(data->hwmon_dev); 418 sysfs_remove_group(&client->dev.kobj, &lm95241_group); 419 420 kfree(data); 421 return 0; 422 } 423 424 /* Driver data (common to all clients) */ 425 static const struct i2c_device_id lm95241_id[] = { 426 { DEVNAME, 0 }, 427 { } 428 }; 429 MODULE_DEVICE_TABLE(i2c, lm95241_id); 430 431 static struct i2c_driver lm95241_driver = { 432 .class = I2C_CLASS_HWMON, 433 .driver = { 434 .name = DEVNAME, 435 }, 436 .probe = lm95241_probe, 437 .remove = lm95241_remove, 438 .id_table = lm95241_id, 439 .detect = lm95241_detect, 440 .address_list = normal_i2c, 441 }; 442 443 static int __init sensors_lm95241_init(void) 444 { 445 return i2c_add_driver(&lm95241_driver); 446 } 447 448 static void __exit sensors_lm95241_exit(void) 449 { 450 i2c_del_driver(&lm95241_driver); 451 } 452 453 MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>"); 454 MODULE_DESCRIPTION("LM95241 sensor driver"); 455 MODULE_LICENSE("GPL"); 456 457 module_init(sensors_lm95241_init); 458 module_exit(sensors_lm95241_exit); 459