4 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
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.
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.
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
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 #include <linux/kthread.h>
34 #include <linux/freezer.h>
36 #include <linux/atomic.h>
41 #include "w1_family.h"
42 #include "w1_netlink.h"
44 MODULE_LICENSE("GPL");
45 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
46 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");
48 static int w1_timeout
= 10;
49 static int w1_timeout_us
= 0;
50 int w1_max_slave_count
= 64;
51 int w1_max_slave_ttl
= 10;
53 module_param_named(timeout
, w1_timeout
, int, 0);
54 MODULE_PARM_DESC(timeout
, "time in seconds between automatic slave searches");
55 module_param_named(timeout_us
, w1_timeout_us
, int, 0);
56 MODULE_PARM_DESC(timeout
, "time in microseconds between automatic slave"
58 /* A search stops when w1_max_slave_count devices have been found in that
59 * search. The next search will start over and detect the same set of devices
60 * on a static 1-wire bus. Memory is not allocated based on this number, just
61 * on the number of devices known to the kernel. Having a high number does not
62 * consume additional resources. As a special case, if there is only one
63 * device on the network and w1_max_slave_count is set to 1, the device id can
64 * be read directly skipping the normal slower search process.
66 module_param_named(max_slave_count
, w1_max_slave_count
, int, 0);
67 MODULE_PARM_DESC(max_slave_count
,
68 "maximum number of slaves detected in a search");
69 module_param_named(slave_ttl
, w1_max_slave_ttl
, int, 0);
70 MODULE_PARM_DESC(slave_ttl
,
71 "Number of searches not seeing a slave before it will be removed");
73 DEFINE_MUTEX(w1_mlock
);
74 LIST_HEAD(w1_masters
);
76 static int w1_master_match(struct device
*dev
, struct device_driver
*drv
)
81 static int w1_master_probe(struct device
*dev
)
86 static void w1_master_release(struct device
*dev
)
88 struct w1_master
*md
= dev_to_w1_master(dev
);
90 dev_dbg(dev
, "%s: Releasing %s.\n", __func__
, md
->name
);
91 memset(md
, 0, sizeof(struct w1_master
) + sizeof(struct w1_bus_master
));
95 static void w1_slave_release(struct device
*dev
)
97 struct w1_slave
*sl
= dev_to_w1_slave(dev
);
99 dev_dbg(dev
, "%s: Releasing %s [%p]\n", __func__
, sl
->name
, sl
);
101 w1_family_put(sl
->family
);
102 sl
->master
->slave_count
--;
105 static ssize_t
name_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
107 struct w1_slave
*sl
= dev_to_w1_slave(dev
);
109 return sprintf(buf
, "%s\n", sl
->name
);
111 static DEVICE_ATTR_RO(name
);
113 static ssize_t
id_show(struct device
*dev
,
114 struct device_attribute
*attr
, char *buf
)
116 struct w1_slave
*sl
= dev_to_w1_slave(dev
);
117 ssize_t count
= sizeof(sl
->reg_num
);
119 memcpy(buf
, (u8
*)&sl
->reg_num
, count
);
122 static DEVICE_ATTR_RO(id
);
124 static struct attribute
*w1_slave_attrs
[] = {
129 ATTRIBUTE_GROUPS(w1_slave
);
133 static ssize_t
rw_write(struct file
*filp
, struct kobject
*kobj
,
134 struct bin_attribute
*bin_attr
, char *buf
, loff_t off
,
137 struct w1_slave
*sl
= kobj_to_w1_slave(kobj
);
139 mutex_lock(&sl
->master
->mutex
);
140 if (w1_reset_select_slave(sl
)) {
145 w1_write_block(sl
->master
, buf
, count
);
148 mutex_unlock(&sl
->master
->mutex
);
152 static ssize_t
rw_read(struct file
*filp
, struct kobject
*kobj
,
153 struct bin_attribute
*bin_attr
, char *buf
, loff_t off
,
156 struct w1_slave
*sl
= kobj_to_w1_slave(kobj
);
158 mutex_lock(&sl
->master
->mutex
);
159 w1_read_block(sl
->master
, buf
, count
);
160 mutex_unlock(&sl
->master
->mutex
);
164 static BIN_ATTR_RW(rw
, PAGE_SIZE
);
166 static struct bin_attribute
*w1_slave_bin_attrs
[] = {
171 static const struct attribute_group w1_slave_default_group
= {
172 .bin_attrs
= w1_slave_bin_attrs
,
175 static const struct attribute_group
*w1_slave_default_groups
[] = {
176 &w1_slave_default_group
,
180 static struct w1_family_ops w1_default_fops
= {
181 .groups
= w1_slave_default_groups
,
184 static struct w1_family w1_default_family
= {
185 .fops
= &w1_default_fops
,
188 static int w1_uevent(struct device
*dev
, struct kobj_uevent_env
*env
);
190 static struct bus_type w1_bus_type
= {
192 .match
= w1_master_match
,
196 struct device_driver w1_master_driver
= {
197 .name
= "w1_master_driver",
199 .probe
= w1_master_probe
,
202 struct device w1_master_device
= {
205 .init_name
= "w1 bus master",
206 .driver
= &w1_master_driver
,
207 .release
= &w1_master_release
210 static struct device_driver w1_slave_driver
= {
211 .name
= "w1_slave_driver",
216 struct device w1_slave_device
= {
219 .init_name
= "w1 bus slave",
220 .driver
= &w1_slave_driver
,
221 .release
= &w1_slave_release
225 static ssize_t
w1_master_attribute_show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
227 struct w1_master
*md
= dev_to_w1_master(dev
);
230 mutex_lock(&md
->mutex
);
231 count
= sprintf(buf
, "%s\n", md
->name
);
232 mutex_unlock(&md
->mutex
);
237 static ssize_t
w1_master_attribute_store_search(struct device
* dev
,
238 struct device_attribute
*attr
,
239 const char * buf
, size_t count
)
242 struct w1_master
*md
= dev_to_w1_master(dev
);
245 ret
= kstrtol(buf
, 0, &tmp
);
249 mutex_lock(&md
->mutex
);
250 md
->search_count
= tmp
;
251 mutex_unlock(&md
->mutex
);
252 /* Only wake if it is going to be searching. */
254 wake_up_process(md
->thread
);
259 static ssize_t
w1_master_attribute_show_search(struct device
*dev
,
260 struct device_attribute
*attr
,
263 struct w1_master
*md
= dev_to_w1_master(dev
);
266 mutex_lock(&md
->mutex
);
267 count
= sprintf(buf
, "%d\n", md
->search_count
);
268 mutex_unlock(&md
->mutex
);
273 static ssize_t
w1_master_attribute_store_pullup(struct device
*dev
,
274 struct device_attribute
*attr
,
275 const char *buf
, size_t count
)
278 struct w1_master
*md
= dev_to_w1_master(dev
);
281 ret
= kstrtol(buf
, 0, &tmp
);
285 mutex_lock(&md
->mutex
);
286 md
->enable_pullup
= tmp
;
287 mutex_unlock(&md
->mutex
);
292 static ssize_t
w1_master_attribute_show_pullup(struct device
*dev
,
293 struct device_attribute
*attr
,
296 struct w1_master
*md
= dev_to_w1_master(dev
);
299 mutex_lock(&md
->mutex
);
300 count
= sprintf(buf
, "%d\n", md
->enable_pullup
);
301 mutex_unlock(&md
->mutex
);
306 static ssize_t
w1_master_attribute_show_pointer(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
308 struct w1_master
*md
= dev_to_w1_master(dev
);
311 mutex_lock(&md
->mutex
);
312 count
= sprintf(buf
, "0x%p\n", md
->bus_master
);
313 mutex_unlock(&md
->mutex
);
317 static ssize_t
w1_master_attribute_show_timeout(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
320 count
= sprintf(buf
, "%d\n", w1_timeout
);
324 static ssize_t
w1_master_attribute_show_timeout_us(struct device
*dev
,
325 struct device_attribute
*attr
, char *buf
)
328 count
= sprintf(buf
, "%d\n", w1_timeout_us
);
332 static ssize_t
w1_master_attribute_store_max_slave_count(struct device
*dev
,
333 struct device_attribute
*attr
, const char *buf
, size_t count
)
336 struct w1_master
*md
= dev_to_w1_master(dev
);
338 if (kstrtoint(buf
, 0, &tmp
) == -EINVAL
|| tmp
< 1)
341 mutex_lock(&md
->mutex
);
342 md
->max_slave_count
= tmp
;
343 /* allow each time the max_slave_count is updated */
344 clear_bit(W1_WARN_MAX_COUNT
, &md
->flags
);
345 mutex_unlock(&md
->mutex
);
350 static ssize_t
w1_master_attribute_show_max_slave_count(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
352 struct w1_master
*md
= dev_to_w1_master(dev
);
355 mutex_lock(&md
->mutex
);
356 count
= sprintf(buf
, "%d\n", md
->max_slave_count
);
357 mutex_unlock(&md
->mutex
);
361 static ssize_t
w1_master_attribute_show_attempts(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
363 struct w1_master
*md
= dev_to_w1_master(dev
);
366 mutex_lock(&md
->mutex
);
367 count
= sprintf(buf
, "%lu\n", md
->attempts
);
368 mutex_unlock(&md
->mutex
);
372 static ssize_t
w1_master_attribute_show_slave_count(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
374 struct w1_master
*md
= dev_to_w1_master(dev
);
377 mutex_lock(&md
->mutex
);
378 count
= sprintf(buf
, "%d\n", md
->slave_count
);
379 mutex_unlock(&md
->mutex
);
383 static ssize_t
w1_master_attribute_show_slaves(struct device
*dev
,
384 struct device_attribute
*attr
, char *buf
)
386 struct w1_master
*md
= dev_to_w1_master(dev
);
388 struct list_head
*ent
, *n
;
389 struct w1_slave
*sl
= NULL
;
391 mutex_lock(&md
->list_mutex
);
393 list_for_each_safe(ent
, n
, &md
->slist
) {
394 sl
= list_entry(ent
, struct w1_slave
, w1_slave_entry
);
396 c
-= snprintf(buf
+ PAGE_SIZE
- c
, c
, "%s\n", sl
->name
);
399 c
-= snprintf(buf
+ PAGE_SIZE
- c
, c
, "not found.\n");
401 mutex_unlock(&md
->list_mutex
);
403 return PAGE_SIZE
- c
;
406 static ssize_t
w1_master_attribute_show_add(struct device
*dev
,
407 struct device_attribute
*attr
, char *buf
)
410 c
-= snprintf(buf
+PAGE_SIZE
- c
, c
,
411 "write device id xx-xxxxxxxxxxxx to add slave\n");
412 return PAGE_SIZE
- c
;
415 static int w1_atoreg_num(struct device
*dev
, const char *buf
, size_t count
,
416 struct w1_reg_num
*rn
)
419 unsigned long long id
;
423 /* The CRC value isn't read from the user because the sysfs directory
424 * doesn't include it and most messages from the bus search don't
425 * print it either. It would be unreasonable for the user to then
428 const char *error_msg
= "bad slave string format, expecting "
432 dev_err(dev
, "%s", error_msg
);
435 i
= sscanf(buf
, "%02x-%012llx", &family
, &id
);
437 dev_err(dev
, "%s", error_msg
);
443 rn64_le
= cpu_to_le64(*(u64
*)rn
);
444 rn
->crc
= w1_calc_crc8((u8
*)&rn64_le
, 7);
447 dev_info(dev
, "With CRC device is %02x.%012llx.%02x.\n",
448 rn
->family
, (unsigned long long)rn
->id
, rn
->crc
);
454 /* Searches the slaves in the w1_master and returns a pointer or NULL.
455 * Note: must not hold list_mutex
457 struct w1_slave
*w1_slave_search_device(struct w1_master
*dev
,
458 struct w1_reg_num
*rn
)
461 mutex_lock(&dev
->list_mutex
);
462 list_for_each_entry(sl
, &dev
->slist
, w1_slave_entry
) {
463 if (sl
->reg_num
.family
== rn
->family
&&
464 sl
->reg_num
.id
== rn
->id
&&
465 sl
->reg_num
.crc
== rn
->crc
) {
466 mutex_unlock(&dev
->list_mutex
);
470 mutex_unlock(&dev
->list_mutex
);
474 static ssize_t
w1_master_attribute_store_add(struct device
*dev
,
475 struct device_attribute
*attr
,
476 const char *buf
, size_t count
)
478 struct w1_master
*md
= dev_to_w1_master(dev
);
479 struct w1_reg_num rn
;
481 ssize_t result
= count
;
483 if (w1_atoreg_num(dev
, buf
, count
, &rn
))
486 mutex_lock(&md
->mutex
);
487 sl
= w1_slave_search_device(md
, &rn
);
488 /* It would be nice to do a targeted search one the one-wire bus
489 * for the new device to see if it is out there or not. But the
490 * current search doesn't support that.
493 dev_info(dev
, "Device %s already exists\n", sl
->name
);
496 w1_attach_slave_device(md
, &rn
);
498 mutex_unlock(&md
->mutex
);
503 static ssize_t
w1_master_attribute_show_remove(struct device
*dev
,
504 struct device_attribute
*attr
, char *buf
)
507 c
-= snprintf(buf
+PAGE_SIZE
- c
, c
,
508 "write device id xx-xxxxxxxxxxxx to remove slave\n");
509 return PAGE_SIZE
- c
;
512 static ssize_t
w1_master_attribute_store_remove(struct device
*dev
,
513 struct device_attribute
*attr
,
514 const char *buf
, size_t count
)
516 struct w1_master
*md
= dev_to_w1_master(dev
);
517 struct w1_reg_num rn
;
519 ssize_t result
= count
;
521 if (w1_atoreg_num(dev
, buf
, count
, &rn
))
524 mutex_lock(&md
->mutex
);
525 sl
= w1_slave_search_device(md
, &rn
);
527 result
= w1_slave_detach(sl
);
528 /* refcnt 0 means it was detached in the call */
532 dev_info(dev
, "Device %02x-%012llx doesn't exists\n", rn
.family
,
533 (unsigned long long)rn
.id
);
536 mutex_unlock(&md
->mutex
);
541 #define W1_MASTER_ATTR_RO(_name, _mode) \
542 struct device_attribute w1_master_attribute_##_name = \
543 __ATTR(w1_master_##_name, _mode, \
544 w1_master_attribute_show_##_name, NULL)
546 #define W1_MASTER_ATTR_RW(_name, _mode) \
547 struct device_attribute w1_master_attribute_##_name = \
548 __ATTR(w1_master_##_name, _mode, \
549 w1_master_attribute_show_##_name, \
550 w1_master_attribute_store_##_name)
552 static W1_MASTER_ATTR_RO(name
, S_IRUGO
);
553 static W1_MASTER_ATTR_RO(slaves
, S_IRUGO
);
554 static W1_MASTER_ATTR_RO(slave_count
, S_IRUGO
);
555 static W1_MASTER_ATTR_RW(max_slave_count
, S_IRUGO
| S_IWUSR
| S_IWGRP
);
556 static W1_MASTER_ATTR_RO(attempts
, S_IRUGO
);
557 static W1_MASTER_ATTR_RO(timeout
, S_IRUGO
);
558 static W1_MASTER_ATTR_RO(timeout_us
, S_IRUGO
);
559 static W1_MASTER_ATTR_RO(pointer
, S_IRUGO
);
560 static W1_MASTER_ATTR_RW(search
, S_IRUGO
| S_IWUSR
| S_IWGRP
);
561 static W1_MASTER_ATTR_RW(pullup
, S_IRUGO
| S_IWUSR
| S_IWGRP
);
562 static W1_MASTER_ATTR_RW(add
, S_IRUGO
| S_IWUSR
| S_IWGRP
);
563 static W1_MASTER_ATTR_RW(remove
, S_IRUGO
| S_IWUSR
| S_IWGRP
);
565 static struct attribute
*w1_master_default_attrs
[] = {
566 &w1_master_attribute_name
.attr
,
567 &w1_master_attribute_slaves
.attr
,
568 &w1_master_attribute_slave_count
.attr
,
569 &w1_master_attribute_max_slave_count
.attr
,
570 &w1_master_attribute_attempts
.attr
,
571 &w1_master_attribute_timeout
.attr
,
572 &w1_master_attribute_timeout_us
.attr
,
573 &w1_master_attribute_pointer
.attr
,
574 &w1_master_attribute_search
.attr
,
575 &w1_master_attribute_pullup
.attr
,
576 &w1_master_attribute_add
.attr
,
577 &w1_master_attribute_remove
.attr
,
581 static struct attribute_group w1_master_defattr_group
= {
582 .attrs
= w1_master_default_attrs
,
585 int w1_create_master_attributes(struct w1_master
*master
)
587 return sysfs_create_group(&master
->dev
.kobj
, &w1_master_defattr_group
);
590 void w1_destroy_master_attributes(struct w1_master
*master
)
592 sysfs_remove_group(&master
->dev
.kobj
, &w1_master_defattr_group
);
595 static int w1_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
597 struct w1_master
*md
= NULL
;
598 struct w1_slave
*sl
= NULL
;
599 char *event_owner
, *name
;
602 if (dev
->driver
== &w1_master_driver
) {
603 md
= container_of(dev
, struct w1_master
, dev
);
604 event_owner
= "master";
606 } else if (dev
->driver
== &w1_slave_driver
) {
607 sl
= container_of(dev
, struct w1_slave
, dev
);
608 event_owner
= "slave";
611 dev_dbg(dev
, "Unknown event.\n");
615 dev_dbg(dev
, "Hotplug event for %s %s, bus_id=%s.\n",
616 event_owner
, name
, dev_name(dev
));
618 if (dev
->driver
!= &w1_slave_driver
|| !sl
)
621 err
= add_uevent_var(env
, "W1_FID=%02X", sl
->reg_num
.family
);
625 err
= add_uevent_var(env
, "W1_SLAVE_ID=%024LX",
626 (unsigned long long)sl
->reg_num
.id
);
631 static int w1_family_notify(unsigned long action
, struct w1_slave
*sl
)
633 struct w1_family_ops
*fops
;
636 fops
= sl
->family
->fops
;
642 case BUS_NOTIFY_ADD_DEVICE
:
643 /* if the family driver needs to initialize something... */
644 if (fops
->add_slave
) {
645 err
= fops
->add_slave(sl
);
648 "add_slave() call failed. err=%d\n",
654 err
= sysfs_create_groups(&sl
->dev
.kobj
, fops
->groups
);
657 "sysfs group creation failed. err=%d\n",
664 case BUS_NOTIFY_DEL_DEVICE
:
665 if (fops
->remove_slave
)
666 sl
->family
->fops
->remove_slave(sl
);
668 sysfs_remove_groups(&sl
->dev
.kobj
, fops
->groups
);
674 static int __w1_attach_slave_device(struct w1_slave
*sl
)
678 sl
->dev
.parent
= &sl
->master
->dev
;
679 sl
->dev
.driver
= &w1_slave_driver
;
680 sl
->dev
.bus
= &w1_bus_type
;
681 sl
->dev
.release
= &w1_slave_release
;
682 sl
->dev
.groups
= w1_slave_groups
;
684 dev_set_name(&sl
->dev
, "%02x-%012llx",
685 (unsigned int) sl
->reg_num
.family
,
686 (unsigned long long) sl
->reg_num
.id
);
687 snprintf(&sl
->name
[0], sizeof(sl
->name
),
689 (unsigned int) sl
->reg_num
.family
,
690 (unsigned long long) sl
->reg_num
.id
);
692 dev_dbg(&sl
->dev
, "%s: registering %s as %p.\n", __func__
,
693 dev_name(&sl
->dev
), sl
);
695 /* suppress for w1_family_notify before sending KOBJ_ADD */
696 dev_set_uevent_suppress(&sl
->dev
, true);
698 err
= device_register(&sl
->dev
);
701 "Device registration [%s] failed. err=%d\n",
702 dev_name(&sl
->dev
), err
);
705 w1_family_notify(BUS_NOTIFY_ADD_DEVICE
, sl
);
707 dev_set_uevent_suppress(&sl
->dev
, false);
708 kobject_uevent(&sl
->dev
.kobj
, KOBJ_ADD
);
710 mutex_lock(&sl
->master
->list_mutex
);
711 list_add_tail(&sl
->w1_slave_entry
, &sl
->master
->slist
);
712 mutex_unlock(&sl
->master
->list_mutex
);
717 int w1_attach_slave_device(struct w1_master
*dev
, struct w1_reg_num
*rn
)
722 struct w1_netlink_msg msg
;
724 sl
= kzalloc(sizeof(struct w1_slave
), GFP_KERNEL
);
727 "%s: failed to allocate new slave device.\n",
733 sl
->owner
= THIS_MODULE
;
735 set_bit(W1_SLAVE_ACTIVE
, &sl
->flags
);
737 memset(&msg
, 0, sizeof(msg
));
738 memcpy(&sl
->reg_num
, rn
, sizeof(sl
->reg_num
));
739 atomic_set(&sl
->refcnt
, 1);
740 atomic_inc(&sl
->master
->refcnt
);
742 /* slave modules need to be loaded in a context with unlocked mutex */
743 mutex_unlock(&dev
->mutex
);
744 request_module("w1-family-0x%02x", rn
->family
);
745 mutex_lock(&dev
->mutex
);
747 spin_lock(&w1_flock
);
748 f
= w1_family_registered(rn
->family
);
750 f
= &w1_default_family
;
751 dev_info(&dev
->dev
, "Family %x for %02x.%012llx.%02x is not registered.\n",
752 rn
->family
, rn
->family
,
753 (unsigned long long)rn
->id
, rn
->crc
);
756 spin_unlock(&w1_flock
);
761 err
= __w1_attach_slave_device(sl
);
763 dev_err(&dev
->dev
, "%s: Attaching %s failed.\n", __func__
,
765 w1_family_put(sl
->family
);
770 sl
->ttl
= dev
->slave_ttl
;
773 memcpy(msg
.id
.id
, rn
, sizeof(msg
.id
));
774 msg
.type
= W1_SLAVE_ADD
;
775 w1_netlink_send(dev
, &msg
);
780 int w1_unref_slave(struct w1_slave
*sl
)
782 struct w1_master
*dev
= sl
->master
;
784 mutex_lock(&dev
->list_mutex
);
785 refcnt
= atomic_sub_return(1, &sl
->refcnt
);
787 struct w1_netlink_msg msg
;
789 dev_dbg(&sl
->dev
, "%s: detaching %s [%p].\n", __func__
,
792 list_del(&sl
->w1_slave_entry
);
794 memset(&msg
, 0, sizeof(msg
));
795 memcpy(msg
.id
.id
, &sl
->reg_num
, sizeof(msg
.id
));
796 msg
.type
= W1_SLAVE_REMOVE
;
797 w1_netlink_send(sl
->master
, &msg
);
799 w1_family_notify(BUS_NOTIFY_DEL_DEVICE
, sl
);
800 device_unregister(&sl
->dev
);
802 memset(sl
, 0, sizeof(*sl
));
806 atomic_dec(&dev
->refcnt
);
807 mutex_unlock(&dev
->list_mutex
);
811 int w1_slave_detach(struct w1_slave
*sl
)
813 /* Only detach a slave once as it decreases the refcnt each time. */
815 mutex_lock(&sl
->master
->list_mutex
);
816 destroy_now
= !test_bit(W1_SLAVE_DETACH
, &sl
->flags
);
817 set_bit(W1_SLAVE_DETACH
, &sl
->flags
);
818 mutex_unlock(&sl
->master
->list_mutex
);
821 destroy_now
= !w1_unref_slave(sl
);
822 return destroy_now
? 0 : -EBUSY
;
825 struct w1_master
*w1_search_master_id(u32 id
)
827 struct w1_master
*dev
;
830 mutex_lock(&w1_mlock
);
831 list_for_each_entry(dev
, &w1_masters
, w1_master_entry
) {
834 atomic_inc(&dev
->refcnt
);
838 mutex_unlock(&w1_mlock
);
840 return (found
)?dev
:NULL
;
843 struct w1_slave
*w1_search_slave(struct w1_reg_num
*id
)
845 struct w1_master
*dev
;
846 struct w1_slave
*sl
= NULL
;
849 mutex_lock(&w1_mlock
);
850 list_for_each_entry(dev
, &w1_masters
, w1_master_entry
) {
851 mutex_lock(&dev
->list_mutex
);
852 list_for_each_entry(sl
, &dev
->slist
, w1_slave_entry
) {
853 if (sl
->reg_num
.family
== id
->family
&&
854 sl
->reg_num
.id
== id
->id
&&
855 sl
->reg_num
.crc
== id
->crc
) {
857 atomic_inc(&dev
->refcnt
);
858 atomic_inc(&sl
->refcnt
);
862 mutex_unlock(&dev
->list_mutex
);
867 mutex_unlock(&w1_mlock
);
869 return (found
)?sl
:NULL
;
872 void w1_reconnect_slaves(struct w1_family
*f
, int attach
)
874 struct w1_slave
*sl
, *sln
;
875 struct w1_master
*dev
;
877 mutex_lock(&w1_mlock
);
878 list_for_each_entry(dev
, &w1_masters
, w1_master_entry
) {
879 dev_dbg(&dev
->dev
, "Reconnecting slaves in device %s "
880 "for family %02x.\n", dev
->name
, f
->fid
);
881 mutex_lock(&dev
->mutex
);
882 mutex_lock(&dev
->list_mutex
);
883 list_for_each_entry_safe(sl
, sln
, &dev
->slist
, w1_slave_entry
) {
884 /* If it is a new family, slaves with the default
885 * family driver and are that family will be
886 * connected. If the family is going away, devices
887 * matching that family are reconneced.
889 if ((attach
&& sl
->family
->fid
== W1_FAMILY_DEFAULT
890 && sl
->reg_num
.family
== f
->fid
) ||
891 (!attach
&& sl
->family
->fid
== f
->fid
)) {
892 struct w1_reg_num rn
;
894 mutex_unlock(&dev
->list_mutex
);
895 memcpy(&rn
, &sl
->reg_num
, sizeof(rn
));
896 /* If it was already in use let the automatic
897 * scan pick it up again later.
899 if (!w1_slave_detach(sl
))
900 w1_attach_slave_device(dev
, &rn
);
901 mutex_lock(&dev
->list_mutex
);
904 dev_dbg(&dev
->dev
, "Reconnecting slaves in device %s "
905 "has been finished.\n", dev
->name
);
906 mutex_unlock(&dev
->list_mutex
);
907 mutex_unlock(&dev
->mutex
);
909 mutex_unlock(&w1_mlock
);
912 void w1_slave_found(struct w1_master
*dev
, u64 rn
)
915 struct w1_reg_num
*tmp
;
916 u64 rn_le
= cpu_to_le64(rn
);
918 atomic_inc(&dev
->refcnt
);
920 tmp
= (struct w1_reg_num
*) &rn
;
922 sl
= w1_slave_search_device(dev
, tmp
);
924 set_bit(W1_SLAVE_ACTIVE
, &sl
->flags
);
926 if (rn
&& tmp
->crc
== w1_calc_crc8((u8
*)&rn_le
, 7))
927 w1_attach_slave_device(dev
, tmp
);
930 atomic_dec(&dev
->refcnt
);
934 * w1_search() - Performs a ROM Search & registers any devices found.
935 * @dev: The master device to search
936 * @search_type: W1_SEARCH to search all devices, or W1_ALARM_SEARCH
937 * to return only devices in the alarmed state
938 * @cb: Function to call when a device is found
940 * The 1-wire search is a simple binary tree search.
941 * For each bit of the address, we read two bits and write one bit.
942 * The bit written will put to sleep all devies that don't match that bit.
943 * When the two reads differ, the direction choice is obvious.
944 * When both bits are 0, we must choose a path to take.
945 * When we can scan all 64 bits without having to choose a path, we are done.
947 * See "Application note 187 1-wire search algorithm" at www.maxim-ic.com
950 void w1_search(struct w1_master
*dev
, u8 search_type
, w1_slave_found_callback cb
)
952 u64 last_rn
, rn
, tmp64
;
953 int i
, slave_count
= 0;
954 int last_zero
, last_device
;
955 int search_bit
, desc_bit
;
966 while ( !last_device
&& (slave_count
++ < dev
->max_slave_count
) ) {
971 * Reset bus and all 1-wire device state machines
972 * so they can respond to our requests.
974 * Return 0 - device(s) present, 1 - no devices present.
976 mutex_lock(&dev
->bus_mutex
);
977 if (w1_reset_bus(dev
)) {
978 mutex_unlock(&dev
->bus_mutex
);
979 dev_dbg(&dev
->dev
, "No devices present on the wire.\n");
983 /* Do fast search on single slave bus */
984 if (dev
->max_slave_count
== 1) {
986 w1_write_8(dev
, W1_READ_ROM
);
987 rv
= w1_read_block(dev
, (u8
*)&rn
, 8);
988 mutex_unlock(&dev
->bus_mutex
);
996 /* Start the search */
997 w1_write_8(dev
, search_type
);
998 for (i
= 0; i
< 64; ++i
) {
999 /* Determine the direction/search bit */
1001 search_bit
= 1; /* took the 0 path last time, so take the 1 path */
1002 else if (i
> desc_bit
)
1003 search_bit
= 0; /* take the 0 path on the next branch */
1005 search_bit
= ((last_rn
>> i
) & 0x1);
1007 /* Read two bits and write one bit */
1008 triplet_ret
= w1_triplet(dev
, search_bit
);
1010 /* quit if no device responded */
1011 if ( (triplet_ret
& 0x03) == 0x03 )
1014 /* If both directions were valid, and we took the 0 path... */
1015 if (triplet_ret
== 0)
1018 /* extract the direction taken & update the device number */
1019 tmp64
= (triplet_ret
>> 2);
1022 if (test_bit(W1_ABORT_SEARCH
, &dev
->flags
)) {
1023 mutex_unlock(&dev
->bus_mutex
);
1024 dev_dbg(&dev
->dev
, "Abort w1_search\n");
1028 mutex_unlock(&dev
->bus_mutex
);
1030 if ( (triplet_ret
& 0x03) != 0x03 ) {
1031 if ((desc_bit
== last_zero
) || (last_zero
< 0)) {
1035 dev
->search_id
= rn
;
1037 desc_bit
= last_zero
;
1041 if (!last_device
&& slave_count
== dev
->max_slave_count
&&
1042 !test_bit(W1_WARN_MAX_COUNT
, &dev
->flags
)) {
1043 /* Only max_slave_count will be scanned in a search,
1044 * but it will start where it left off next search
1045 * until all ids are identified and then it will start
1046 * over. A continued search will report the previous
1047 * last id as the first id (provided it is still on the
1050 dev_info(&dev
->dev
, "%s: max_slave_count %d reached, "
1051 "will continue next search.\n", __func__
,
1052 dev
->max_slave_count
);
1053 set_bit(W1_WARN_MAX_COUNT
, &dev
->flags
);
1058 void w1_search_process_cb(struct w1_master
*dev
, u8 search_type
,
1059 w1_slave_found_callback cb
)
1061 struct w1_slave
*sl
, *sln
;
1063 mutex_lock(&dev
->list_mutex
);
1064 list_for_each_entry(sl
, &dev
->slist
, w1_slave_entry
)
1065 clear_bit(W1_SLAVE_ACTIVE
, &sl
->flags
);
1066 mutex_unlock(&dev
->list_mutex
);
1068 w1_search_devices(dev
, search_type
, cb
);
1070 mutex_lock(&dev
->list_mutex
);
1071 list_for_each_entry_safe(sl
, sln
, &dev
->slist
, w1_slave_entry
) {
1072 if (!test_bit(W1_SLAVE_ACTIVE
, &sl
->flags
) && !--sl
->ttl
) {
1073 mutex_unlock(&dev
->list_mutex
);
1074 w1_slave_detach(sl
);
1075 mutex_lock(&dev
->list_mutex
);
1077 else if (test_bit(W1_SLAVE_ACTIVE
, &sl
->flags
))
1078 sl
->ttl
= dev
->slave_ttl
;
1080 mutex_unlock(&dev
->list_mutex
);
1082 if (dev
->search_count
> 0)
1083 dev
->search_count
--;
1086 static void w1_search_process(struct w1_master
*dev
, u8 search_type
)
1088 w1_search_process_cb(dev
, search_type
, w1_slave_found
);
1092 * w1_process_callbacks() - execute each dev->async_list callback entry
1093 * @dev: w1_master device
1095 * The w1 master list_mutex must be held.
1097 * Return: 1 if there were commands to executed 0 otherwise
1099 int w1_process_callbacks(struct w1_master
*dev
)
1102 struct w1_async_cmd
*async_cmd
, *async_n
;
1104 /* The list can be added to in another thread, loop until it is empty */
1105 while (!list_empty(&dev
->async_list
)) {
1106 list_for_each_entry_safe(async_cmd
, async_n
, &dev
->async_list
,
1108 /* drop the lock, if it is a search it can take a long
1110 mutex_unlock(&dev
->list_mutex
);
1111 async_cmd
->cb(dev
, async_cmd
);
1113 mutex_lock(&dev
->list_mutex
);
1119 int w1_process(void *data
)
1121 struct w1_master
*dev
= (struct w1_master
*) data
;
1122 /* As long as w1_timeout is only set by a module parameter the sleep
1123 * time can be calculated in jiffies once.
1125 const unsigned long jtime
=
1126 usecs_to_jiffies(w1_timeout
* 1000000 + w1_timeout_us
);
1127 /* remainder if it woke up early */
1128 unsigned long jremain
= 0;
1132 if (!jremain
&& dev
->search_count
) {
1133 mutex_lock(&dev
->mutex
);
1134 w1_search_process(dev
, W1_SEARCH
);
1135 mutex_unlock(&dev
->mutex
);
1138 mutex_lock(&dev
->list_mutex
);
1139 /* Note, w1_process_callback drops the lock while processing,
1140 * but locks it again before returning.
1142 if (!w1_process_callbacks(dev
) && jremain
) {
1143 /* a wake up is either to stop the thread, process
1144 * callbacks, or search, it isn't process callbacks, so
1145 * schedule a search.
1150 __set_current_state(TASK_INTERRUPTIBLE
);
1152 /* hold list_mutex until after interruptible to prevent loosing
1153 * the wakeup signal when async_cmd is added.
1155 mutex_unlock(&dev
->list_mutex
);
1157 if (kthread_should_stop())
1160 /* Only sleep when the search is active. */
1161 if (dev
->search_count
) {
1164 jremain
= schedule_timeout(jremain
);
1170 atomic_dec(&dev
->refcnt
);
1175 static int __init
w1_init(void)
1179 pr_info("Driver for 1-wire Dallas network protocol.\n");
1183 retval
= bus_register(&w1_bus_type
);
1185 pr_err("Failed to register bus. err=%d.\n", retval
);
1186 goto err_out_exit_init
;
1189 retval
= driver_register(&w1_master_driver
);
1191 pr_err("Failed to register master driver. err=%d.\n",
1193 goto err_out_bus_unregister
;
1196 retval
= driver_register(&w1_slave_driver
);
1198 pr_err("Failed to register slave driver. err=%d.\n",
1200 goto err_out_master_unregister
;
1206 /* For undoing the slave register if there was a step after it. */
1207 err_out_slave_unregister
:
1208 driver_unregister(&w1_slave_driver
);
1211 err_out_master_unregister
:
1212 driver_unregister(&w1_master_driver
);
1214 err_out_bus_unregister
:
1215 bus_unregister(&w1_bus_type
);
1221 static void __exit
w1_fini(void)
1223 struct w1_master
*dev
;
1225 /* Set netlink removal messages and some cleanup */
1226 list_for_each_entry(dev
, &w1_masters
, w1_master_entry
)
1227 __w1_remove_master_device(dev
);
1231 driver_unregister(&w1_slave_driver
);
1232 driver_unregister(&w1_master_driver
);
1233 bus_unregister(&w1_bus_type
);
1236 module_init(w1_init
);
1237 module_exit(w1_fini
);