Merge branch 'next' of git://git.monstr.eu/linux-2.6-microblaze
[linux-2.6-microblaze.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 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");