blob: 312cf3220f12dfa9f81f1515cb793efa3fa7db32 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Evgeniy Polyakov77859252005-05-20 22:33:25 +04002 * w1.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
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 terms 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 <linux/delay.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/moduleparam.h>
26#include <linux/list.h>
27#include <linux/interrupt.h>
28#include <linux/spinlock.h>
29#include <linux/timer.h>
30#include <linux/device.h>
31#include <linux/slab.h>
32#include <linux/sched.h>
33
34#include <asm/atomic.h>
35
36#include "w1.h"
37#include "w1_io.h"
38#include "w1_log.h"
39#include "w1_int.h"
40#include "w1_family.h"
41#include "w1_netlink.h"
42
43MODULE_LICENSE("GPL");
44MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
45MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");
46
47static int w1_timeout = 10;
48int w1_max_slave_count = 10;
49int w1_max_slave_ttl = 10;
50
51module_param_named(timeout, w1_timeout, int, 0);
52module_param_named(max_slave_count, w1_max_slave_count, int, 0);
53module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);
54
55DEFINE_SPINLOCK(w1_mlock);
56LIST_HEAD(w1_masters);
57
58static pid_t control_thread;
59static int control_needs_exit;
60static DECLARE_COMPLETION(w1_control_complete);
61
Evgeniy Polyakov99c5bfe2005-06-04 01:31:26 +040062/* stuff for the default family */
63static ssize_t w1_famdefault_read_name(struct device *dev, struct device_attribute *attr, char *buf)
64{
65 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
66 return(sprintf(buf, "%s\n", sl->name));
67}
68static struct w1_family_ops w1_default_fops = {
69 .rname = &w1_famdefault_read_name,
70};
71static struct w1_family w1_default_family = {
72 .fops = &w1_default_fops,
73};
74
Linus Torvalds1da177e2005-04-16 15:20:36 -070075static int w1_master_match(struct device *dev, struct device_driver *drv)
76{
77 return 1;
78}
79
80static int w1_master_probe(struct device *dev)
81{
82 return -ENODEV;
83}
84
85static int w1_master_remove(struct device *dev)
86{
87 return 0;
88}
89
90static void w1_master_release(struct device *dev)
91{
92 struct w1_master *md = container_of(dev, struct w1_master, dev);
93
94 complete(&md->dev_released);
95}
96
97static void w1_slave_release(struct device *dev)
98{
99 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
100
101 complete(&sl->dev_released);
102}
103
Yani Ioannou060b8842005-05-17 06:44:04 -0400104static ssize_t w1_default_read_name(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
106 return sprintf(buf, "No family registered.\n");
107}
108
109static ssize_t w1_default_read_bin(struct kobject *kobj, char *buf, loff_t off,
110 size_t count)
111{
112 return sprintf(buf, "No family registered.\n");
113}
114
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400115static struct device_attribute w1_slave_attribute =
116 __ATTR(name, S_IRUGO, w1_default_read_name, NULL);
117
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400118static struct bin_attribute w1_slave_bin_attribute = {
119 .attr = {
120 .name = "w1_slave",
121 .mode = S_IRUGO,
122 .owner = THIS_MODULE,
123 },
124 .size = W1_SLAVE_DATA_SIZE,
125 .read = &w1_default_read_bin,
126};
127
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129static struct bus_type w1_bus_type = {
130 .name = "w1",
131 .match = w1_master_match,
132};
133
134struct device_driver w1_driver = {
135 .name = "w1_driver",
136 .bus = &w1_bus_type,
137 .probe = w1_master_probe,
138 .remove = w1_master_remove,
139};
140
141struct device w1_device = {
142 .parent = NULL,
143 .bus = &w1_bus_type,
144 .bus_id = "w1 bus master",
145 .driver = &w1_driver,
146 .release = &w1_master_release
147};
148
Yani Ioannou060b8842005-05-17 06:44:04 -0400149static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400151 struct w1_master *md = container_of(dev, struct w1_master, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 ssize_t count;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 if (down_interruptible (&md->mutex))
155 return -EBUSY;
156
157 count = sprintf(buf, "%s\n", md->name);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 up(&md->mutex);
160
161 return count;
162}
163
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400164static ssize_t w1_master_attribute_store_search(struct device * dev,
165 struct device_attribute *attr,
166 const char * buf, size_t count)
167{
168 struct w1_master *md = container_of(dev, struct w1_master, dev);
169
170 if (down_interruptible (&md->mutex))
171 return -EBUSY;
172
173 md->search_count = simple_strtol(buf, NULL, 0);
174
175 up(&md->mutex);
176
177 return count;
178}
179
180static ssize_t w1_master_attribute_show_search(struct device *dev,
181 struct device_attribute *attr,
182 char *buf)
183{
184 struct w1_master *md = container_of(dev, struct w1_master, dev);
185 ssize_t count;
186
187 if (down_interruptible (&md->mutex))
188 return -EBUSY;
189
190 count = sprintf(buf, "%d\n", md->search_count);
191
192 up(&md->mutex);
193
194 return count;
195}
196
Yani Ioannou060b8842005-05-17 06:44:04 -0400197static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 struct w1_master *md = container_of(dev, struct w1_master, dev);
200 ssize_t count;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 if (down_interruptible(&md->mutex))
203 return -EBUSY;
204
205 count = sprintf(buf, "0x%p\n", md->bus_master);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 up(&md->mutex);
208 return count;
209}
210
Yani Ioannou060b8842005-05-17 06:44:04 -0400211static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
213 ssize_t count;
214 count = sprintf(buf, "%d\n", w1_timeout);
215 return count;
216}
217
Yani Ioannou060b8842005-05-17 06:44:04 -0400218static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
220 struct w1_master *md = container_of(dev, struct w1_master, dev);
221 ssize_t count;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (down_interruptible(&md->mutex))
224 return -EBUSY;
225
226 count = sprintf(buf, "%d\n", md->max_slave_count);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 up(&md->mutex);
229 return count;
230}
231
Yani Ioannou060b8842005-05-17 06:44:04 -0400232static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 struct w1_master *md = container_of(dev, struct w1_master, dev);
235 ssize_t count;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 if (down_interruptible(&md->mutex))
238 return -EBUSY;
239
240 count = sprintf(buf, "%lu\n", md->attempts);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 up(&md->mutex);
243 return count;
244}
245
Yani Ioannou060b8842005-05-17 06:44:04 -0400246static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 struct w1_master *md = container_of(dev, struct w1_master, dev);
249 ssize_t count;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (down_interruptible(&md->mutex))
252 return -EBUSY;
253
254 count = sprintf(buf, "%d\n", md->slave_count);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 up(&md->mutex);
257 return count;
258}
259
Yani Ioannou060b8842005-05-17 06:44:04 -0400260static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
262 struct w1_master *md = container_of(dev, struct w1_master, dev);
263 int c = PAGE_SIZE;
264
265 if (down_interruptible(&md->mutex))
266 return -EBUSY;
267
268 if (md->slave_count == 0)
269 c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n");
270 else {
271 struct list_head *ent, *n;
272 struct w1_slave *sl;
273
274 list_for_each_safe(ent, n, &md->slist) {
275 sl = list_entry(ent, struct w1_slave, w1_slave_entry);
276
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400277 c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
279 }
280
281 up(&md->mutex);
282
283 return PAGE_SIZE - c;
284}
285
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400286#define W1_MASTER_ATTR_RO(_name, _mode) \
287 struct device_attribute w1_master_attribute_##_name = \
288 __ATTR(w1_master_##_name, _mode, \
289 w1_master_attribute_show_##_name, NULL)
290
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400291#define W1_MASTER_ATTR_RW(_name, _mode) \
292 struct device_attribute w1_master_attribute_##_name = \
293 __ATTR(w1_master_##_name, _mode, \
294 w1_master_attribute_show_##_name, \
295 w1_master_attribute_store_##_name)
296
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400297static W1_MASTER_ATTR_RO(name, S_IRUGO);
298static W1_MASTER_ATTR_RO(slaves, S_IRUGO);
299static W1_MASTER_ATTR_RO(slave_count, S_IRUGO);
300static W1_MASTER_ATTR_RO(max_slave_count, S_IRUGO);
301static W1_MASTER_ATTR_RO(attempts, S_IRUGO);
302static W1_MASTER_ATTR_RO(timeout, S_IRUGO);
303static W1_MASTER_ATTR_RO(pointer, S_IRUGO);
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400304static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUGO);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400305
306static struct attribute *w1_master_default_attrs[] = {
307 &w1_master_attribute_name.attr,
308 &w1_master_attribute_slaves.attr,
309 &w1_master_attribute_slave_count.attr,
310 &w1_master_attribute_max_slave_count.attr,
311 &w1_master_attribute_attempts.attr,
312 &w1_master_attribute_timeout.attr,
313 &w1_master_attribute_pointer.attr,
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400314 &w1_master_attribute_search.attr,
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400315 NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316};
317
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400318static struct attribute_group w1_master_defattr_group = {
319 .attrs = w1_master_default_attrs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320};
321
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400322int w1_create_master_attributes(struct w1_master *master)
323{
324 return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
325}
326
327void w1_destroy_master_attributes(struct w1_master *master)
328{
329 sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
330}
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332static int __w1_attach_slave_device(struct w1_slave *sl)
333{
334 int err;
335
336 sl->dev.parent = &sl->master->dev;
337 sl->dev.driver = sl->master->driver;
338 sl->dev.bus = &w1_bus_type;
339 sl->dev.release = &w1_slave_release;
340
341 snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400342 "%02x-%012llx",
343 (unsigned int) sl->reg_num.family,
344 (unsigned long long) sl->reg_num.id);
345 snprintf(&sl->name[0], sizeof(sl->name),
346 "%02x-%012llx",
347 (unsigned int) sl->reg_num.family,
348 (unsigned long long) sl->reg_num.id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 dev_dbg(&sl->dev, "%s: registering %s.\n", __func__,
351 &sl->dev.bus_id[0]);
352
353 err = device_register(&sl->dev);
354 if (err < 0) {
355 dev_err(&sl->dev,
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400356 "Device registration [%s] failed. err=%d\n",
357 sl->dev.bus_id, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return err;
359 }
360
361 memcpy(&sl->attr_bin, &w1_slave_bin_attribute, sizeof(sl->attr_bin));
362 memcpy(&sl->attr_name, &w1_slave_attribute, sizeof(sl->attr_name));
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 sl->attr_bin.read = sl->family->fops->rbin;
365 sl->attr_name.show = sl->family->fops->rname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 err = device_create_file(&sl->dev, &sl->attr_name);
368 if (err < 0) {
369 dev_err(&sl->dev,
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400370 "sysfs file creation for [%s] failed. err=%d\n",
371 sl->dev.bus_id, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 device_unregister(&sl->dev);
373 return err;
374 }
375
Evgeniy Polyakov99c5bfe2005-06-04 01:31:26 +0400376 if ( sl->attr_bin.read ) {
377 err = sysfs_create_bin_file(&sl->dev.kobj, &sl->attr_bin);
378 if (err < 0) {
379 dev_err(&sl->dev,
380 "sysfs file creation for [%s] failed. err=%d\n",
381 sl->dev.bus_id, err);
382 device_remove_file(&sl->dev, &sl->attr_name);
383 device_unregister(&sl->dev);
384 return err;
385 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 }
387
388 list_add_tail(&sl->w1_slave_entry, &sl->master->slist);
389
390 return 0;
391}
392
393static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn)
394{
395 struct w1_slave *sl;
396 struct w1_family *f;
397 int err;
398 struct w1_netlink_msg msg;
399
400 sl = kmalloc(sizeof(struct w1_slave), GFP_KERNEL);
401 if (!sl) {
402 dev_err(&dev->dev,
403 "%s: failed to allocate new slave device.\n",
404 __func__);
405 return -ENOMEM;
406 }
407
408 memset(sl, 0, sizeof(*sl));
409
410 sl->owner = THIS_MODULE;
411 sl->master = dev;
412 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
413
414 memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
415 atomic_set(&sl->refcnt, 0);
416 init_completion(&sl->dev_released);
417
418 spin_lock(&w1_flock);
419 f = w1_family_registered(rn->family);
420 if (!f) {
Evgeniy Polyakov99c5bfe2005-06-04 01:31:26 +0400421 f= &w1_default_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 dev_info(&dev->dev, "Family %x for %02x.%012llx.%02x is not registered.\n",
423 rn->family, rn->family,
424 (unsigned long long)rn->id, rn->crc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426 __w1_family_get(f);
427 spin_unlock(&w1_flock);
428
429 sl->family = f;
430
431
432 err = __w1_attach_slave_device(sl);
433 if (err < 0) {
434 dev_err(&dev->dev, "%s: Attaching %s failed.\n", __func__,
435 sl->name);
436 w1_family_put(sl->family);
437 kfree(sl);
438 return err;
439 }
440
441 sl->ttl = dev->slave_ttl;
442 dev->slave_count++;
443
444 memcpy(&msg.id.id, rn, sizeof(msg.id.id));
445 msg.type = W1_SLAVE_ADD;
446 w1_netlink_send(dev, &msg);
447
448 return 0;
449}
450
451static void w1_slave_detach(struct w1_slave *sl)
452{
453 struct w1_netlink_msg msg;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 dev_info(&sl->dev, "%s: detaching %s.\n", __func__, sl->name);
456
457 while (atomic_read(&sl->refcnt)) {
458 printk(KERN_INFO "Waiting for %s to become free: refcnt=%d.\n",
459 sl->name, atomic_read(&sl->refcnt));
460
461 if (msleep_interruptible(1000))
462 flush_signals(current);
463 }
464
Evgeniy Polyakov99c5bfe2005-06-04 01:31:26 +0400465 if ( sl->attr_bin.read ) {
466 sysfs_remove_bin_file (&sl->dev.kobj, &sl->attr_bin);
467 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 device_remove_file(&sl->dev, &sl->attr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 device_unregister(&sl->dev);
470 w1_family_put(sl->family);
471
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400472 sl->master->slave_count--;
473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 memcpy(&msg.id.id, &sl->reg_num, sizeof(msg.id.id));
475 msg.type = W1_SLAVE_REMOVE;
476 w1_netlink_send(sl->master, &msg);
477}
478
479static struct w1_master *w1_search_master(unsigned long data)
480{
481 struct w1_master *dev;
482 int found = 0;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400483
484 spin_lock_bh(&w1_mlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 list_for_each_entry(dev, &w1_masters, w1_master_entry) {
486 if (dev->bus_master->data == data) {
487 found = 1;
488 atomic_inc(&dev->refcnt);
489 break;
490 }
491 }
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400492 spin_unlock_bh(&w1_mlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 return (found)?dev:NULL;
495}
496
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400497void w1_reconnect_slaves(struct w1_family *f)
498{
499 struct w1_master *dev;
500
501 spin_lock_bh(&w1_mlock);
502 list_for_each_entry(dev, &w1_masters, w1_master_entry) {
503 dev_info(&dev->dev, "Reconnecting slaves in %s into new family %02x.\n",
504 dev->name, f->fid);
505 set_bit(W1_MASTER_NEED_RECONNECT, &dev->flags);
506 }
507 spin_unlock_bh(&w1_mlock);
508}
509
510
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400511static void w1_slave_found(unsigned long data, u64 rn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 int slave_count;
514 struct w1_slave *sl;
515 struct list_head *ent;
516 struct w1_reg_num *tmp;
517 int family_found = 0;
518 struct w1_master *dev;
519
520 dev = w1_search_master(data);
521 if (!dev) {
522 printk(KERN_ERR "Failed to find w1 master device for data %08lx, it is impossible.\n",
523 data);
524 return;
525 }
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 tmp = (struct w1_reg_num *) &rn;
528
529 slave_count = 0;
530 list_for_each(ent, &dev->slist) {
531
532 sl = list_entry(ent, struct w1_slave, w1_slave_entry);
533
534 if (sl->reg_num.family == tmp->family &&
535 sl->reg_num.id == tmp->id &&
536 sl->reg_num.crc == tmp->crc) {
537 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
538 break;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400539 } else if (sl->reg_num.family == tmp->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 family_found = 1;
541 break;
542 }
543
544 slave_count++;
545 }
546
johnpol@2ka.mipt.ru8523ff42005-04-18 21:16:57 -0700547 rn = cpu_to_le64(rn);
548
549 if (slave_count == dev->slave_count &&
550 rn && ((le64_to_cpu(rn) >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn, 7)) {
551 w1_attach_slave_device(dev, tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 }
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 atomic_dec(&dev->refcnt);
555}
556
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400557/**
558 * Performs a ROM Search & registers any devices found.
559 * The 1-wire search is a simple binary tree search.
560 * For each bit of the address, we read two bits and write one bit.
561 * The bit written will put to sleep all devies that don't match that bit.
562 * When the two reads differ, the direction choice is obvious.
563 * When both bits are 0, we must choose a path to take.
564 * When we can scan all 64 bits without having to choose a path, we are done.
565 *
566 * See "Application note 187 1-wire search algorithm" at www.maxim-ic.com
567 *
568 * @dev The master device to search
569 * @cb Function to call when a device is found
570 */
571void w1_search(struct w1_master *dev, w1_slave_found_callback cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400573 u64 last_rn, rn, tmp64;
574 int i, slave_count = 0;
575 int last_zero, last_device;
576 int search_bit, desc_bit;
577 u8 triplet_ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400579 search_bit = 0;
580 rn = last_rn = 0;
581 last_device = 0;
582 last_zero = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 desc_bit = 64;
585
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400586 while ( !last_device && (slave_count++ < dev->max_slave_count) ) {
587 last_rn = rn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 rn = 0;
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 /*
591 * Reset bus and all 1-wire device state machines
592 * so they can respond to our requests.
593 *
594 * Return 0 - device(s) present, 1 - no devices present.
595 */
596 if (w1_reset_bus(dev)) {
597 dev_info(&dev->dev, "No devices present on the wire.\n");
598 break;
599 }
600
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400601 /* Start the search */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 w1_write_8(dev, W1_SEARCH);
603 for (i = 0; i < 64; ++i) {
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400604 /* Determine the direction/search bit */
605 if (i == desc_bit)
606 search_bit = 1; /* took the 0 path last time, so take the 1 path */
607 else if (i > desc_bit)
608 search_bit = 0; /* take the 0 path on the next branch */
609 else
610 search_bit = ((last_rn >> i) & 0x1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400612 /** Read two bits and write one bit */
613 triplet_ret = w1_triplet(dev, search_bit);
614
615 /* quit if no device responded */
616 if ( (triplet_ret & 0x03) == 0x03 )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 break;
618
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400619 /* If both directions were valid, and we took the 0 path... */
620 if (triplet_ret == 0)
621 last_zero = i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400623 /* extract the direction taken & update the device number */
624 tmp64 = (triplet_ret >> 2);
625 rn |= (tmp64 << i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Evgeniy Polyakov6b729862005-06-04 01:30:43 +0400628 if ( (triplet_ret & 0x03) != 0x03 ) {
629 if ( (desc_bit == last_zero) || (last_zero < 0))
630 last_device = 1;
631 desc_bit = last_zero;
632 cb(dev->bus_master->data, rn);
633 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
635}
636
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400637static int w1_control(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400639 struct w1_slave *sl, *sln;
640 struct w1_master *dev, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 int err, have_to_wait = 0;
642
643 daemonize("w1_control");
644 allow_signal(SIGTERM);
645
646 while (!control_needs_exit || have_to_wait) {
647 have_to_wait = 0;
648
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700649 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 msleep_interruptible(w1_timeout * 1000);
651
652 if (signal_pending(current))
653 flush_signals(current);
654
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400655 list_for_each_entry_safe(dev, n, &w1_masters, w1_master_entry) {
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400656 if (!control_needs_exit && !dev->flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 continue;
658 /*
659 * Little race: we can create thread but not set the flag.
660 * Get a chance for external process to set flag up.
661 */
662 if (!dev->initialized) {
663 have_to_wait = 1;
664 continue;
665 }
666
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 if (control_needs_exit) {
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400668 set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
670 err = kill_proc(dev->kpid, SIGTERM, 1);
671 if (err)
672 dev_err(&dev->dev,
673 "Failed to send signal to w1 kernel thread %d.\n",
674 dev->kpid);
675 }
676
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400677 if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
678 wait_for_completion(&dev->dev_exited);
679 spin_lock_bh(&w1_mlock);
680 list_del(&dev->w1_master_entry);
681 spin_unlock_bh(&w1_mlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400683 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
684 list_del(&sl->w1_slave_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400686 w1_slave_detach(sl);
687 kfree(sl);
688 }
689 w1_destroy_master_attributes(dev);
690 atomic_dec(&dev->refcnt);
691 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 }
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400693
694 if (test_bit(W1_MASTER_NEED_RECONNECT, &dev->flags)) {
695 dev_info(&dev->dev, "Reconnecting slaves in device %s.\n", dev->name);
696 down(&dev->mutex);
697 list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
698 if (sl->family->fid == W1_FAMILY_DEFAULT) {
699 struct w1_reg_num rn;
700 list_del(&sl->w1_slave_entry);
701 w1_slave_detach(sl);
702
703 memcpy(&rn, &sl->reg_num, sizeof(rn));
704
705 kfree(sl);
706
707 w1_attach_slave_device(dev, &rn);
708 }
709 }
710 clear_bit(W1_MASTER_NEED_RECONNECT, &dev->flags);
711 up(&dev->mutex);
712 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
714 }
715
716 complete_and_exit(&w1_control_complete, 0);
717}
718
719int w1_process(void *data)
720{
721 struct w1_master *dev = (struct w1_master *) data;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400722 struct w1_slave *sl, *sln;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 daemonize("%s", dev->name);
725 allow_signal(SIGTERM);
726
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400727 while (!test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700728 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 msleep_interruptible(w1_timeout * 1000);
730
731 if (signal_pending(current))
732 flush_signals(current);
733
Evgeniy Polyakov6adf87b2005-06-04 01:29:25 +0400734 if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 break;
736
737 if (!dev->initialized)
738 continue;
739
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400740 if (dev->search_count == 0)
741 continue;
742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 if (down_interruptible(&dev->mutex))
744 continue;
745
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400746 list_for_each_entry(sl, &dev->slist, w1_slave_entry)
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400747 clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 w1_search_devices(dev, w1_slave_found);
750
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400751 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
752 if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 list_del (&sl->w1_slave_entry);
754
755 w1_slave_detach (sl);
756 kfree (sl);
757
758 dev->slave_count--;
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400759 } else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 sl->ttl = dev->slave_ttl;
761 }
Evgeniy Polyakov2a9d0c12005-06-04 01:31:02 +0400762
763 if (dev->search_count > 0)
764 dev->search_count--;
765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 up(&dev->mutex);
767 }
768
769 atomic_dec(&dev->refcnt);
770 complete_and_exit(&dev->dev_exited, 0);
771
772 return 0;
773}
774
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400775static int w1_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776{
777 int retval;
778
779 printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n");
780
781 retval = bus_register(&w1_bus_type);
782 if (retval) {
783 printk(KERN_ERR "Failed to register bus. err=%d.\n", retval);
784 goto err_out_exit_init;
785 }
786
787 retval = driver_register(&w1_driver);
788 if (retval) {
789 printk(KERN_ERR
790 "Failed to register master driver. err=%d.\n",
791 retval);
792 goto err_out_bus_unregister;
793 }
794
795 control_thread = kernel_thread(&w1_control, NULL, 0);
796 if (control_thread < 0) {
797 printk(KERN_ERR "Failed to create control thread. err=%d\n",
798 control_thread);
799 retval = control_thread;
800 goto err_out_driver_unregister;
801 }
802
803 return 0;
804
805err_out_driver_unregister:
806 driver_unregister(&w1_driver);
807
808err_out_bus_unregister:
809 bus_unregister(&w1_bus_type);
810
811err_out_exit_init:
812 return retval;
813}
814
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400815static void w1_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816{
817 struct w1_master *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400819 list_for_each_entry(dev, &w1_masters, w1_master_entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 __w1_remove_master_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
822 control_needs_exit = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 wait_for_completion(&w1_control_complete);
824
825 driver_unregister(&w1_driver);
826 bus_unregister(&w1_bus_type);
827}
828
829module_init(w1_init);
830module_exit(w1_fini);