Root/
1 | /* |
2 | * Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com> |
3 | * |
4 | * The LM95245 is a sensor chip made by National Semiconductors. |
5 | * It reports up to two temperatures (its own plus an external one). |
6 | * Complete datasheet can be obtained from National's website at: |
7 | * http://www.national.com/ds.cgi/LM/LM95245.pdf |
8 | * |
9 | * This driver is based on lm95241.c |
10 | * |
11 | * This program is free software; you can redistribute it and/or modify |
12 | * it under the terms of the GNU General Public License as published by |
13 | * the Free Software Foundation; either version 2 of the License, or |
14 | * (at your option) any later version. |
15 | * |
16 | * This program is distributed in the hope that it will be useful, |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
19 | * GNU General Public License for more details. |
20 | * |
21 | * You should have received a copy of the GNU General Public License |
22 | * along with this program; if not, write to the Free Software |
23 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
24 | */ |
25 | |
26 | #include <linux/module.h> |
27 | #include <linux/init.h> |
28 | #include <linux/slab.h> |
29 | #include <linux/jiffies.h> |
30 | #include <linux/i2c.h> |
31 | #include <linux/hwmon.h> |
32 | #include <linux/hwmon-sysfs.h> |
33 | #include <linux/err.h> |
34 | #include <linux/mutex.h> |
35 | #include <linux/sysfs.h> |
36 | |
37 | #define DEVNAME "lm95245" |
38 | |
39 | static const unsigned short normal_i2c[] = { |
40 | 0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END }; |
41 | |
42 | /* LM95245 registers */ |
43 | /* general registers */ |
44 | #define LM95245_REG_RW_CONFIG1 0x03 |
45 | #define LM95245_REG_RW_CONVERS_RATE 0x04 |
46 | #define LM95245_REG_W_ONE_SHOT 0x0F |
47 | |
48 | /* diode configuration */ |
49 | #define LM95245_REG_RW_CONFIG2 0xBF |
50 | #define LM95245_REG_RW_REMOTE_OFFH 0x11 |
51 | #define LM95245_REG_RW_REMOTE_OFFL 0x12 |
52 | |
53 | /* status registers */ |
54 | #define LM95245_REG_R_STATUS1 0x02 |
55 | #define LM95245_REG_R_STATUS2 0x33 |
56 | |
57 | /* limit registers */ |
58 | #define LM95245_REG_RW_REMOTE_OS_LIMIT 0x07 |
59 | #define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT 0x20 |
60 | #define LM95245_REG_RW_REMOTE_TCRIT_LIMIT 0x19 |
61 | #define LM95245_REG_RW_COMMON_HYSTERESIS 0x21 |
62 | |
63 | /* temperature signed */ |
64 | #define LM95245_REG_R_LOCAL_TEMPH_S 0x00 |
65 | #define LM95245_REG_R_LOCAL_TEMPL_S 0x30 |
66 | #define LM95245_REG_R_REMOTE_TEMPH_S 0x01 |
67 | #define LM95245_REG_R_REMOTE_TEMPL_S 0x10 |
68 | /* temperature unsigned */ |
69 | #define LM95245_REG_R_REMOTE_TEMPH_U 0x31 |
70 | #define LM95245_REG_R_REMOTE_TEMPL_U 0x32 |
71 | |
72 | /* id registers */ |
73 | #define LM95245_REG_R_MAN_ID 0xFE |
74 | #define LM95245_REG_R_CHIP_ID 0xFF |
75 | |
76 | /* LM95245 specific bitfields */ |
77 | #define CFG_STOP 0x40 |
78 | #define CFG_REMOTE_TCRIT_MASK 0x10 |
79 | #define CFG_REMOTE_OS_MASK 0x08 |
80 | #define CFG_LOCAL_TCRIT_MASK 0x04 |
81 | #define CFG_LOCAL_OS_MASK 0x02 |
82 | |
83 | #define CFG2_OS_A0 0x40 |
84 | #define CFG2_DIODE_FAULT_OS 0x20 |
85 | #define CFG2_DIODE_FAULT_TCRIT 0x10 |
86 | #define CFG2_REMOTE_TT 0x08 |
87 | #define CFG2_REMOTE_FILTER_DIS 0x00 |
88 | #define CFG2_REMOTE_FILTER_EN 0x06 |
89 | |
90 | /* conversation rate in ms */ |
91 | #define RATE_CR0063 0x00 |
92 | #define RATE_CR0364 0x01 |
93 | #define RATE_CR1000 0x02 |
94 | #define RATE_CR2500 0x03 |
95 | |
96 | #define STATUS1_DIODE_FAULT 0x04 |
97 | #define STATUS1_RTCRIT 0x02 |
98 | #define STATUS1_LOC 0x01 |
99 | |
100 | #define MANUFACTURER_ID 0x01 |
101 | #define DEFAULT_REVISION 0xB3 |
102 | |
103 | static const u8 lm95245_reg_address[] = { |
104 | LM95245_REG_R_LOCAL_TEMPH_S, |
105 | LM95245_REG_R_LOCAL_TEMPL_S, |
106 | LM95245_REG_R_REMOTE_TEMPH_S, |
107 | LM95245_REG_R_REMOTE_TEMPL_S, |
108 | LM95245_REG_R_REMOTE_TEMPH_U, |
109 | LM95245_REG_R_REMOTE_TEMPL_U, |
110 | LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT, |
111 | LM95245_REG_RW_REMOTE_TCRIT_LIMIT, |
112 | LM95245_REG_RW_COMMON_HYSTERESIS, |
113 | LM95245_REG_R_STATUS1, |
114 | }; |
115 | |
116 | /* Client data (each client gets its own) */ |
117 | struct lm95245_data { |
118 | struct device *hwmon_dev; |
119 | struct mutex update_lock; |
120 | unsigned long last_updated; /* in jiffies */ |
121 | unsigned long interval; /* in msecs */ |
122 | bool valid; /* zero until following fields are valid */ |
123 | /* registers values */ |
124 | u8 regs[ARRAY_SIZE(lm95245_reg_address)]; |
125 | u8 config1, config2; |
126 | }; |
127 | |
128 | /* Conversions */ |
129 | static int temp_from_reg_unsigned(u8 val_h, u8 val_l) |
130 | { |
131 | return val_h * 1000 + val_l * 1000 / 256; |
132 | } |
133 | |
134 | static int temp_from_reg_signed(u8 val_h, u8 val_l) |
135 | { |
136 | if (val_h & 0x80) |
137 | return (val_h - 0x100) * 1000; |
138 | return temp_from_reg_unsigned(val_h, val_l); |
139 | } |
140 | |
141 | static struct lm95245_data *lm95245_update_device(struct device *dev) |
142 | { |
143 | struct i2c_client *client = to_i2c_client(dev); |
144 | struct lm95245_data *data = i2c_get_clientdata(client); |
145 | |
146 | mutex_lock(&data->update_lock); |
147 | |
148 | if (time_after(jiffies, data->last_updated |
149 | + msecs_to_jiffies(data->interval)) || !data->valid) { |
150 | int i; |
151 | |
152 | dev_dbg(&client->dev, "Updating lm95245 data.\n"); |
153 | for (i = 0; i < ARRAY_SIZE(lm95245_reg_address); i++) |
154 | data->regs[i] |
155 | = i2c_smbus_read_byte_data(client, |
156 | lm95245_reg_address[i]); |
157 | data->last_updated = jiffies; |
158 | data->valid = 1; |
159 | } |
160 | |
161 | mutex_unlock(&data->update_lock); |
162 | |
163 | return data; |
164 | } |
165 | |
166 | static unsigned long lm95245_read_conversion_rate(struct i2c_client *client) |
167 | { |
168 | int rate; |
169 | unsigned long interval; |
170 | |
171 | rate = i2c_smbus_read_byte_data(client, LM95245_REG_RW_CONVERS_RATE); |
172 | |
173 | switch (rate) { |
174 | case RATE_CR0063: |
175 | interval = 63; |
176 | break; |
177 | case RATE_CR0364: |
178 | interval = 364; |
179 | break; |
180 | case RATE_CR1000: |
181 | interval = 1000; |
182 | break; |
183 | case RATE_CR2500: |
184 | default: |
185 | interval = 2500; |
186 | break; |
187 | } |
188 | |
189 | return interval; |
190 | } |
191 | |
192 | static unsigned long lm95245_set_conversion_rate(struct i2c_client *client, |
193 | unsigned long interval) |
194 | { |
195 | int rate; |
196 | |
197 | if (interval <= 63) { |
198 | interval = 63; |
199 | rate = RATE_CR0063; |
200 | } else if (interval <= 364) { |
201 | interval = 364; |
202 | rate = RATE_CR0364; |
203 | } else if (interval <= 1000) { |
204 | interval = 1000; |
205 | rate = RATE_CR1000; |
206 | } else { |
207 | interval = 2500; |
208 | rate = RATE_CR2500; |
209 | } |
210 | |
211 | i2c_smbus_write_byte_data(client, LM95245_REG_RW_CONVERS_RATE, rate); |
212 | |
213 | return interval; |
214 | } |
215 | |
216 | /* Sysfs stuff */ |
217 | static ssize_t show_input(struct device *dev, struct device_attribute *attr, |
218 | char *buf) |
219 | { |
220 | struct lm95245_data *data = lm95245_update_device(dev); |
221 | int temp; |
222 | int index = to_sensor_dev_attr(attr)->index; |
223 | |
224 | /* |
225 | * Index 0 (Local temp) is always signed |
226 | * Index 2 (Remote temp) has both signed and unsigned data |
227 | * use signed calculation for remote if signed bit is set |
228 | */ |
229 | if (index == 0 || data->regs[index] & 0x80) |
230 | temp = temp_from_reg_signed(data->regs[index], |
231 | data->regs[index + 1]); |
232 | else |
233 | temp = temp_from_reg_unsigned(data->regs[index + 2], |
234 | data->regs[index + 3]); |
235 | |
236 | return snprintf(buf, PAGE_SIZE - 1, "%d\n", temp); |
237 | } |
238 | |
239 | static ssize_t show_limit(struct device *dev, struct device_attribute *attr, |
240 | char *buf) |
241 | { |
242 | struct lm95245_data *data = lm95245_update_device(dev); |
243 | int index = to_sensor_dev_attr(attr)->index; |
244 | |
245 | return snprintf(buf, PAGE_SIZE - 1, "%d\n", |
246 | data->regs[index] * 1000); |
247 | } |
248 | |
249 | static ssize_t set_limit(struct device *dev, struct device_attribute *attr, |
250 | const char *buf, size_t count) |
251 | { |
252 | struct i2c_client *client = to_i2c_client(dev); |
253 | struct lm95245_data *data = i2c_get_clientdata(client); |
254 | int index = to_sensor_dev_attr(attr)->index; |
255 | unsigned long val; |
256 | |
257 | if (kstrtoul(buf, 10, &val) < 0) |
258 | return -EINVAL; |
259 | |
260 | val /= 1000; |
261 | |
262 | val = clamp_val(val, 0, (index == 6 ? 127 : 255)); |
263 | |
264 | mutex_lock(&data->update_lock); |
265 | |
266 | data->valid = 0; |
267 | |
268 | i2c_smbus_write_byte_data(client, lm95245_reg_address[index], val); |
269 | |
270 | mutex_unlock(&data->update_lock); |
271 | |
272 | return count; |
273 | } |
274 | |
275 | static ssize_t set_crit_hyst(struct device *dev, struct device_attribute *attr, |
276 | const char *buf, size_t count) |
277 | { |
278 | struct i2c_client *client = to_i2c_client(dev); |
279 | struct lm95245_data *data = i2c_get_clientdata(client); |
280 | unsigned long val; |
281 | |
282 | if (kstrtoul(buf, 10, &val) < 0) |
283 | return -EINVAL; |
284 | |
285 | val /= 1000; |
286 | |
287 | val = clamp_val(val, 0, 31); |
288 | |
289 | mutex_lock(&data->update_lock); |
290 | |
291 | data->valid = 0; |
292 | |
293 | /* shared crit hysteresis */ |
294 | i2c_smbus_write_byte_data(client, LM95245_REG_RW_COMMON_HYSTERESIS, |
295 | val); |
296 | |
297 | mutex_unlock(&data->update_lock); |
298 | |
299 | return count; |
300 | } |
301 | |
302 | static ssize_t show_type(struct device *dev, struct device_attribute *attr, |
303 | char *buf) |
304 | { |
305 | struct i2c_client *client = to_i2c_client(dev); |
306 | struct lm95245_data *data = i2c_get_clientdata(client); |
307 | |
308 | return snprintf(buf, PAGE_SIZE - 1, |
309 | data->config2 & CFG2_REMOTE_TT ? "1\n" : "2\n"); |
310 | } |
311 | |
312 | static ssize_t set_type(struct device *dev, struct device_attribute *attr, |
313 | const char *buf, size_t count) |
314 | { |
315 | struct i2c_client *client = to_i2c_client(dev); |
316 | struct lm95245_data *data = i2c_get_clientdata(client); |
317 | unsigned long val; |
318 | |
319 | if (kstrtoul(buf, 10, &val) < 0) |
320 | return -EINVAL; |
321 | if (val != 1 && val != 2) |
322 | return -EINVAL; |
323 | |
324 | mutex_lock(&data->update_lock); |
325 | |
326 | if (val == 1) |
327 | data->config2 |= CFG2_REMOTE_TT; |
328 | else |
329 | data->config2 &= ~CFG2_REMOTE_TT; |
330 | |
331 | data->valid = 0; |
332 | |
333 | i2c_smbus_write_byte_data(client, LM95245_REG_RW_CONFIG2, |
334 | data->config2); |
335 | |
336 | mutex_unlock(&data->update_lock); |
337 | |
338 | return count; |
339 | } |
340 | |
341 | static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, |
342 | char *buf) |
343 | { |
344 | struct lm95245_data *data = lm95245_update_device(dev); |
345 | int index = to_sensor_dev_attr(attr)->index; |
346 | |
347 | return snprintf(buf, PAGE_SIZE - 1, "%d\n", |
348 | !!(data->regs[9] & index)); |
349 | } |
350 | |
351 | static ssize_t show_interval(struct device *dev, struct device_attribute *attr, |
352 | char *buf) |
353 | { |
354 | struct lm95245_data *data = lm95245_update_device(dev); |
355 | |
356 | return snprintf(buf, PAGE_SIZE - 1, "%lu\n", data->interval); |
357 | } |
358 | |
359 | static ssize_t set_interval(struct device *dev, struct device_attribute *attr, |
360 | const char *buf, size_t count) |
361 | { |
362 | struct i2c_client *client = to_i2c_client(dev); |
363 | struct lm95245_data *data = i2c_get_clientdata(client); |
364 | unsigned long val; |
365 | |
366 | if (kstrtoul(buf, 10, &val) < 0) |
367 | return -EINVAL; |
368 | |
369 | mutex_lock(&data->update_lock); |
370 | |
371 | data->interval = lm95245_set_conversion_rate(client, val); |
372 | |
373 | mutex_unlock(&data->update_lock); |
374 | |
375 | return count; |
376 | } |
377 | |
378 | static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0); |
379 | static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_limit, |
380 | set_limit, 6); |
381 | static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_limit, |
382 | set_crit_hyst, 8); |
383 | static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, |
384 | STATUS1_LOC); |
385 | |
386 | static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2); |
387 | static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_limit, |
388 | set_limit, 7); |
389 | static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IWUSR | S_IRUGO, show_limit, |
390 | set_crit_hyst, 8); |
391 | static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, |
392 | STATUS1_RTCRIT); |
393 | static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, |
394 | set_type, 0); |
395 | static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, |
396 | STATUS1_DIODE_FAULT); |
397 | |
398 | static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval, |
399 | set_interval); |
400 | |
401 | static struct attribute *lm95245_attributes[] = { |
402 | &sensor_dev_attr_temp1_input.dev_attr.attr, |
403 | &sensor_dev_attr_temp1_crit.dev_attr.attr, |
404 | &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, |
405 | &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, |
406 | &sensor_dev_attr_temp2_input.dev_attr.attr, |
407 | &sensor_dev_attr_temp2_crit.dev_attr.attr, |
408 | &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr, |
409 | &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, |
410 | &sensor_dev_attr_temp2_type.dev_attr.attr, |
411 | &sensor_dev_attr_temp2_fault.dev_attr.attr, |
412 | &dev_attr_update_interval.attr, |
413 | NULL |
414 | }; |
415 | |
416 | static const struct attribute_group lm95245_group = { |
417 | .attrs = lm95245_attributes, |
418 | }; |
419 | |
420 | /* Return 0 if detection is successful, -ENODEV otherwise */ |
421 | static int lm95245_detect(struct i2c_client *new_client, |
422 | struct i2c_board_info *info) |
423 | { |
424 | struct i2c_adapter *adapter = new_client->adapter; |
425 | |
426 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) |
427 | return -ENODEV; |
428 | |
429 | if (i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID) |
430 | != MANUFACTURER_ID |
431 | || i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID) |
432 | != DEFAULT_REVISION) |
433 | return -ENODEV; |
434 | |
435 | strlcpy(info->type, DEVNAME, I2C_NAME_SIZE); |
436 | return 0; |
437 | } |
438 | |
439 | static void lm95245_init_client(struct i2c_client *client) |
440 | { |
441 | struct lm95245_data *data = i2c_get_clientdata(client); |
442 | |
443 | data->valid = 0; |
444 | data->interval = lm95245_read_conversion_rate(client); |
445 | |
446 | data->config1 = i2c_smbus_read_byte_data(client, |
447 | LM95245_REG_RW_CONFIG1); |
448 | data->config2 = i2c_smbus_read_byte_data(client, |
449 | LM95245_REG_RW_CONFIG2); |
450 | |
451 | if (data->config1 & CFG_STOP) { |
452 | /* Clear the standby bit */ |
453 | data->config1 &= ~CFG_STOP; |
454 | i2c_smbus_write_byte_data(client, LM95245_REG_RW_CONFIG1, |
455 | data->config1); |
456 | } |
457 | } |
458 | |
459 | static int lm95245_probe(struct i2c_client *new_client, |
460 | const struct i2c_device_id *id) |
461 | { |
462 | struct lm95245_data *data; |
463 | int err; |
464 | |
465 | data = devm_kzalloc(&new_client->dev, sizeof(struct lm95245_data), |
466 | GFP_KERNEL); |
467 | if (!data) |
468 | return -ENOMEM; |
469 | |
470 | i2c_set_clientdata(new_client, data); |
471 | mutex_init(&data->update_lock); |
472 | |
473 | /* Initialize the LM95245 chip */ |
474 | lm95245_init_client(new_client); |
475 | |
476 | /* Register sysfs hooks */ |
477 | err = sysfs_create_group(&new_client->dev.kobj, &lm95245_group); |
478 | if (err) |
479 | return err; |
480 | |
481 | data->hwmon_dev = hwmon_device_register(&new_client->dev); |
482 | if (IS_ERR(data->hwmon_dev)) { |
483 | err = PTR_ERR(data->hwmon_dev); |
484 | goto exit_remove_files; |
485 | } |
486 | |
487 | return 0; |
488 | |
489 | exit_remove_files: |
490 | sysfs_remove_group(&new_client->dev.kobj, &lm95245_group); |
491 | return err; |
492 | } |
493 | |
494 | static int lm95245_remove(struct i2c_client *client) |
495 | { |
496 | struct lm95245_data *data = i2c_get_clientdata(client); |
497 | |
498 | hwmon_device_unregister(data->hwmon_dev); |
499 | sysfs_remove_group(&client->dev.kobj, &lm95245_group); |
500 | |
501 | return 0; |
502 | } |
503 | |
504 | /* Driver data (common to all clients) */ |
505 | static const struct i2c_device_id lm95245_id[] = { |
506 | { DEVNAME, 0 }, |
507 | { } |
508 | }; |
509 | MODULE_DEVICE_TABLE(i2c, lm95245_id); |
510 | |
511 | static struct i2c_driver lm95245_driver = { |
512 | .class = I2C_CLASS_HWMON, |
513 | .driver = { |
514 | .name = DEVNAME, |
515 | }, |
516 | .probe = lm95245_probe, |
517 | .remove = lm95245_remove, |
518 | .id_table = lm95245_id, |
519 | .detect = lm95245_detect, |
520 | .address_list = normal_i2c, |
521 | }; |
522 | |
523 | module_i2c_driver(lm95245_driver); |
524 | |
525 | MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>"); |
526 | MODULE_DESCRIPTION("LM95245 sensor driver"); |
527 | MODULE_LICENSE("GPL"); |
528 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9