blob: 2f029e8f4f95d7fbc15a2af11f2b8e28abce7e34 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Evgeniy Polyakov77859252005-05-20 22:33:25 +04002 * w1_therm.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Evgeniy Polyakova8018762011-08-25 15:59:06 -07004 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
Evgeniy Polyakov77859252005-05-20 22:33:25 +04005 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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>
Al Virof6a57032006-10-18 01:47:25 -040027#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/device.h>
29#include <linux/types.h>
David Frieseb2c0da2014-01-15 22:29:24 -060030#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/delay.h>
32
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +030033#include "../w1.h"
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +030034#include "../w1_int.h"
35#include "../w1_family.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37MODULE_LICENSE("GPL");
Evgeniy Polyakova8018762011-08-25 15:59:06 -070038MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070039MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
Alexander Stein8d7bda52013-05-26 20:06:50 +020040MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
41MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
42MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
43MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
44MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
David Fries6cd15972008-10-15 22:04:43 -070046/* 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.
Michael Arndt29e55072013-02-17 20:51:20 +010050 * 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
David Fries6cd15972008-10-15 22:04:43 -070058 */
59static int w1_strong_pullup = 1;
60module_param_named(strong_pullup, w1_strong_pullup, int, 0);
61
David Friesf7134ee2015-05-08 19:51:50 -050062struct 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
David Frieseb2c0da2014-01-15 22:29:24 -060071static int w1_therm_add_slave(struct w1_slave *sl)
72{
David Friesf7134ee2015-05-08 19:51:50 -050073 sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
74 GFP_KERNEL);
David Frieseb2c0da2014-01-15 22:29:24 -060075 if (!sl->family_data)
76 return -ENOMEM;
David Friesf7134ee2015-05-08 19:51:50 -050077 atomic_set(THERM_REFCNT(sl->family_data), 1);
David Frieseb2c0da2014-01-15 22:29:24 -060078 return 0;
79}
80
81static void w1_therm_remove_slave(struct w1_slave *sl)
82{
David Friesf7134ee2015-05-08 19:51:50 -050083 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 }
David Frieseb2c0da2014-01-15 22:29:24 -060088 kfree(sl->family_data);
89 sl->family_data = NULL;
90}
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -070092static ssize_t w1_slave_show(struct device *device,
David Fries347ba8a2008-10-15 22:04:51 -070093 struct device_attribute *attr, char *buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Matt Campbelld9411e52015-04-28 07:44:17 -040095static ssize_t w1_seq_show(struct device *device,
96 struct device_attribute *attr, char *buf);
97
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -070098static DEVICE_ATTR_RO(w1_slave);
Matt Campbelld9411e52015-04-28 07:44:17 -040099static DEVICE_ATTR_RO(w1_seq);
Evgeniy Polyakovd2a4ef62005-08-11 17:27:50 +0400100
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700101static struct attribute *w1_therm_attrs[] = {
102 &dev_attr_w1_slave.attr,
103 NULL,
104};
Matt Campbelld9411e52015-04-28 07:44:17 -0400105
106static struct attribute *w1_ds28ea00_attrs[] = {
107 &dev_attr_w1_slave.attr,
108 &dev_attr_w1_seq.attr,
109 NULL,
110};
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700111ATTRIBUTE_GROUPS(w1_therm);
Matt Campbelld9411e52015-04-28 07:44:17 -0400112ATTRIBUTE_GROUPS(w1_ds28ea00);
Evgeniy Polyakovd2a4ef62005-08-11 17:27:50 +0400113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114static struct w1_family_ops w1_therm_fops = {
David Frieseb2c0da2014-01-15 22:29:24 -0600115 .add_slave = w1_therm_add_slave,
116 .remove_slave = w1_therm_remove_slave,
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700117 .groups = w1_therm_groups,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118};
119
Matt Campbelld9411e52015-04-28 07:44:17 -0400120static struct w1_family_ops w1_ds28ea00_fops = {
121 .add_slave = w1_therm_add_slave,
122 .remove_slave = w1_therm_remove_slave,
123 .groups = w1_ds28ea00_groups,
124};
125
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400126static struct w1_family w1_therm_family_DS18S20 = {
127 .fid = W1_THERM_DS18S20,
128 .fops = &w1_therm_fops,
129};
130
131static struct w1_family w1_therm_family_DS18B20 = {
132 .fid = W1_THERM_DS18B20,
133 .fops = &w1_therm_fops,
134};
Evgeniy Polyakovd2a4ef62005-08-11 17:27:50 +0400135
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400136static struct w1_family w1_therm_family_DS1822 = {
137 .fid = W1_THERM_DS1822,
138 .fops = &w1_therm_fops,
139};
140
Christian Glindkampf7b13712011-07-26 16:08:55 -0700141static struct w1_family w1_therm_family_DS28EA00 = {
142 .fid = W1_THERM_DS28EA00,
Matt Campbelld9411e52015-04-28 07:44:17 -0400143 .fops = &w1_ds28ea00_fops,
Christian Glindkampf7b13712011-07-26 16:08:55 -0700144};
145
Raphael Assenatf3261df2012-08-16 12:56:40 -0400146static struct w1_family w1_therm_family_DS1825 = {
147 .fid = W1_THERM_DS1825,
148 .fops = &w1_therm_fops,
149};
150
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400151struct w1_therm_family_converter
152{
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400153 u8 broken;
154 u16 reserved;
155 struct w1_family *f;
156 int (*convert)(u8 rom[9]);
157};
158
David Fries7129b122008-02-06 01:38:09 -0800159/* The return value is millidegrees Centigrade. */
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400160static inline int w1_DS18B20_convert_temp(u8 rom[9]);
161static inline int w1_DS18S20_convert_temp(u8 rom[9]);
162
163static struct w1_therm_family_converter w1_therm_families[] = {
164 {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400165 .f = &w1_therm_family_DS18S20,
166 .convert = w1_DS18S20_convert_temp
167 },
168 {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400169 .f = &w1_therm_family_DS1822,
170 .convert = w1_DS18B20_convert_temp
171 },
172 {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400173 .f = &w1_therm_family_DS18B20,
174 .convert = w1_DS18B20_convert_temp
175 },
Christian Glindkampf7b13712011-07-26 16:08:55 -0700176 {
177 .f = &w1_therm_family_DS28EA00,
178 .convert = w1_DS18B20_convert_temp
179 },
Raphael Assenatf3261df2012-08-16 12:56:40 -0400180 {
181 .f = &w1_therm_family_DS1825,
182 .convert = w1_DS18B20_convert_temp
183 }
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400184};
185
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400186static inline int w1_DS18B20_convert_temp(u8 rom[9])
187{
Ian Dall9a6a1ec2010-04-23 13:17:53 -0400188 s16 t = le16_to_cpup((__le16 *)rom);
189 return t*1000/16;
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400190}
191
192static inline int w1_DS18S20_convert_temp(u8 rom[9])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 int t, h;
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400195
196 if (!rom[7])
197 return 0;
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +0300198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 if (rom[1] == 0)
200 t = ((s32)rom[0] >> 1)*1000;
201 else
202 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +0300203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 t -= 250;
205 h = 1000*((s32)rom[7] - (s32)rom[6]);
206 h /= (s32)rom[7];
207 t += h;
208
209 return t;
210}
211
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400212static inline int w1_convert_temp(u8 rom[9], u8 fid)
213{
214 int i;
215
Ahmed S. Darwish9d0094d2007-02-12 00:52:05 -0800216 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
Evgeniy Polyakov4e470aa2005-05-20 22:50:33 +0400217 if (w1_therm_families[i].f->fid == fid)
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400218 return w1_therm_families[i].convert(rom);
219
220 return 0;
221}
222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700224static ssize_t w1_slave_show(struct device *device,
David Fries347ba8a2008-10-15 22:04:51 -0700225 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
David Fries347ba8a2008-10-15 22:04:51 -0700227 struct w1_slave *sl = dev_to_w1_slave(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 struct w1_master *dev = sl->master;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100229 u8 rom[9], crc, verdict, external_power;
David Friesf7134ee2015-05-08 19:51:50 -0500230 int i, ret, max_trying = 10;
David Fries347ba8a2008-10-15 22:04:51 -0700231 ssize_t c = PAGE_SIZE;
David Friesf7134ee2015-05-08 19:51:50 -0500232 u8 *family_data = sl->family_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
David Friesf7134ee2015-05-08 19:51:50 -0500234 ret = mutex_lock_interruptible(&dev->bus_mutex);
235 if (ret != 0)
236 goto post_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
David Friesf7134ee2015-05-08 19:51:50 -0500238 if(!sl->family_data)
239 {
240 ret = -ENODEV;
241 goto pre_unlock;
242 }
243
244 /* prevent the slave from going away in sleep */
245 atomic_inc(THERM_REFCNT(family_data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 memset(rom, 0, sizeof(rom));
247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 while (max_trying--) {
David Stevenson867ff982012-12-18 01:37:56 +0000249
250 verdict = 0;
251 crc = 0;
252
Evgeniy Polyakovea7d8f62005-08-11 17:27:49 +0400253 if (!w1_reset_select_slave(sl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 int count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 unsigned int tm = 750;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100256 unsigned long sleep_rem;
257
258 w1_write_8(dev, W1_READ_PSUPPLY);
259 external_power = w1_read_8(dev);
260
261 if (w1_reset_select_slave(sl))
262 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
David Fries6cd15972008-10-15 22:04:43 -0700264 /* 750ms strong pullup (or delay) after the convert */
Michael Arndt29e55072013-02-17 20:51:20 +0100265 if (w1_strong_pullup == 2 ||
266 (!external_power && w1_strong_pullup))
David Fries6cd15972008-10-15 22:04:43 -0700267 w1_next_pullup(dev, tm);
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 w1_write_8(dev, W1_CONVERT_TEMP);
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100270
271 if (external_power) {
NeilBrownb02f8be2012-05-18 15:59:52 +1000272 mutex_unlock(&dev->bus_mutex);
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100273
274 sleep_rem = msleep_interruptible(tm);
David Friesf7134ee2015-05-08 19:51:50 -0500275 if (sleep_rem != 0) {
276 ret = -EINTR;
277 goto post_unlock;
278 }
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100279
David Friesf7134ee2015-05-08 19:51:50 -0500280 ret = mutex_lock_interruptible(&dev->bus_mutex);
281 if (ret != 0)
282 goto post_unlock;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100283 } else if (!w1_strong_pullup) {
284 sleep_rem = msleep_interruptible(tm);
285 if (sleep_rem != 0) {
David Friesf7134ee2015-05-08 19:51:50 -0500286 ret = -EINTR;
287 goto pre_unlock;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100288 }
289 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Evgeniy Polyakovea7d8f62005-08-11 17:27:49 +0400291 if (!w1_reset_select_slave(sl)) {
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 w1_write_8(dev, W1_READ_SCRATCHPAD);
294 if ((count = w1_read_block(dev, rom, 9)) != 9) {
David Fries347ba8a2008-10-15 22:04:51 -0700295 dev_warn(device, "w1_read_block() "
296 "returned %u instead of 9.\n",
297 count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 }
299
300 crc = w1_calc_crc8(rom, 8);
301
David Fries80c002d2008-01-22 03:31:39 -0800302 if (rom[8] == crc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 verdict = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 }
305 }
306
David Stevenson867ff982012-12-18 01:37:56 +0000307 if (verdict)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 break;
309 }
310
311 for (i = 0; i < 9; ++i)
David Fries347ba8a2008-10-15 22:04:51 -0700312 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
313 c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 crc, (verdict) ? "YES" : "NO");
315 if (verdict)
David Friesf7134ee2015-05-08 19:51:50 -0500316 memcpy(family_data, rom, sizeof(rom));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 else
David Stevenson867ff982012-12-18 01:37:56 +0000318 dev_warn(device, "Read failed CRC check\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 for (i = 0; i < 9; ++i)
David Frieseb2c0da2014-01-15 22:29:24 -0600321 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
David Friesf7134ee2015-05-08 19:51:50 -0500322 ((u8 *)family_data)[i]);
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +0300323
David Fries347ba8a2008-10-15 22:04:51 -0700324 c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
325 w1_convert_temp(rom, sl->family->fid));
David Friesf7134ee2015-05-08 19:51:50 -0500326 ret = PAGE_SIZE - c;
327
328pre_unlock:
NeilBrownb02f8be2012-05-18 15:59:52 +1000329 mutex_unlock(&dev->bus_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
David Friesf7134ee2015-05-08 19:51:50 -0500331post_unlock:
332 atomic_dec(THERM_REFCNT(family_data));
333 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
335
Matt Campbelld9411e52015-04-28 07:44:17 -0400336#define W1_42_CHAIN 0x99
337#define W1_42_CHAIN_OFF 0x3C
338#define W1_42_CHAIN_OFF_INV 0xC3
339#define W1_42_CHAIN_ON 0x5A
340#define W1_42_CHAIN_ON_INV 0xA5
341#define W1_42_CHAIN_DONE 0x96
342#define W1_42_CHAIN_DONE_INV 0x69
343#define W1_42_COND_READ 0x0F
344#define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
345#define W1_42_FINISHED_BYTE 0xFF
346static ssize_t w1_seq_show(struct device *device,
347 struct device_attribute *attr, char *buf)
348{
349 struct w1_slave *sl = dev_to_w1_slave(device);
350 ssize_t c = PAGE_SIZE;
351 int rv;
352 int i;
353 u8 ack;
354 u64 rn;
355 struct w1_reg_num *reg_num;
356 int seq = 0;
357
Dan Carpenter0c6d5c82015-06-04 12:04:12 +0300358 mutex_lock(&sl->master->bus_mutex);
Matt Campbelld9411e52015-04-28 07:44:17 -0400359 /* Place all devices in CHAIN state */
360 if (w1_reset_bus(sl->master))
361 goto error;
362 w1_write_8(sl->master, W1_SKIP_ROM);
363 w1_write_8(sl->master, W1_42_CHAIN);
364 w1_write_8(sl->master, W1_42_CHAIN_ON);
365 w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
366 msleep(sl->master->pullup_duration);
367
368 /* check for acknowledgment */
369 ack = w1_read_8(sl->master);
370 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
371 goto error;
372
373 /* In case the bus fails to send 0xFF, limit*/
374 for (i = 0; i <= 64; i++) {
375 if (w1_reset_bus(sl->master))
376 goto error;
377
378 w1_write_8(sl->master, W1_42_COND_READ);
379 rv = w1_read_block(sl->master, (u8 *)&rn, 8);
380 reg_num = (struct w1_reg_num *) &rn;
Dan Carpentera14ef242015-06-01 12:55:37 +0300381 if (reg_num->family == W1_42_FINISHED_BYTE)
Matt Campbelld9411e52015-04-28 07:44:17 -0400382 break;
383 if (sl->reg_num.id == reg_num->id)
384 seq = i;
385
386 w1_write_8(sl->master, W1_42_CHAIN);
387 w1_write_8(sl->master, W1_42_CHAIN_DONE);
388 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
389 w1_read_block(sl->master, &ack, sizeof(ack));
390
391 /* check for acknowledgment */
392 ack = w1_read_8(sl->master);
393 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
394 goto error;
395
396 }
397
398 /* Exit from CHAIN state */
399 if (w1_reset_bus(sl->master))
400 goto error;
401 w1_write_8(sl->master, W1_SKIP_ROM);
402 w1_write_8(sl->master, W1_42_CHAIN);
403 w1_write_8(sl->master, W1_42_CHAIN_OFF);
404 w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
405
406 /* check for acknowledgment */
407 ack = w1_read_8(sl->master);
408 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
409 goto error;
Dan Carpenter0c6d5c82015-06-04 12:04:12 +0300410 mutex_unlock(&sl->master->bus_mutex);
Matt Campbelld9411e52015-04-28 07:44:17 -0400411
412 c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
413 return PAGE_SIZE - c;
414error:
415 mutex_unlock(&sl->master->bus_mutex);
416 return -EIO;
417}
418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419static int __init w1_therm_init(void)
420{
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400421 int err, i;
422
Ahmed S. Darwish9d0094d2007-02-12 00:52:05 -0800423 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400424 err = w1_register_family(w1_therm_families[i].f);
425 if (err)
426 w1_therm_families[i].broken = 1;
427 }
428
429 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430}
431
432static void __exit w1_therm_fini(void)
433{
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400434 int i;
435
Ahmed S. Darwish9d0094d2007-02-12 00:52:05 -0800436 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400437 if (!w1_therm_families[i].broken)
438 w1_unregister_family(w1_therm_families[i].f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439}
440
441module_init(w1_therm_init);
442module_exit(w1_therm_fini);