Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/groec...
[linux-2.6.git] / drivers / hwmon / lm95241.c
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 device *hwmon_dev;
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 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 (strict_strtoul(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
191         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
192                                   data->model);
193         i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
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 (strict_strtol(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
232         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
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 (strict_strtol(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
270         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
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 (strict_strtoul(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
379         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
380         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
381                                   R1FE_MASK | R2FE_MASK);
382         i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
383                                   data->trutherm);
384         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
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 = kzalloc(sizeof(struct lm95241_data), GFP_KERNEL);
395         if (!data) {
396                 err = -ENOMEM;
397                 goto exit;
398         }
399
400         i2c_set_clientdata(new_client, data);
401         mutex_init(&data->update_lock);
402
403         /* Initialize the LM95241 chip */
404         lm95241_init_client(new_client);
405
406         /* Register sysfs hooks */
407         err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group);
408         if (err)
409                 goto exit_free;
410
411         data->hwmon_dev = hwmon_device_register(&new_client->dev);
412         if (IS_ERR(data->hwmon_dev)) {
413                 err = PTR_ERR(data->hwmon_dev);
414                 goto exit_remove_files;
415         }
416
417         return 0;
418
419 exit_remove_files:
420         sysfs_remove_group(&new_client->dev.kobj, &lm95241_group);
421 exit_free:
422         kfree(data);
423 exit:
424         return err;
425 }
426
427 static int lm95241_remove(struct i2c_client *client)
428 {
429         struct lm95241_data *data = i2c_get_clientdata(client);
430
431         hwmon_device_unregister(data->hwmon_dev);
432         sysfs_remove_group(&client->dev.kobj, &lm95241_group);
433
434         kfree(data);
435         return 0;
436 }
437
438 /* Driver data (common to all clients) */
439 static const struct i2c_device_id lm95241_id[] = {
440         { "lm95231", 0 },
441         { "lm95241", 0 },
442         { }
443 };
444 MODULE_DEVICE_TABLE(i2c, lm95241_id);
445
446 static struct i2c_driver lm95241_driver = {
447         .class          = I2C_CLASS_HWMON,
448         .driver = {
449                 .name   = DEVNAME,
450         },
451         .probe          = lm95241_probe,
452         .remove         = lm95241_remove,
453         .id_table       = lm95241_id,
454         .detect         = lm95241_detect,
455         .address_list   = normal_i2c,
456 };
457
458 static int __init sensors_lm95241_init(void)
459 {
460         return i2c_add_driver(&lm95241_driver);
461 }
462
463 static void __exit sensors_lm95241_exit(void)
464 {
465         i2c_del_driver(&lm95241_driver);
466 }
467
468 MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>");
469 MODULE_DESCRIPTION("LM95241 sensor driver");
470 MODULE_LICENSE("GPL");
471
472 module_init(sensors_lm95241_init);
473 module_exit(sensors_lm95241_exit);