?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'r6040-next'
[linux/fpc-iii.git] / drivers / w1 / slaves / w1_therm.c
blob581a300fd6cda40265c5bdde527ced6157c56e06
1 /*
2 * w1_therm.c
3 *
4 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the therms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include <asm/types.h>
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/sched.h>
28 #include <linux/device.h>
29 #include <linux/types.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h>
32
33 #include "../w1.h"
34 #include "../w1_int.h"
35 #include "../w1_family.h"
36
37 MODULE_LICENSE("GPL");
38 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
39 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
40 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
41 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
42 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
43 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
44 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
45
46 /* Allow the strong pullup to be disabled, but default to enabled.
47 * If it was disabled a parasite powered device might not get the require
48 * current to do a temperature conversion. If it is enabled parasite powered
49 * devices have a better chance of getting the current required.
50 * In case the parasite power-detection is not working (seems to be the case
51 * for some DS18S20) the strong pullup can also be forced, regardless of the
52 * power state of the devices.
53 *
54 * Summary of options:
55 * - strong_pullup = 0 Disable strong pullup completely
56 * - strong_pullup = 1 Enable automatic strong pullup detection
57 * - strong_pullup = 2 Force strong pullup
58 */
59 static int w1_strong_pullup = 1;
60 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
61
62 struct w1_therm_family_data {
63 uint8_t rom[9];
64 atomic_t refcnt;
65 };
66
67 /* return the address of the refcnt in the family data */
68 #define THERM_REFCNT(family_data) \
69 (&((struct w1_therm_family_data*)family_data)->refcnt)
70
71 static int w1_therm_add_slave(struct w1_slave *sl)
72 {
73 sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
74 GFP_KERNEL);
75 if (!sl->family_data)
76 return -ENOMEM;
77 atomic_set(THERM_REFCNT(sl->family_data), 1);
78 return 0;
79 }
80
81 static void w1_therm_remove_slave(struct w1_slave *sl)
82 {
83 int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
84 while(refcnt) {
85 msleep(1000);
86 refcnt = atomic_read(THERM_REFCNT(sl->family_data));
87 }
88 kfree(sl->family_data);
89 sl->family_data = NULL;
90 }
91
92 static ssize_t w1_slave_show(struct device *device,
93 struct device_attribute *attr, char *buf);
94
95 static ssize_t w1_slave_store(struct device *device,
96 struct device_attribute *attr, const char *buf, size_t size);
97
98 static ssize_t w1_seq_show(struct device *device,
99 struct device_attribute *attr, char *buf);
100
101 static DEVICE_ATTR_RW(w1_slave);
102 static DEVICE_ATTR_RO(w1_seq);
103
104 static struct attribute *w1_therm_attrs[] = {
105 &dev_attr_w1_slave.attr,
106 NULL,
107 };
108
109 static struct attribute *w1_ds28ea00_attrs[] = {
110 &dev_attr_w1_slave.attr,
111 &dev_attr_w1_seq.attr,
112 NULL,
113 };
114 ATTRIBUTE_GROUPS(w1_therm);
115 ATTRIBUTE_GROUPS(w1_ds28ea00);
116
117 static struct w1_family_ops w1_therm_fops = {
118 .add_slave = w1_therm_add_slave,
119 .remove_slave = w1_therm_remove_slave,
120 .groups = w1_therm_groups,
121 };
122
123 static struct w1_family_ops w1_ds28ea00_fops = {
124 .add_slave = w1_therm_add_slave,
125 .remove_slave = w1_therm_remove_slave,
126 .groups = w1_ds28ea00_groups,
127 };
128
129 static struct w1_family w1_therm_family_DS18S20 = {
130 .fid = W1_THERM_DS18S20,
131 .fops = &w1_therm_fops,
132 };
133
134 static struct w1_family w1_therm_family_DS18B20 = {
135 .fid = W1_THERM_DS18B20,
136 .fops = &w1_therm_fops,
137 };
138
139 static struct w1_family w1_therm_family_DS1822 = {
140 .fid = W1_THERM_DS1822,
141 .fops = &w1_therm_fops,
142 };
143
144 static struct w1_family w1_therm_family_DS28EA00 = {
145 .fid = W1_THERM_DS28EA00,
146 .fops = &w1_ds28ea00_fops,
147 };
148
149 static struct w1_family w1_therm_family_DS1825 = {
150 .fid = W1_THERM_DS1825,
151 .fops = &w1_therm_fops,
152 };
153
154 struct w1_therm_family_converter
155 {
156 u8 broken;
157 u16 reserved;
158 struct w1_family *f;
159 int (*convert)(u8 rom[9]);
160 int (*precision)(struct device *device, int val);
161 int (*eeprom)(struct device *device);
162 };
163
164 /* write configuration to eeprom */
165 static inline int w1_therm_eeprom(struct device *device);
166
167 /* Set precision for conversion */
168 static inline int w1_DS18B20_precision(struct device *device, int val);
169 static inline int w1_DS18S20_precision(struct device *device, int val);
170
171 /* The return value is millidegrees Centigrade. */
172 static inline int w1_DS18B20_convert_temp(u8 rom[9]);
173 static inline int w1_DS18S20_convert_temp(u8 rom[9]);
174
175 static struct w1_therm_family_converter w1_therm_families[] = {
176 {
177 .f = &w1_therm_family_DS18S20,
178 .convert = w1_DS18S20_convert_temp,
179 .precision = w1_DS18S20_precision,
180 .eeprom = w1_therm_eeprom
181 },
182 {
183 .f = &w1_therm_family_DS1822,
184 .convert = w1_DS18B20_convert_temp,
185 .precision = w1_DS18S20_precision,
186 .eeprom = w1_therm_eeprom
187 },
188 {
189 .f = &w1_therm_family_DS18B20,
190 .convert = w1_DS18B20_convert_temp,
191 .precision = w1_DS18B20_precision,
192 .eeprom = w1_therm_eeprom
193 },
194 {
195 .f = &w1_therm_family_DS28EA00,
196 .convert = w1_DS18B20_convert_temp,
197 .precision = w1_DS18S20_precision,
198 .eeprom = w1_therm_eeprom
199 },
200 {
201 .f = &w1_therm_family_DS1825,
202 .convert = w1_DS18B20_convert_temp,
203 .precision = w1_DS18S20_precision,
204 .eeprom = w1_therm_eeprom
205 }
206 };
207
208 static inline int w1_therm_eeprom(struct device *device)
209 {
210 struct w1_slave *sl = dev_to_w1_slave(device);
211 struct w1_master *dev = sl->master;
212 u8 rom[9], external_power;
213 int ret, max_trying = 10;
214 u8 *family_data = sl->family_data;
215
216 ret = mutex_lock_interruptible(&dev->bus_mutex);
217 if (ret != 0)
218 goto post_unlock;
219
220 if (!sl->family_data) {
221 ret = -ENODEV;
222 goto pre_unlock;
223 }
224
225 /* prevent the slave from going away in sleep */
226 atomic_inc(THERM_REFCNT(family_data));
227 memset(rom, 0, sizeof(rom));
228
229 while (max_trying--) {
230 if (!w1_reset_select_slave(sl)) {
231 unsigned int tm = 10;
232 unsigned long sleep_rem;
233
234 /* check if in parasite mode */
235 w1_write_8(dev, W1_READ_PSUPPLY);
236 external_power = w1_read_8(dev);
237
238 if (w1_reset_select_slave(sl))
239 continue;
240
241 /* 10ms strong pullup/delay after the copy command */
242 if (w1_strong_pullup == 2 ||
243 (!external_power && w1_strong_pullup))
244 w1_next_pullup(dev, tm);
245
246 w1_write_8(dev, W1_COPY_SCRATCHPAD);
247
248 if (external_power) {
249 mutex_unlock(&dev->bus_mutex);
250
251 sleep_rem = msleep_interruptible(tm);
252 if (sleep_rem != 0) {
253 ret = -EINTR;
254 goto post_unlock;
255 }
256
257 ret = mutex_lock_interruptible(&dev->bus_mutex);
258 if (ret != 0)
259 goto post_unlock;
260 } else if (!w1_strong_pullup) {
261 sleep_rem = msleep_interruptible(tm);
262 if (sleep_rem != 0) {
263 ret = -EINTR;
264 goto pre_unlock;
265 }
266 }
267
268 break;
269 }
270 }
271
272 pre_unlock:
273 mutex_unlock(&dev->bus_mutex);
274
275 post_unlock:
276 atomic_dec(THERM_REFCNT(family_data));
277 return ret;
278 }
279
280 /* DS18S20 does not feature configuration register */
281 static inline int w1_DS18S20_precision(struct device *device, int val)
282 {
283 return 0;
284 }
285
286 static inline int w1_DS18B20_precision(struct device *device, int val)
287 {
288 struct w1_slave *sl = dev_to_w1_slave(device);
289 struct w1_master *dev = sl->master;
290 u8 rom[9], crc;
291 int ret, max_trying = 10;
292 u8 *family_data = sl->family_data;
293 uint8_t precision_bits;
294 uint8_t mask = 0x60;
295
296 if(val > 12 || val < 9) {
297 pr_warn("Unsupported precision\n");
298 return -1;
299 }
300
301 ret = mutex_lock_interruptible(&dev->bus_mutex);
302 if (ret != 0)
303 goto post_unlock;
304
305 if (!sl->family_data) {
306 ret = -ENODEV;
307 goto pre_unlock;
308 }
309
310 /* prevent the slave from going away in sleep */
311 atomic_inc(THERM_REFCNT(family_data));
312 memset(rom, 0, sizeof(rom));
313
314 /* translate precision to bitmask (see datasheet page 9) */
315 switch (val) {
316 case 9:
317 precision_bits = 0x00;
318 break;
319 case 10:
320 precision_bits = 0x20;
321 break;
322 case 11:
323 precision_bits = 0x40;
324 break;
325 case 12:
326 default:
327 precision_bits = 0x60;
328 break;
329 }
330
331 while (max_trying--) {
332 crc = 0;
333
334 if (!w1_reset_select_slave(sl)) {
335 int count = 0;
336
337 /* read values to only alter precision bits */
338 w1_write_8(dev, W1_READ_SCRATCHPAD);
339 if ((count = w1_read_block(dev, rom, 9)) != 9)
340 dev_warn(device, "w1_read_block() returned %u instead of 9.\n", count);
341
342 crc = w1_calc_crc8(rom, 8);
343 if (rom[8] == crc) {
344 rom[4] = (rom[4] & ~mask) | (precision_bits & mask);
345
346 if (!w1_reset_select_slave(sl)) {
347 w1_write_8(dev, W1_WRITE_SCRATCHPAD);
348 w1_write_8(dev, rom[2]);
349 w1_write_8(dev, rom[3]);
350 w1_write_8(dev, rom[4]);
351
352 break;
353 }
354 }
355 }
356 }
357
358 pre_unlock:
359 mutex_unlock(&dev->bus_mutex);
360
361 post_unlock:
362 atomic_dec(THERM_REFCNT(family_data));
363 return ret;
364 }
365
366 static inline int w1_DS18B20_convert_temp(u8 rom[9])
367 {
368 s16 t = le16_to_cpup((__le16 *)rom);
369 return t*1000/16;
370 }
371
372 static inline int w1_DS18S20_convert_temp(u8 rom[9])
373 {
374 int t, h;
375
376 if (!rom[7])
377 return 0;
378
379 if (rom[1] == 0)
380 t = ((s32)rom[0] >> 1)*1000;
381 else
382 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
383
384 t -= 250;
385 h = 1000*((s32)rom[7] - (s32)rom[6]);
386 h /= (s32)rom[7];
387 t += h;
388
389 return t;
390 }
391
392 static inline int w1_convert_temp(u8 rom[9], u8 fid)
393 {
394 int i;
395
396 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
397 if (w1_therm_families[i].f->fid == fid)
398 return w1_therm_families[i].convert(rom);
399
400 return 0;
401 }
402
403 static ssize_t w1_slave_store(struct device *device,
404 struct device_attribute *attr, const char *buf,
405 size_t size)
406 {
407 int val, ret;
408 struct w1_slave *sl = dev_to_w1_slave(device);
409 int i;
410
411 ret = kstrtoint(buf, 0, &val);
412 if (ret)
413 return ret;
414
415 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
416 if (w1_therm_families[i].f->fid == sl->family->fid) {
417 /* zero value indicates to write current configuration to eeprom */
418 if (0 == val)
419 ret = w1_therm_families[i].eeprom(device);
420 else
421 ret = w1_therm_families[i].precision(device, val);
422 break;
423 }
424 }
425 return ret ? : size;
426 }
427
428 static ssize_t w1_slave_show(struct device *device,
429 struct device_attribute *attr, char *buf)
430 {
431 struct w1_slave *sl = dev_to_w1_slave(device);
432 struct w1_master *dev = sl->master;
433 u8 rom[9], crc, verdict, external_power;
434 int i, ret, max_trying = 10;
435 ssize_t c = PAGE_SIZE;
436 u8 *family_data = sl->family_data;
437
438 ret = mutex_lock_interruptible(&dev->bus_mutex);
439 if (ret != 0)
440 goto post_unlock;
441
442 if(!sl->family_data)
443 {
444 ret = -ENODEV;
445 goto pre_unlock;
446 }
447
448 /* prevent the slave from going away in sleep */
449 atomic_inc(THERM_REFCNT(family_data));
450 memset(rom, 0, sizeof(rom));
451
452 while (max_trying--) {
453
454 verdict = 0;
455 crc = 0;
456
457 if (!w1_reset_select_slave(sl)) {
458 int count = 0;
459 unsigned int tm = 750;
460 unsigned long sleep_rem;
461
462 w1_write_8(dev, W1_READ_PSUPPLY);
463 external_power = w1_read_8(dev);
464
465 if (w1_reset_select_slave(sl))
466 continue;
467
468 /* 750ms strong pullup (or delay) after the convert */
469 if (w1_strong_pullup == 2 ||
470 (!external_power && w1_strong_pullup))
471 w1_next_pullup(dev, tm);
472
473 w1_write_8(dev, W1_CONVERT_TEMP);
474
475 if (external_power) {
476 mutex_unlock(&dev->bus_mutex);
477
478 sleep_rem = msleep_interruptible(tm);
479 if (sleep_rem != 0) {
480 ret = -EINTR;
481 goto post_unlock;
482 }
483
484 ret = mutex_lock_interruptible(&dev->bus_mutex);
485 if (ret != 0)
486 goto post_unlock;
487 } else if (!w1_strong_pullup) {
488 sleep_rem = msleep_interruptible(tm);
489 if (sleep_rem != 0) {
490 ret = -EINTR;
491 goto pre_unlock;
492 }
493 }
494
495 if (!w1_reset_select_slave(sl)) {
496
497 w1_write_8(dev, W1_READ_SCRATCHPAD);
498 if ((count = w1_read_block(dev, rom, 9)) != 9) {
499 dev_warn(device, "w1_read_block() "
500 "returned %u instead of 9.\n",
501 count);
502 }
503
504 crc = w1_calc_crc8(rom, 8);
505
506 if (rom[8] == crc)
507 verdict = 1;
508 }
509 }
510
511 if (verdict)
512 break;
513 }
514
515 for (i = 0; i < 9; ++i)
516 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
517 c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
518 crc, (verdict) ? "YES" : "NO");
519 if (verdict)
520 memcpy(family_data, rom, sizeof(rom));
521 else
522 dev_warn(device, "Read failed CRC check\n");
523
524 for (i = 0; i < 9; ++i)
525 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
526 ((u8 *)family_data)[i]);
527
528 c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
529 w1_convert_temp(rom, sl->family->fid));
530 ret = PAGE_SIZE - c;
531
532 pre_unlock:
533 mutex_unlock(&dev->bus_mutex);
534
535 post_unlock:
536 atomic_dec(THERM_REFCNT(family_data));
537 return ret;
538 }
539
540 #define W1_42_CHAIN 0x99
541 #define W1_42_CHAIN_OFF 0x3C
542 #define W1_42_CHAIN_OFF_INV 0xC3
543 #define W1_42_CHAIN_ON 0x5A
544 #define W1_42_CHAIN_ON_INV 0xA5
545 #define W1_42_CHAIN_DONE 0x96
546 #define W1_42_CHAIN_DONE_INV 0x69
547 #define W1_42_COND_READ 0x0F
548 #define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
549 #define W1_42_FINISHED_BYTE 0xFF
550 static ssize_t w1_seq_show(struct device *device,
551 struct device_attribute *attr, char *buf)
552 {
553 struct w1_slave *sl = dev_to_w1_slave(device);
554 ssize_t c = PAGE_SIZE;
555 int rv;
556 int i;
557 u8 ack;
558 u64 rn;
559 struct w1_reg_num *reg_num;
560 int seq = 0;
561
562 mutex_lock(&sl->master->bus_mutex);
563 /* Place all devices in CHAIN state */
564 if (w1_reset_bus(sl->master))
565 goto error;
566 w1_write_8(sl->master, W1_SKIP_ROM);
567 w1_write_8(sl->master, W1_42_CHAIN);
568 w1_write_8(sl->master, W1_42_CHAIN_ON);
569 w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
570 msleep(sl->master->pullup_duration);
571
572 /* check for acknowledgment */
573 ack = w1_read_8(sl->master);
574 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
575 goto error;
576
577 /* In case the bus fails to send 0xFF, limit*/
578 for (i = 0; i <= 64; i++) {
579 if (w1_reset_bus(sl->master))
580 goto error;
581
582 w1_write_8(sl->master, W1_42_COND_READ);
583 rv = w1_read_block(sl->master, (u8 *)&rn, 8);
584 reg_num = (struct w1_reg_num *) &rn;
585 if (reg_num->family == W1_42_FINISHED_BYTE)
586 break;
587 if (sl->reg_num.id == reg_num->id)
588 seq = i;
589
590 w1_write_8(sl->master, W1_42_CHAIN);
591 w1_write_8(sl->master, W1_42_CHAIN_DONE);
592 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
593 w1_read_block(sl->master, &ack, sizeof(ack));
594
595 /* check for acknowledgment */
596 ack = w1_read_8(sl->master);
597 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
598 goto error;
599
600 }
601
602 /* Exit from CHAIN state */
603 if (w1_reset_bus(sl->master))
604 goto error;
605 w1_write_8(sl->master, W1_SKIP_ROM);
606 w1_write_8(sl->master, W1_42_CHAIN);
607 w1_write_8(sl->master, W1_42_CHAIN_OFF);
608 w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
609
610 /* check for acknowledgment */
611 ack = w1_read_8(sl->master);
612 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
613 goto error;
614 mutex_unlock(&sl->master->bus_mutex);
615
616 c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
617 return PAGE_SIZE - c;
618 error:
619 mutex_unlock(&sl->master->bus_mutex);
620 return -EIO;
621 }
622
623 static int __init w1_therm_init(void)
624 {
625 int err, i;
626
627 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
628 err = w1_register_family(w1_therm_families[i].f);
629 if (err)
630 w1_therm_families[i].broken = 1;
631 }
632
633 return 0;
634 }
635
636 static void __exit w1_therm_fini(void)
637 {
638 int i;
639
640 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
641 if (!w1_therm_families[i].broken)
642 w1_unregister_family(w1_therm_families[i].f);
643 }
644
645 module_init(w1_therm_init);
646 module_exit(w1_therm_fini);
Linux with added FPC-III support