Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
w1_therm.c
Go to the documentation of this file.
1 /*
2  * w1_therm.c
3  *
4  * Copyright (c) 2004 Evgeniy Polyakov <[email protected]>
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/delay.h>
31 
32 #include "../w1.h"
33 #include "../w1_int.h"
34 #include "../w1_family.h"
35 
36 MODULE_LICENSE("GPL");
37 MODULE_AUTHOR("Evgeniy Polyakov <[email protected]>");
38 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
39 
40 /* Allow the strong pullup to be disabled, but default to enabled.
41  * If it was disabled a parasite powered device might not get the require
42  * current to do a temperature conversion. If it is enabled parasite powered
43  * devices have a better chance of getting the current required.
44  */
45 static int w1_strong_pullup = 1;
46 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
47 
48 static u8 bad_roms[][9] = {
49  {0xaa, 0x00, 0x4b, 0x46, 0xff, 0xff, 0x0c, 0x10, 0x87},
50  {}
51  };
52 
53 static ssize_t w1_therm_read(struct device *device,
54  struct device_attribute *attr, char *buf);
55 
56 static struct device_attribute w1_therm_attr =
57  __ATTR(w1_slave, S_IRUGO, w1_therm_read, NULL);
58 
59 static int w1_therm_add_slave(struct w1_slave *sl)
60 {
61  return device_create_file(&sl->dev, &w1_therm_attr);
62 }
63 
64 static void w1_therm_remove_slave(struct w1_slave *sl)
65 {
66  device_remove_file(&sl->dev, &w1_therm_attr);
67 }
68 
69 static struct w1_family_ops w1_therm_fops = {
70  .add_slave = w1_therm_add_slave,
71  .remove_slave = w1_therm_remove_slave,
72 };
73 
74 static struct w1_family w1_therm_family_DS18S20 = {
75  .fid = W1_THERM_DS18S20,
76  .fops = &w1_therm_fops,
77 };
78 
79 static struct w1_family w1_therm_family_DS18B20 = {
80  .fid = W1_THERM_DS18B20,
81  .fops = &w1_therm_fops,
82 };
83 
84 static struct w1_family w1_therm_family_DS1822 = {
85  .fid = W1_THERM_DS1822,
86  .fops = &w1_therm_fops,
87 };
88 
89 static struct w1_family w1_therm_family_DS28EA00 = {
90  .fid = W1_THERM_DS28EA00,
91  .fops = &w1_therm_fops,
92 };
93 
94 static struct w1_family w1_therm_family_DS1825 = {
95  .fid = W1_THERM_DS1825,
96  .fops = &w1_therm_fops,
97 };
98 
100 {
103  struct w1_family *f;
104  int (*convert)(u8 rom[9]);
105 };
106 
107 /* The return value is millidegrees Centigrade. */
108 static inline int w1_DS18B20_convert_temp(u8 rom[9]);
109 static inline int w1_DS18S20_convert_temp(u8 rom[9]);
110 
111 static struct w1_therm_family_converter w1_therm_families[] = {
112  {
113  .f = &w1_therm_family_DS18S20,
114  .convert = w1_DS18S20_convert_temp
115  },
116  {
117  .f = &w1_therm_family_DS1822,
118  .convert = w1_DS18B20_convert_temp
119  },
120  {
121  .f = &w1_therm_family_DS18B20,
122  .convert = w1_DS18B20_convert_temp
123  },
124  {
125  .f = &w1_therm_family_DS28EA00,
126  .convert = w1_DS18B20_convert_temp
127  },
128  {
129  .f = &w1_therm_family_DS1825,
130  .convert = w1_DS18B20_convert_temp
131  }
132 };
133 
134 static inline int w1_DS18B20_convert_temp(u8 rom[9])
135 {
136  s16 t = le16_to_cpup((__le16 *)rom);
137  return t*1000/16;
138 }
139 
140 static inline int w1_DS18S20_convert_temp(u8 rom[9])
141 {
142  int t, h;
143 
144  if (!rom[7])
145  return 0;
146 
147  if (rom[1] == 0)
148  t = ((s32)rom[0] >> 1)*1000;
149  else
150  t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
151 
152  t -= 250;
153  h = 1000*((s32)rom[7] - (s32)rom[6]);
154  h /= (s32)rom[7];
155  t += h;
156 
157  return t;
158 }
159 
160 static inline int w1_convert_temp(u8 rom[9], u8 fid)
161 {
162  int i;
163 
164  for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
165  if (w1_therm_families[i].f->fid == fid)
166  return w1_therm_families[i].convert(rom);
167 
168  return 0;
169 }
170 
171 static int w1_therm_check_rom(u8 rom[9])
172 {
173  int i;
174 
175  for (i=0; i<sizeof(bad_roms)/9; ++i)
176  if (!memcmp(bad_roms[i], rom, 9))
177  return 1;
178 
179  return 0;
180 }
181 
182 static ssize_t w1_therm_read(struct device *device,
183  struct device_attribute *attr, char *buf)
184 {
185  struct w1_slave *sl = dev_to_w1_slave(device);
186  struct w1_master *dev = sl->master;
187  u8 rom[9], crc, verdict, external_power;
188  int i, max_trying = 10;
189  ssize_t c = PAGE_SIZE;
190 
191  i = mutex_lock_interruptible(&dev->bus_mutex);
192  if (i != 0)
193  return i;
194 
195  memset(rom, 0, sizeof(rom));
196 
197  verdict = 0;
198  crc = 0;
199 
200  while (max_trying--) {
201  if (!w1_reset_select_slave(sl)) {
202  int count = 0;
203  unsigned int tm = 750;
204  unsigned long sleep_rem;
205 
206  w1_write_8(dev, W1_READ_PSUPPLY);
207  external_power = w1_read_8(dev);
208 
209  if (w1_reset_select_slave(sl))
210  continue;
211 
212  /* 750ms strong pullup (or delay) after the convert */
213  if (!external_power && w1_strong_pullup)
214  w1_next_pullup(dev, tm);
215 
216  w1_write_8(dev, W1_CONVERT_TEMP);
217 
218  if (external_power) {
219  mutex_unlock(&dev->bus_mutex);
220 
221  sleep_rem = msleep_interruptible(tm);
222  if (sleep_rem != 0)
223  return -EINTR;
224 
225  i = mutex_lock_interruptible(&dev->bus_mutex);
226  if (i != 0)
227  return i;
228  } else if (!w1_strong_pullup) {
229  sleep_rem = msleep_interruptible(tm);
230  if (sleep_rem != 0) {
231  mutex_unlock(&dev->bus_mutex);
232  return -EINTR;
233  }
234  }
235 
236  if (!w1_reset_select_slave(sl)) {
237 
238  w1_write_8(dev, W1_READ_SCRATCHPAD);
239  if ((count = w1_read_block(dev, rom, 9)) != 9) {
240  dev_warn(device, "w1_read_block() "
241  "returned %u instead of 9.\n",
242  count);
243  }
244 
245  crc = w1_calc_crc8(rom, 8);
246 
247  if (rom[8] == crc)
248  verdict = 1;
249  }
250  }
251 
252  if (!w1_therm_check_rom(rom))
253  break;
254  }
255 
256  for (i = 0; i < 9; ++i)
257  c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
258  c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
259  crc, (verdict) ? "YES" : "NO");
260  if (verdict)
261  memcpy(sl->rom, rom, sizeof(sl->rom));
262  else
263  dev_warn(device, "18S20 doesn't respond to CONVERT_TEMP.\n");
264 
265  for (i = 0; i < 9; ++i)
266  c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", sl->rom[i]);
267 
268  c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
269  w1_convert_temp(rom, sl->family->fid));
270  mutex_unlock(&dev->bus_mutex);
271 
272  return PAGE_SIZE - c;
273 }
274 
275 static int __init w1_therm_init(void)
276 {
277  int err, i;
278 
279  for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
280  err = w1_register_family(w1_therm_families[i].f);
281  if (err)
282  w1_therm_families[i].broken = 1;
283  }
284 
285  return 0;
286 }
287 
288 static void __exit w1_therm_fini(void)
289 {
290  int i;
291 
292  for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
293  if (!w1_therm_families[i].broken)
294  w1_unregister_family(w1_therm_families[i].f);
295 }
296 
297 module_init(w1_therm_init);
298 module_exit(w1_therm_fini);