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 NATSEMI_MAN_ID 0x01 78 #define LM95231_CHIP_ID 0xA1 79 #define LM95241_CHIP_ID 0xA4 80 81 static const u8 lm95241_reg_address[] = { 82 LM95241_REG_R_LOCAL_TEMPH, 83 LM95241_REG_R_LOCAL_TEMPL, 84 LM95241_REG_R_REMOTE1_TEMPH, 85 LM95241_REG_R_REMOTE1_TEMPL, 86 LM95241_REG_R_REMOTE2_TEMPH, 87 LM95241_REG_R_REMOTE2_TEMPL 88 }; 89 90 /* Client data (each client gets its own) */ 91 struct lm95241_data { 92 struct i2c_client *client; 93 struct mutex update_lock; 94 unsigned long last_updated, interval; /* in jiffies */ 95 char valid; /* zero until following fields are valid */ 96 /* registers values */ 97 u8 temp[ARRAY_SIZE(lm95241_reg_address)]; 98 u8 config, model, trutherm; 99 }; 100 101 /* Conversions */ 102 static int temp_from_reg_signed(u8 val_h, u8 val_l) 103 { 104 s16 val_hl = (val_h << 8) | val_l; 105 return val_hl * 1000 / 256; 106 } 107 108 static int temp_from_reg_unsigned(u8 val_h, u8 val_l) 109 { 110 u16 val_hl = (val_h << 8) | val_l; 111 return val_hl * 1000 / 256; 112 } 113 114 static struct lm95241_data *lm95241_update_device(struct device *dev) 115 { 116 struct lm95241_data *data = dev_get_drvdata(dev); 117 struct i2c_client *client = data->client; 118 119 mutex_lock(&data->update_lock); 120 121 if (time_after(jiffies, data->last_updated + data->interval) || 122 !data->valid) { 123 int i; 124 125 dev_dbg(dev, "Updating lm95241 data.\n"); 126 for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++) 127 data->temp[i] 128 = i2c_smbus_read_byte_data(client, 129 lm95241_reg_address[i]); 130 data->last_updated = jiffies; 131 data->valid = 1; 132 } 133 134 mutex_unlock(&data->update_lock); 135 136 return data; 137 } 138 139 /* Sysfs stuff */ 140 static ssize_t show_input(struct device *dev, struct device_attribute *attr, 141 char *buf) 142 { 143 struct lm95241_data *data = lm95241_update_device(dev); 144 int index = to_sensor_dev_attr(attr)->index; 145 146 return snprintf(buf, PAGE_SIZE - 1, "%d\n", 147 index == 0 || (data->config & (1 << (index / 2))) ? 148 temp_from_reg_signed(data->temp[index], data->temp[index + 1]) : 149 temp_from_reg_unsigned(data->temp[index], 150 data->temp[index + 1])); 151 } 152 153 static ssize_t show_type(struct device *dev, struct device_attribute *attr, 154 char *buf) 155 { 156 struct lm95241_data *data = dev_get_drvdata(dev); 157 158 return snprintf(buf, PAGE_SIZE - 1, 159 data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n"); 160 } 161 162 static ssize_t set_type(struct device *dev, struct device_attribute *attr, 163 const char *buf, size_t count) 164 { 165 struct lm95241_data *data = dev_get_drvdata(dev); 166 struct i2c_client *client = data->client; 167 unsigned long val; 168 int shift; 169 u8 mask = to_sensor_dev_attr(attr)->index; 170 171 if (kstrtoul(buf, 10, &val) < 0) 172 return -EINVAL; 173 if (val != 1 && val != 2) 174 return -EINVAL; 175 176 shift = mask == R1MS_MASK ? TT1_SHIFT : TT2_SHIFT; 177 178 mutex_lock(&data->update_lock); 179 180 data->trutherm &= ~(TT_MASK << shift); 181 if (val == 1) { 182 data->model |= mask; 183 data->trutherm |= (TT_ON << shift); 184 } else { 185 data->model &= ~mask; 186 data->trutherm |= (TT_OFF << shift); 187 } 188 data->valid = 0; 189 190 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, 191 data->model); 192 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, 193 data->trutherm); 194 195 mutex_unlock(&data->update_lock); 196 197 return count; 198 } 199 200 static ssize_t show_min(struct device *dev, struct device_attribute *attr, 201 char *buf) 202 { 203 struct lm95241_data *data = dev_get_drvdata(dev); 204 205 return snprintf(buf, PAGE_SIZE - 1, 206 data->config & to_sensor_dev_attr(attr)->index ? 207 "-127000\n" : "0\n"); 208 } 209 210 static ssize_t set_min(struct device *dev, struct device_attribute *attr, 211 const char *buf, size_t count) 212 { 213 struct lm95241_data *data = dev_get_drvdata(dev); 214 long val; 215 216 if (kstrtol(buf, 10, &val) < 0) 217 return -EINVAL; 218 if (val < -128000) 219 return -EINVAL; 220 221 mutex_lock(&data->update_lock); 222 223 if (val < 0) 224 data->config |= to_sensor_dev_attr(attr)->index; 225 else 226 data->config &= ~to_sensor_dev_attr(attr)->index; 227 data->valid = 0; 228 229 i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG, 230 data->config); 231 232 mutex_unlock(&data->update_lock); 233 234 return count; 235 } 236 237 static ssize_t show_max(struct device *dev, struct device_attribute *attr, 238 char *buf) 239 { 240 struct lm95241_data *data = dev_get_drvdata(dev); 241 242 return snprintf(buf, PAGE_SIZE - 1, 243 data->config & to_sensor_dev_attr(attr)->index ? 244 "127000\n" : "255000\n"); 245 } 246 247 static ssize_t set_max(struct device *dev, struct device_attribute *attr, 248 const char *buf, size_t count) 249 { 250 struct lm95241_data *data = dev_get_drvdata(dev); 251 long val; 252 253 if (kstrtol(buf, 10, &val) < 0) 254 return -EINVAL; 255 if (val >= 256000) 256 return -EINVAL; 257 258 mutex_lock(&data->update_lock); 259 260 if (val <= 127000) 261 data->config |= to_sensor_dev_attr(attr)->index; 262 else 263 data->config &= ~to_sensor_dev_attr(attr)->index; 264 data->valid = 0; 265 266 i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG, 267 data->config); 268 269 mutex_unlock(&data->update_lock); 270 271 return count; 272 } 273 274 static ssize_t show_interval(struct device *dev, struct device_attribute *attr, 275 char *buf) 276 { 277 struct lm95241_data *data = lm95241_update_device(dev); 278 279 return snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->interval 280 / HZ); 281 } 282 283 static ssize_t set_interval(struct device *dev, struct device_attribute *attr, 284 const char *buf, size_t count) 285 { 286 struct lm95241_data *data = dev_get_drvdata(dev); 287 unsigned long val; 288 289 if (kstrtoul(buf, 10, &val) < 0) 290 return -EINVAL; 291 292 data->interval = val * HZ / 1000; 293 294 return count; 295 } 296 297 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0); 298 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2); 299 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 4); 300 static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type, 301 R1MS_MASK); 302 static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type, 303 R2MS_MASK); 304 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min, 305 R1DF_MASK); 306 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min, 307 R2DF_MASK); 308 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max, 309 R1DF_MASK); 310 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max, 311 R2DF_MASK); 312 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval, 313 set_interval); 314 315 static struct attribute *lm95241_attrs[] = { 316 &sensor_dev_attr_temp1_input.dev_attr.attr, 317 &sensor_dev_attr_temp2_input.dev_attr.attr, 318 &sensor_dev_attr_temp3_input.dev_attr.attr, 319 &sensor_dev_attr_temp2_type.dev_attr.attr, 320 &sensor_dev_attr_temp3_type.dev_attr.attr, 321 &sensor_dev_attr_temp2_min.dev_attr.attr, 322 &sensor_dev_attr_temp3_min.dev_attr.attr, 323 &sensor_dev_attr_temp2_max.dev_attr.attr, 324 &sensor_dev_attr_temp3_max.dev_attr.attr, 325 &dev_attr_update_interval.attr, 326 NULL 327 }; 328 ATTRIBUTE_GROUPS(lm95241); 329 330 /* Return 0 if detection is successful, -ENODEV otherwise */ 331 static int lm95241_detect(struct i2c_client *new_client, 332 struct i2c_board_info *info) 333 { 334 struct i2c_adapter *adapter = new_client->adapter; 335 const char *name; 336 int mfg_id, chip_id; 337 338 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 339 return -ENODEV; 340 341 mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID); 342 if (mfg_id != NATSEMI_MAN_ID) 343 return -ENODEV; 344 345 chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID); 346 switch (chip_id) { 347 case LM95231_CHIP_ID: 348 name = "lm95231"; 349 break; 350 case LM95241_CHIP_ID: 351 name = "lm95241"; 352 break; 353 default: 354 return -ENODEV; 355 } 356 357 /* Fill the i2c board info */ 358 strlcpy(info->type, name, I2C_NAME_SIZE); 359 return 0; 360 } 361 362 static void lm95241_init_client(struct i2c_client *client, 363 struct lm95241_data *data) 364 { 365 data->interval = HZ; /* 1 sec default */ 366 data->config = CFG_CR0076; 367 data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT); 368 369 i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config); 370 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER, 371 R1FE_MASK | R2FE_MASK); 372 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, 373 data->trutherm); 374 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, 375 data->model); 376 } 377 378 static int lm95241_probe(struct i2c_client *client, 379 const struct i2c_device_id *id) 380 { 381 struct device *dev = &client->dev; 382 struct lm95241_data *data; 383 struct device *hwmon_dev; 384 385 data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL); 386 if (!data) 387 return -ENOMEM; 388 389 data->client = client; 390 mutex_init(&data->update_lock); 391 392 /* Initialize the LM95241 chip */ 393 lm95241_init_client(client, data); 394 395 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 396 data, 397 lm95241_groups); 398 return PTR_ERR_OR_ZERO(hwmon_dev); 399 } 400 401 /* Driver data (common to all clients) */ 402 static const struct i2c_device_id lm95241_id[] = { 403 { "lm95231", 0 }, 404 { "lm95241", 0 }, 405 { } 406 }; 407 MODULE_DEVICE_TABLE(i2c, lm95241_id); 408 409 static struct i2c_driver lm95241_driver = { 410 .class = I2C_CLASS_HWMON, 411 .driver = { 412 .name = DEVNAME, 413 }, 414 .probe = lm95241_probe, 415 .id_table = lm95241_id, 416 .detect = lm95241_detect, 417 .address_list = normal_i2c, 418 }; 419 420 module_i2c_driver(lm95241_driver); 421 422 MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>"); 423 MODULE_DESCRIPTION("LM95241 sensor driver"); 424 MODULE_LICENSE("GPL"); 425