Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
lm95241.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2008, 2010 Davide Rizzo <[email protected]>
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[] = {
88 };
89 
90 /* Client data (each client gets its own) */
91 struct lm95241_data {
92  struct device *hwmon_dev;
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)];
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 i2c_client *client = to_i2c_client(dev);
117  struct lm95241_data *data = i2c_get_clientdata(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(&client->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 i2c_client *client = to_i2c_client(dev);
157  struct lm95241_data *data = i2c_get_clientdata(client);
158 
159  return snprintf(buf, PAGE_SIZE - 1,
160  data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n");
161 }
162 
163 static ssize_t set_type(struct device *dev, struct device_attribute *attr,
164  const char *buf, size_t count)
165 {
166  struct i2c_client *client = to_i2c_client(dev);
167  struct lm95241_data *data = i2c_get_clientdata(client);
168  unsigned long val;
169  int shift;
170  u8 mask = to_sensor_dev_attr(attr)->index;
171 
172  if (kstrtoul(buf, 10, &val) < 0)
173  return -EINVAL;
174  if (val != 1 && val != 2)
175  return -EINVAL;
176 
177  shift = mask == R1MS_MASK ? TT1_SHIFT : TT2_SHIFT;
178 
179  mutex_lock(&data->update_lock);
180 
181  data->trutherm &= ~(TT_MASK << shift);
182  if (val == 1) {
183  data->model |= mask;
184  data->trutherm |= (TT_ON << shift);
185  } else {
186  data->model &= ~mask;
187  data->trutherm |= (TT_OFF << shift);
188  }
189  data->valid = 0;
190 
192  data->model);
194  data->trutherm);
195 
196  mutex_unlock(&data->update_lock);
197 
198  return count;
199 }
200 
201 static ssize_t show_min(struct device *dev, struct device_attribute *attr,
202  char *buf)
203 {
204  struct i2c_client *client = to_i2c_client(dev);
205  struct lm95241_data *data = i2c_get_clientdata(client);
206 
207  return snprintf(buf, PAGE_SIZE - 1,
208  data->config & to_sensor_dev_attr(attr)->index ?
209  "-127000\n" : "0\n");
210 }
211 
212 static ssize_t set_min(struct device *dev, struct device_attribute *attr,
213  const char *buf, size_t count)
214 {
215  struct i2c_client *client = to_i2c_client(dev);
216  struct lm95241_data *data = i2c_get_clientdata(client);
217  long val;
218 
219  if (kstrtol(buf, 10, &val) < 0)
220  return -EINVAL;
221  if (val < -128000)
222  return -EINVAL;
223 
224  mutex_lock(&data->update_lock);
225 
226  if (val < 0)
227  data->config |= to_sensor_dev_attr(attr)->index;
228  else
229  data->config &= ~to_sensor_dev_attr(attr)->index;
230  data->valid = 0;
231 
233 
234  mutex_unlock(&data->update_lock);
235 
236  return count;
237 }
238 
239 static ssize_t show_max(struct device *dev, struct device_attribute *attr,
240  char *buf)
241 {
242  struct i2c_client *client = to_i2c_client(dev);
243  struct lm95241_data *data = i2c_get_clientdata(client);
244 
245  return snprintf(buf, PAGE_SIZE - 1,
246  data->config & to_sensor_dev_attr(attr)->index ?
247  "127000\n" : "255000\n");
248 }
249 
250 static ssize_t set_max(struct device *dev, struct device_attribute *attr,
251  const char *buf, size_t count)
252 {
253  struct i2c_client *client = to_i2c_client(dev);
254  struct lm95241_data *data = i2c_get_clientdata(client);
255  long val;
256 
257  if (kstrtol(buf, 10, &val) < 0)
258  return -EINVAL;
259  if (val >= 256000)
260  return -EINVAL;
261 
262  mutex_lock(&data->update_lock);
263 
264  if (val <= 127000)
265  data->config |= to_sensor_dev_attr(attr)->index;
266  else
267  data->config &= ~to_sensor_dev_attr(attr)->index;
268  data->valid = 0;
269 
271 
272  mutex_unlock(&data->update_lock);
273 
274  return count;
275 }
276 
277 static ssize_t show_interval(struct device *dev, struct device_attribute *attr,
278  char *buf)
279 {
280  struct lm95241_data *data = lm95241_update_device(dev);
281 
282  return snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->interval
283  / HZ);
284 }
285 
286 static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
287  const char *buf, size_t count)
288 {
289  struct i2c_client *client = to_i2c_client(dev);
290  struct lm95241_data *data = i2c_get_clientdata(client);
291  unsigned long val;
292 
293  if (kstrtoul(buf, 10, &val) < 0)
294  return -EINVAL;
295 
296  data->interval = val * HZ / 1000;
297 
298  return count;
299 }
300 
301 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0);
302 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
303 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 4);
304 static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type,
305  R1MS_MASK);
306 static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type,
307  R2MS_MASK);
308 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min,
309  R1DF_MASK);
310 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min,
311  R2DF_MASK);
312 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max,
313  R1DF_MASK);
314 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max,
315  R2DF_MASK);
316 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
317  set_interval);
318 
319 static struct attribute *lm95241_attributes[] = {
320  &sensor_dev_attr_temp1_input.dev_attr.attr,
321  &sensor_dev_attr_temp2_input.dev_attr.attr,
322  &sensor_dev_attr_temp3_input.dev_attr.attr,
323  &sensor_dev_attr_temp2_type.dev_attr.attr,
324  &sensor_dev_attr_temp3_type.dev_attr.attr,
325  &sensor_dev_attr_temp2_min.dev_attr.attr,
326  &sensor_dev_attr_temp3_min.dev_attr.attr,
327  &sensor_dev_attr_temp2_max.dev_attr.attr,
328  &sensor_dev_attr_temp3_max.dev_attr.attr,
329  &dev_attr_update_interval.attr,
330  NULL
331 };
332 
333 static const struct attribute_group lm95241_group = {
334  .attrs = lm95241_attributes,
335 };
336 
337 /* Return 0 if detection is successful, -ENODEV otherwise */
338 static int lm95241_detect(struct i2c_client *new_client,
339  struct i2c_board_info *info)
340 {
341  struct i2c_adapter *adapter = new_client->adapter;
342  const char *name;
343  int mfg_id, chip_id;
344 
345  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
346  return -ENODEV;
347 
348  mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID);
349  if (mfg_id != NATSEMI_MAN_ID)
350  return -ENODEV;
351 
352  chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID);
353  switch (chip_id) {
354  case LM95231_CHIP_ID:
355  name = "lm95231";
356  break;
357  case LM95241_CHIP_ID:
358  name = "lm95241";
359  break;
360  default:
361  return -ENODEV;
362  }
363 
364  /* Fill the i2c board info */
365  strlcpy(info->type, name, I2C_NAME_SIZE);
366  return 0;
367 }
368 
369 static void lm95241_init_client(struct i2c_client *client)
370 {
371  struct lm95241_data *data = i2c_get_clientdata(client);
372 
373  data->interval = HZ; /* 1 sec default */
374  data->valid = 0;
375  data->config = CFG_CR0076;
376  data->model = 0;
377  data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
378 
381  R1FE_MASK | R2FE_MASK);
383  data->trutherm);
385  data->model);
386 }
387 
388 static int lm95241_probe(struct i2c_client *new_client,
389  const struct i2c_device_id *id)
390 {
391  struct lm95241_data *data;
392  int err;
393 
394  data = devm_kzalloc(&new_client->dev, sizeof(struct lm95241_data),
395  GFP_KERNEL);
396  if (!data)
397  return -ENOMEM;
398 
399  i2c_set_clientdata(new_client, data);
400  mutex_init(&data->update_lock);
401 
402  /* Initialize the LM95241 chip */
403  lm95241_init_client(new_client);
404 
405  /* Register sysfs hooks */
406  err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group);
407  if (err)
408  return err;
409 
410  data->hwmon_dev = hwmon_device_register(&new_client->dev);
411  if (IS_ERR(data->hwmon_dev)) {
412  err = PTR_ERR(data->hwmon_dev);
413  goto exit_remove_files;
414  }
415 
416  return 0;
417 
418 exit_remove_files:
419  sysfs_remove_group(&new_client->dev.kobj, &lm95241_group);
420  return err;
421 }
422 
423 static int lm95241_remove(struct i2c_client *client)
424 {
425  struct lm95241_data *data = i2c_get_clientdata(client);
426 
428  sysfs_remove_group(&client->dev.kobj, &lm95241_group);
429 
430  return 0;
431 }
432 
433 /* Driver data (common to all clients) */
434 static const struct i2c_device_id lm95241_id[] = {
435  { "lm95231", 0 },
436  { "lm95241", 0 },
437  { }
438 };
439 MODULE_DEVICE_TABLE(i2c, lm95241_id);
440 
441 static struct i2c_driver lm95241_driver = {
442  .class = I2C_CLASS_HWMON,
443  .driver = {
444  .name = DEVNAME,
445  },
446  .probe = lm95241_probe,
447  .remove = lm95241_remove,
448  .id_table = lm95241_id,
449  .detect = lm95241_detect,
450  .address_list = normal_i2c,
451 };
452 
453 module_i2c_driver(lm95241_driver);
454 
455 MODULE_AUTHOR("Davide Rizzo <[email protected]>");
456 MODULE_DESCRIPTION("LM95241 sensor driver");
457 MODULE_LICENSE("GPL");