xref: /openbmc/linux/drivers/w1/w1.c (revision b34e08d5)
1 /*
2  *	w1.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 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 #include <linux/kthread.h>
34 #include <linux/freezer.h>
35 
36 #include <linux/atomic.h>
37 
38 #include "w1.h"
39 #include "w1_log.h"
40 #include "w1_int.h"
41 #include "w1_family.h"
42 #include "w1_netlink.h"
43 
44 MODULE_LICENSE("GPL");
45 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
46 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");
47 
48 static int w1_timeout = 10;
49 int w1_max_slave_count = 64;
50 int w1_max_slave_ttl = 10;
51 
52 module_param_named(timeout, w1_timeout, int, 0);
53 MODULE_PARM_DESC(timeout, "time in seconds between automatic slave searches");
54 /* A search stops when w1_max_slave_count devices have been found in that
55  * search.  The next search will start over and detect the same set of devices
56  * on a static 1-wire bus.  Memory is not allocated based on this number, just
57  * on the number of devices known to the kernel.  Having a high number does not
58  * consume additional resources.  As a special case, if there is only one
59  * device on the network and w1_max_slave_count is set to 1, the device id can
60  * be read directly skipping the normal slower search process.
61  */
62 module_param_named(max_slave_count, w1_max_slave_count, int, 0);
63 MODULE_PARM_DESC(max_slave_count,
64 	"maximum number of slaves detected in a search");
65 module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);
66 MODULE_PARM_DESC(slave_ttl,
67 	"Number of searches not seeing a slave before it will be removed");
68 
69 DEFINE_MUTEX(w1_mlock);
70 LIST_HEAD(w1_masters);
71 
72 static int w1_master_match(struct device *dev, struct device_driver *drv)
73 {
74 	return 1;
75 }
76 
77 static int w1_master_probe(struct device *dev)
78 {
79 	return -ENODEV;
80 }
81 
82 static void w1_master_release(struct device *dev)
83 {
84 	struct w1_master *md = dev_to_w1_master(dev);
85 
86 	dev_dbg(dev, "%s: Releasing %s.\n", __func__, md->name);
87 	memset(md, 0, sizeof(struct w1_master) + sizeof(struct w1_bus_master));
88 	kfree(md);
89 }
90 
91 static void w1_slave_release(struct device *dev)
92 {
93 	struct w1_slave *sl = dev_to_w1_slave(dev);
94 
95 	dev_dbg(dev, "%s: Releasing %s [%p]\n", __func__, sl->name, sl);
96 
97 	w1_family_put(sl->family);
98 	sl->master->slave_count--;
99 }
100 
101 static ssize_t name_show(struct device *dev, struct device_attribute *attr, char *buf)
102 {
103 	struct w1_slave *sl = dev_to_w1_slave(dev);
104 
105 	return sprintf(buf, "%s\n", sl->name);
106 }
107 static DEVICE_ATTR_RO(name);
108 
109 static ssize_t id_show(struct device *dev,
110 	struct device_attribute *attr, char *buf)
111 {
112 	struct w1_slave *sl = dev_to_w1_slave(dev);
113 	ssize_t count = sizeof(sl->reg_num);
114 
115 	memcpy(buf, (u8 *)&sl->reg_num, count);
116 	return count;
117 }
118 static DEVICE_ATTR_RO(id);
119 
120 static struct attribute *w1_slave_attrs[] = {
121 	&dev_attr_name.attr,
122 	&dev_attr_id.attr,
123 	NULL,
124 };
125 ATTRIBUTE_GROUPS(w1_slave);
126 
127 /* Default family */
128 
129 static ssize_t rw_write(struct file *filp, struct kobject *kobj,
130 			struct bin_attribute *bin_attr, char *buf, loff_t off,
131 			size_t count)
132 {
133 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
134 
135 	mutex_lock(&sl->master->mutex);
136 	if (w1_reset_select_slave(sl)) {
137 		count = 0;
138 		goto out_up;
139 	}
140 
141 	w1_write_block(sl->master, buf, count);
142 
143 out_up:
144 	mutex_unlock(&sl->master->mutex);
145 	return count;
146 }
147 
148 static ssize_t rw_read(struct file *filp, struct kobject *kobj,
149 		       struct bin_attribute *bin_attr, char *buf, loff_t off,
150 		       size_t count)
151 {
152 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
153 
154 	mutex_lock(&sl->master->mutex);
155 	w1_read_block(sl->master, buf, count);
156 	mutex_unlock(&sl->master->mutex);
157 	return count;
158 }
159 
160 static BIN_ATTR_RW(rw, PAGE_SIZE);
161 
162 static struct bin_attribute *w1_slave_bin_attrs[] = {
163 	&bin_attr_rw,
164 	NULL,
165 };
166 
167 static const struct attribute_group w1_slave_default_group = {
168 	.bin_attrs = w1_slave_bin_attrs,
169 };
170 
171 static const struct attribute_group *w1_slave_default_groups[] = {
172 	&w1_slave_default_group,
173 	NULL,
174 };
175 
176 static struct w1_family_ops w1_default_fops = {
177 	.groups		= w1_slave_default_groups,
178 };
179 
180 static struct w1_family w1_default_family = {
181 	.fops = &w1_default_fops,
182 };
183 
184 static int w1_uevent(struct device *dev, struct kobj_uevent_env *env);
185 
186 static struct bus_type w1_bus_type = {
187 	.name = "w1",
188 	.match = w1_master_match,
189 	.uevent = w1_uevent,
190 };
191 
192 struct device_driver w1_master_driver = {
193 	.name = "w1_master_driver",
194 	.bus = &w1_bus_type,
195 	.probe = w1_master_probe,
196 };
197 
198 struct device w1_master_device = {
199 	.parent = NULL,
200 	.bus = &w1_bus_type,
201 	.init_name = "w1 bus master",
202 	.driver = &w1_master_driver,
203 	.release = &w1_master_release
204 };
205 
206 static struct device_driver w1_slave_driver = {
207 	.name = "w1_slave_driver",
208 	.bus = &w1_bus_type,
209 };
210 
211 #if 0
212 struct device w1_slave_device = {
213 	.parent = NULL,
214 	.bus = &w1_bus_type,
215 	.init_name = "w1 bus slave",
216 	.driver = &w1_slave_driver,
217 	.release = &w1_slave_release
218 };
219 #endif  /*  0  */
220 
221 static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf)
222 {
223 	struct w1_master *md = dev_to_w1_master(dev);
224 	ssize_t count;
225 
226 	mutex_lock(&md->mutex);
227 	count = sprintf(buf, "%s\n", md->name);
228 	mutex_unlock(&md->mutex);
229 
230 	return count;
231 }
232 
233 static ssize_t w1_master_attribute_store_search(struct device * dev,
234 						struct device_attribute *attr,
235 						const char * buf, size_t count)
236 {
237 	long tmp;
238 	struct w1_master *md = dev_to_w1_master(dev);
239 	int ret;
240 
241 	ret = kstrtol(buf, 0, &tmp);
242 	if (ret)
243 		return ret;
244 
245 	mutex_lock(&md->mutex);
246 	md->search_count = tmp;
247 	mutex_unlock(&md->mutex);
248 	/* Only wake if it is going to be searching. */
249 	if (tmp)
250 		wake_up_process(md->thread);
251 
252 	return count;
253 }
254 
255 static ssize_t w1_master_attribute_show_search(struct device *dev,
256 					       struct device_attribute *attr,
257 					       char *buf)
258 {
259 	struct w1_master *md = dev_to_w1_master(dev);
260 	ssize_t count;
261 
262 	mutex_lock(&md->mutex);
263 	count = sprintf(buf, "%d\n", md->search_count);
264 	mutex_unlock(&md->mutex);
265 
266 	return count;
267 }
268 
269 static ssize_t w1_master_attribute_store_pullup(struct device *dev,
270 						struct device_attribute *attr,
271 						const char *buf, size_t count)
272 {
273 	long tmp;
274 	struct w1_master *md = dev_to_w1_master(dev);
275 	int ret;
276 
277 	ret = kstrtol(buf, 0, &tmp);
278 	if (ret)
279 		return ret;
280 
281 	mutex_lock(&md->mutex);
282 	md->enable_pullup = tmp;
283 	mutex_unlock(&md->mutex);
284 
285 	return count;
286 }
287 
288 static ssize_t w1_master_attribute_show_pullup(struct device *dev,
289 					       struct device_attribute *attr,
290 					       char *buf)
291 {
292 	struct w1_master *md = dev_to_w1_master(dev);
293 	ssize_t count;
294 
295 	mutex_lock(&md->mutex);
296 	count = sprintf(buf, "%d\n", md->enable_pullup);
297 	mutex_unlock(&md->mutex);
298 
299 	return count;
300 }
301 
302 static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)
303 {
304 	struct w1_master *md = dev_to_w1_master(dev);
305 	ssize_t count;
306 
307 	mutex_lock(&md->mutex);
308 	count = sprintf(buf, "0x%p\n", md->bus_master);
309 	mutex_unlock(&md->mutex);
310 	return count;
311 }
312 
313 static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)
314 {
315 	ssize_t count;
316 	count = sprintf(buf, "%d\n", w1_timeout);
317 	return count;
318 }
319 
320 static ssize_t w1_master_attribute_store_max_slave_count(struct device *dev,
321 	struct device_attribute *attr, const char *buf, size_t count)
322 {
323 	int tmp;
324 	struct w1_master *md = dev_to_w1_master(dev);
325 
326 	if (kstrtoint(buf, 0, &tmp) == -EINVAL || tmp < 1)
327 		return -EINVAL;
328 
329 	mutex_lock(&md->mutex);
330 	md->max_slave_count = tmp;
331 	/* allow each time the max_slave_count is updated */
332 	clear_bit(W1_WARN_MAX_COUNT, &md->flags);
333 	mutex_unlock(&md->mutex);
334 
335 	return count;
336 }
337 
338 static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
339 {
340 	struct w1_master *md = dev_to_w1_master(dev);
341 	ssize_t count;
342 
343 	mutex_lock(&md->mutex);
344 	count = sprintf(buf, "%d\n", md->max_slave_count);
345 	mutex_unlock(&md->mutex);
346 	return count;
347 }
348 
349 static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf)
350 {
351 	struct w1_master *md = dev_to_w1_master(dev);
352 	ssize_t count;
353 
354 	mutex_lock(&md->mutex);
355 	count = sprintf(buf, "%lu\n", md->attempts);
356 	mutex_unlock(&md->mutex);
357 	return count;
358 }
359 
360 static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
361 {
362 	struct w1_master *md = dev_to_w1_master(dev);
363 	ssize_t count;
364 
365 	mutex_lock(&md->mutex);
366 	count = sprintf(buf, "%d\n", md->slave_count);
367 	mutex_unlock(&md->mutex);
368 	return count;
369 }
370 
371 static ssize_t w1_master_attribute_show_slaves(struct device *dev,
372 	struct device_attribute *attr, char *buf)
373 {
374 	struct w1_master *md = dev_to_w1_master(dev);
375 	int c = PAGE_SIZE;
376 	struct list_head *ent, *n;
377 	struct w1_slave *sl = NULL;
378 
379 	mutex_lock(&md->list_mutex);
380 
381 	list_for_each_safe(ent, n, &md->slist) {
382 		sl = list_entry(ent, struct w1_slave, w1_slave_entry);
383 
384 		c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name);
385 	}
386 	if (!sl)
387 		c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n");
388 
389 	mutex_unlock(&md->list_mutex);
390 
391 	return PAGE_SIZE - c;
392 }
393 
394 static ssize_t w1_master_attribute_show_add(struct device *dev,
395 	struct device_attribute *attr, char *buf)
396 {
397 	int c = PAGE_SIZE;
398 	c -= snprintf(buf+PAGE_SIZE - c, c,
399 		"write device id xx-xxxxxxxxxxxx to add slave\n");
400 	return PAGE_SIZE - c;
401 }
402 
403 static int w1_atoreg_num(struct device *dev, const char *buf, size_t count,
404 	struct w1_reg_num *rn)
405 {
406 	unsigned int family;
407 	unsigned long long id;
408 	int i;
409 	u64 rn64_le;
410 
411 	/* The CRC value isn't read from the user because the sysfs directory
412 	 * doesn't include it and most messages from the bus search don't
413 	 * print it either.  It would be unreasonable for the user to then
414 	 * provide it.
415 	 */
416 	const char *error_msg = "bad slave string format, expecting "
417 		"ff-dddddddddddd\n";
418 
419 	if (buf[2] != '-') {
420 		dev_err(dev, "%s", error_msg);
421 		return -EINVAL;
422 	}
423 	i = sscanf(buf, "%02x-%012llx", &family, &id);
424 	if (i != 2) {
425 		dev_err(dev, "%s", error_msg);
426 		return -EINVAL;
427 	}
428 	rn->family = family;
429 	rn->id = id;
430 
431 	rn64_le = cpu_to_le64(*(u64 *)rn);
432 	rn->crc = w1_calc_crc8((u8 *)&rn64_le, 7);
433 
434 #if 0
435 	dev_info(dev, "With CRC device is %02x.%012llx.%02x.\n",
436 		  rn->family, (unsigned long long)rn->id, rn->crc);
437 #endif
438 
439 	return 0;
440 }
441 
442 /* Searches the slaves in the w1_master and returns a pointer or NULL.
443  * Note: must not hold list_mutex
444  */
445 struct w1_slave *w1_slave_search_device(struct w1_master *dev,
446 	struct w1_reg_num *rn)
447 {
448 	struct w1_slave *sl;
449 	mutex_lock(&dev->list_mutex);
450 	list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
451 		if (sl->reg_num.family == rn->family &&
452 				sl->reg_num.id == rn->id &&
453 				sl->reg_num.crc == rn->crc) {
454 			mutex_unlock(&dev->list_mutex);
455 			return sl;
456 		}
457 	}
458 	mutex_unlock(&dev->list_mutex);
459 	return NULL;
460 }
461 
462 static ssize_t w1_master_attribute_store_add(struct device *dev,
463 						struct device_attribute *attr,
464 						const char *buf, size_t count)
465 {
466 	struct w1_master *md = dev_to_w1_master(dev);
467 	struct w1_reg_num rn;
468 	struct w1_slave *sl;
469 	ssize_t result = count;
470 
471 	if (w1_atoreg_num(dev, buf, count, &rn))
472 		return -EINVAL;
473 
474 	mutex_lock(&md->mutex);
475 	sl = w1_slave_search_device(md, &rn);
476 	/* It would be nice to do a targeted search one the one-wire bus
477 	 * for the new device to see if it is out there or not.  But the
478 	 * current search doesn't support that.
479 	 */
480 	if (sl) {
481 		dev_info(dev, "Device %s already exists\n", sl->name);
482 		result = -EINVAL;
483 	} else {
484 		w1_attach_slave_device(md, &rn);
485 	}
486 	mutex_unlock(&md->mutex);
487 
488 	return result;
489 }
490 
491 static ssize_t w1_master_attribute_show_remove(struct device *dev,
492 	struct device_attribute *attr, char *buf)
493 {
494 	int c = PAGE_SIZE;
495 	c -= snprintf(buf+PAGE_SIZE - c, c,
496 		"write device id xx-xxxxxxxxxxxx to remove slave\n");
497 	return PAGE_SIZE - c;
498 }
499 
500 static ssize_t w1_master_attribute_store_remove(struct device *dev,
501 						struct device_attribute *attr,
502 						const char *buf, size_t count)
503 {
504 	struct w1_master *md = dev_to_w1_master(dev);
505 	struct w1_reg_num rn;
506 	struct w1_slave *sl;
507 	ssize_t result = count;
508 
509 	if (w1_atoreg_num(dev, buf, count, &rn))
510 		return -EINVAL;
511 
512 	mutex_lock(&md->mutex);
513 	sl = w1_slave_search_device(md, &rn);
514 	if (sl) {
515 		result = w1_slave_detach(sl);
516 		/* refcnt 0 means it was detached in the call */
517 		if (result == 0)
518 			result = count;
519 	} else {
520 		dev_info(dev, "Device %02x-%012llx doesn't exists\n", rn.family,
521 			(unsigned long long)rn.id);
522 		result = -EINVAL;
523 	}
524 	mutex_unlock(&md->mutex);
525 
526 	return result;
527 }
528 
529 #define W1_MASTER_ATTR_RO(_name, _mode)				\
530 	struct device_attribute w1_master_attribute_##_name =	\
531 		__ATTR(w1_master_##_name, _mode,		\
532 		       w1_master_attribute_show_##_name, NULL)
533 
534 #define W1_MASTER_ATTR_RW(_name, _mode)				\
535 	struct device_attribute w1_master_attribute_##_name =	\
536 		__ATTR(w1_master_##_name, _mode,		\
537 		       w1_master_attribute_show_##_name,	\
538 		       w1_master_attribute_store_##_name)
539 
540 static W1_MASTER_ATTR_RO(name, S_IRUGO);
541 static W1_MASTER_ATTR_RO(slaves, S_IRUGO);
542 static W1_MASTER_ATTR_RO(slave_count, S_IRUGO);
543 static W1_MASTER_ATTR_RW(max_slave_count, S_IRUGO | S_IWUSR | S_IWGRP);
544 static W1_MASTER_ATTR_RO(attempts, S_IRUGO);
545 static W1_MASTER_ATTR_RO(timeout, S_IRUGO);
546 static W1_MASTER_ATTR_RO(pointer, S_IRUGO);
547 static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUSR | S_IWGRP);
548 static W1_MASTER_ATTR_RW(pullup, S_IRUGO | S_IWUSR | S_IWGRP);
549 static W1_MASTER_ATTR_RW(add, S_IRUGO | S_IWUSR | S_IWGRP);
550 static W1_MASTER_ATTR_RW(remove, S_IRUGO | S_IWUSR | S_IWGRP);
551 
552 static struct attribute *w1_master_default_attrs[] = {
553 	&w1_master_attribute_name.attr,
554 	&w1_master_attribute_slaves.attr,
555 	&w1_master_attribute_slave_count.attr,
556 	&w1_master_attribute_max_slave_count.attr,
557 	&w1_master_attribute_attempts.attr,
558 	&w1_master_attribute_timeout.attr,
559 	&w1_master_attribute_pointer.attr,
560 	&w1_master_attribute_search.attr,
561 	&w1_master_attribute_pullup.attr,
562 	&w1_master_attribute_add.attr,
563 	&w1_master_attribute_remove.attr,
564 	NULL
565 };
566 
567 static struct attribute_group w1_master_defattr_group = {
568 	.attrs = w1_master_default_attrs,
569 };
570 
571 int w1_create_master_attributes(struct w1_master *master)
572 {
573 	return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
574 }
575 
576 void w1_destroy_master_attributes(struct w1_master *master)
577 {
578 	sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
579 }
580 
581 static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
582 {
583 	struct w1_master *md = NULL;
584 	struct w1_slave *sl = NULL;
585 	char *event_owner, *name;
586 	int err = 0;
587 
588 	if (dev->driver == &w1_master_driver) {
589 		md = container_of(dev, struct w1_master, dev);
590 		event_owner = "master";
591 		name = md->name;
592 	} else if (dev->driver == &w1_slave_driver) {
593 		sl = container_of(dev, struct w1_slave, dev);
594 		event_owner = "slave";
595 		name = sl->name;
596 	} else {
597 		dev_dbg(dev, "Unknown event.\n");
598 		return -EINVAL;
599 	}
600 
601 	dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
602 			event_owner, name, dev_name(dev));
603 
604 	if (dev->driver != &w1_slave_driver || !sl)
605 		goto end;
606 
607 	err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);
608 	if (err)
609 		goto end;
610 
611 	err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",
612 			     (unsigned long long)sl->reg_num.id);
613 end:
614 	return err;
615 }
616 
617 /*
618  * Handle sysfs file creation and removal here, before userspace is told that
619  * the device is added / removed from the system
620  */
621 static int w1_bus_notify(struct notifier_block *nb, unsigned long action,
622 			 void *data)
623 {
624 	struct device *dev = data;
625 	struct w1_slave *sl;
626 	struct w1_family_ops *fops;
627 	int err;
628 
629 	/*
630 	 * Only care about slave devices at the moment.  Yes, we should use a
631 	 * separate "type" for this, but for now, look at the release function
632 	 * to know which type it is...
633 	 */
634 	if (dev->release != w1_slave_release)
635 		return 0;
636 
637 	sl = dev_to_w1_slave(dev);
638 	fops = sl->family->fops;
639 
640 	if (!fops)
641 		return 0;
642 
643 	switch (action) {
644 	case BUS_NOTIFY_ADD_DEVICE:
645 		/* if the family driver needs to initialize something... */
646 		if (fops->add_slave) {
647 			err = fops->add_slave(sl);
648 			if (err < 0) {
649 				dev_err(&sl->dev,
650 					"add_slave() call failed. err=%d\n",
651 					err);
652 				return err;
653 			}
654 		}
655 		if (fops->groups) {
656 			err = sysfs_create_groups(&sl->dev.kobj, fops->groups);
657 			if (err) {
658 				dev_err(&sl->dev,
659 					"sysfs group creation failed. err=%d\n",
660 					err);
661 				return err;
662 			}
663 		}
664 
665 		break;
666 	case BUS_NOTIFY_DEL_DEVICE:
667 		if (fops->remove_slave)
668 			sl->family->fops->remove_slave(sl);
669 		if (fops->groups)
670 			sysfs_remove_groups(&sl->dev.kobj, fops->groups);
671 		break;
672 	}
673 	return 0;
674 }
675 
676 static struct notifier_block w1_bus_nb = {
677 	.notifier_call = w1_bus_notify,
678 };
679 
680 static int __w1_attach_slave_device(struct w1_slave *sl)
681 {
682 	int err;
683 
684 	sl->dev.parent = &sl->master->dev;
685 	sl->dev.driver = &w1_slave_driver;
686 	sl->dev.bus = &w1_bus_type;
687 	sl->dev.release = &w1_slave_release;
688 	sl->dev.groups = w1_slave_groups;
689 
690 	dev_set_name(&sl->dev, "%02x-%012llx",
691 		 (unsigned int) sl->reg_num.family,
692 		 (unsigned long long) sl->reg_num.id);
693 	snprintf(&sl->name[0], sizeof(sl->name),
694 		 "%02x-%012llx",
695 		 (unsigned int) sl->reg_num.family,
696 		 (unsigned long long) sl->reg_num.id);
697 
698 	dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
699 		dev_name(&sl->dev), sl);
700 
701 	err = device_register(&sl->dev);
702 	if (err < 0) {
703 		dev_err(&sl->dev,
704 			"Device registration [%s] failed. err=%d\n",
705 			dev_name(&sl->dev), err);
706 		return err;
707 	}
708 
709 
710 	dev_set_uevent_suppress(&sl->dev, false);
711 	kobject_uevent(&sl->dev.kobj, KOBJ_ADD);
712 
713 	mutex_lock(&sl->master->list_mutex);
714 	list_add_tail(&sl->w1_slave_entry, &sl->master->slist);
715 	mutex_unlock(&sl->master->list_mutex);
716 
717 	return 0;
718 }
719 
720 int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn)
721 {
722 	struct w1_slave *sl;
723 	struct w1_family *f;
724 	int err;
725 	struct w1_netlink_msg msg;
726 
727 	sl = kzalloc(sizeof(struct w1_slave), GFP_KERNEL);
728 	if (!sl) {
729 		dev_err(&dev->dev,
730 			 "%s: failed to allocate new slave device.\n",
731 			 __func__);
732 		return -ENOMEM;
733 	}
734 
735 
736 	sl->owner = THIS_MODULE;
737 	sl->master = dev;
738 	set_bit(W1_SLAVE_ACTIVE, &sl->flags);
739 
740 	memset(&msg, 0, sizeof(msg));
741 	memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
742 	atomic_set(&sl->refcnt, 1);
743 	atomic_inc(&sl->master->refcnt);
744 
745 	/* slave modules need to be loaded in a context with unlocked mutex */
746 	mutex_unlock(&dev->mutex);
747 	request_module("w1-family-0x%0x", rn->family);
748 	mutex_lock(&dev->mutex);
749 
750 	spin_lock(&w1_flock);
751 	f = w1_family_registered(rn->family);
752 	if (!f) {
753 		f= &w1_default_family;
754 		dev_info(&dev->dev, "Family %x for %02x.%012llx.%02x is not registered.\n",
755 			  rn->family, rn->family,
756 			  (unsigned long long)rn->id, rn->crc);
757 	}
758 	__w1_family_get(f);
759 	spin_unlock(&w1_flock);
760 
761 	sl->family = f;
762 
763 
764 	err = __w1_attach_slave_device(sl);
765 	if (err < 0) {
766 		dev_err(&dev->dev, "%s: Attaching %s failed.\n", __func__,
767 			 sl->name);
768 		w1_family_put(sl->family);
769 		kfree(sl);
770 		return err;
771 	}
772 
773 	sl->ttl = dev->slave_ttl;
774 	dev->slave_count++;
775 
776 	memcpy(msg.id.id, rn, sizeof(msg.id));
777 	msg.type = W1_SLAVE_ADD;
778 	w1_netlink_send(dev, &msg);
779 
780 	return 0;
781 }
782 
783 int w1_unref_slave(struct w1_slave *sl)
784 {
785 	struct w1_master *dev = sl->master;
786 	int refcnt;
787 	mutex_lock(&dev->list_mutex);
788 	refcnt = atomic_sub_return(1, &sl->refcnt);
789 	if (refcnt == 0) {
790 		struct w1_netlink_msg msg;
791 
792 		dev_dbg(&sl->dev, "%s: detaching %s [%p].\n", __func__,
793 			sl->name, sl);
794 
795 		list_del(&sl->w1_slave_entry);
796 
797 		memset(&msg, 0, sizeof(msg));
798 		memcpy(msg.id.id, &sl->reg_num, sizeof(msg.id));
799 		msg.type = W1_SLAVE_REMOVE;
800 		w1_netlink_send(sl->master, &msg);
801 
802 		device_unregister(&sl->dev);
803 		#ifdef DEBUG
804 		memset(sl, 0, sizeof(*sl));
805 		#endif
806 		kfree(sl);
807 	}
808 	atomic_dec(&dev->refcnt);
809 	mutex_unlock(&dev->list_mutex);
810 	return refcnt;
811 }
812 
813 int w1_slave_detach(struct w1_slave *sl)
814 {
815 	/* Only detach a slave once as it decreases the refcnt each time. */
816 	int destroy_now;
817 	mutex_lock(&sl->master->list_mutex);
818 	destroy_now = !test_bit(W1_SLAVE_DETACH, &sl->flags);
819 	set_bit(W1_SLAVE_DETACH, &sl->flags);
820 	mutex_unlock(&sl->master->list_mutex);
821 
822 	if (destroy_now)
823 		destroy_now = !w1_unref_slave(sl);
824 	return destroy_now ? 0 : -EBUSY;
825 }
826 
827 struct w1_master *w1_search_master_id(u32 id)
828 {
829 	struct w1_master *dev;
830 	int found = 0;
831 
832 	mutex_lock(&w1_mlock);
833 	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
834 		if (dev->id == id) {
835 			found = 1;
836 			atomic_inc(&dev->refcnt);
837 			break;
838 		}
839 	}
840 	mutex_unlock(&w1_mlock);
841 
842 	return (found)?dev:NULL;
843 }
844 
845 struct w1_slave *w1_search_slave(struct w1_reg_num *id)
846 {
847 	struct w1_master *dev;
848 	struct w1_slave *sl = NULL;
849 	int found = 0;
850 
851 	mutex_lock(&w1_mlock);
852 	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
853 		mutex_lock(&dev->list_mutex);
854 		list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
855 			if (sl->reg_num.family == id->family &&
856 					sl->reg_num.id == id->id &&
857 					sl->reg_num.crc == id->crc) {
858 				found = 1;
859 				atomic_inc(&dev->refcnt);
860 				atomic_inc(&sl->refcnt);
861 				break;
862 			}
863 		}
864 		mutex_unlock(&dev->list_mutex);
865 
866 		if (found)
867 			break;
868 	}
869 	mutex_unlock(&w1_mlock);
870 
871 	return (found)?sl:NULL;
872 }
873 
874 void w1_reconnect_slaves(struct w1_family *f, int attach)
875 {
876 	struct w1_slave *sl, *sln;
877 	struct w1_master *dev;
878 
879 	mutex_lock(&w1_mlock);
880 	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
881 		dev_dbg(&dev->dev, "Reconnecting slaves in device %s "
882 			"for family %02x.\n", dev->name, f->fid);
883 		mutex_lock(&dev->mutex);
884 		mutex_lock(&dev->list_mutex);
885 		list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
886 			/* If it is a new family, slaves with the default
887 			 * family driver and are that family will be
888 			 * connected.  If the family is going away, devices
889 			 * matching that family are reconneced.
890 			 */
891 			if ((attach && sl->family->fid == W1_FAMILY_DEFAULT
892 				&& sl->reg_num.family == f->fid) ||
893 				(!attach && sl->family->fid == f->fid)) {
894 				struct w1_reg_num rn;
895 
896 				mutex_unlock(&dev->list_mutex);
897 				memcpy(&rn, &sl->reg_num, sizeof(rn));
898 				/* If it was already in use let the automatic
899 				 * scan pick it up again later.
900 				 */
901 				if (!w1_slave_detach(sl))
902 					w1_attach_slave_device(dev, &rn);
903 				mutex_lock(&dev->list_mutex);
904 			}
905 		}
906 		dev_dbg(&dev->dev, "Reconnecting slaves in device %s "
907 			"has been finished.\n", dev->name);
908 		mutex_unlock(&dev->list_mutex);
909 		mutex_unlock(&dev->mutex);
910 	}
911 	mutex_unlock(&w1_mlock);
912 }
913 
914 void w1_slave_found(struct w1_master *dev, u64 rn)
915 {
916 	struct w1_slave *sl;
917 	struct w1_reg_num *tmp;
918 	u64 rn_le = cpu_to_le64(rn);
919 
920 	atomic_inc(&dev->refcnt);
921 
922 	tmp = (struct w1_reg_num *) &rn;
923 
924 	sl = w1_slave_search_device(dev, tmp);
925 	if (sl) {
926 		set_bit(W1_SLAVE_ACTIVE, &sl->flags);
927 	} else {
928 		if (rn && tmp->crc == w1_calc_crc8((u8 *)&rn_le, 7))
929 			w1_attach_slave_device(dev, tmp);
930 	}
931 
932 	atomic_dec(&dev->refcnt);
933 }
934 
935 /**
936  * w1_search() - Performs a ROM Search & registers any devices found.
937  * @dev: The master device to search
938  * @search_type: W1_SEARCH to search all devices, or W1_ALARM_SEARCH
939  * to return only devices in the alarmed state
940  * @cb: Function to call when a device is found
941  *
942  * The 1-wire search is a simple binary tree search.
943  * For each bit of the address, we read two bits and write one bit.
944  * The bit written will put to sleep all devies that don't match that bit.
945  * When the two reads differ, the direction choice is obvious.
946  * When both bits are 0, we must choose a path to take.
947  * When we can scan all 64 bits without having to choose a path, we are done.
948  *
949  * See "Application note 187 1-wire search algorithm" at www.maxim-ic.com
950  *
951  */
952 void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
953 {
954 	u64 last_rn, rn, tmp64;
955 	int i, slave_count = 0;
956 	int last_zero, last_device;
957 	int search_bit, desc_bit;
958 	u8  triplet_ret = 0;
959 
960 	search_bit = 0;
961 	rn = dev->search_id;
962 	last_rn = 0;
963 	last_device = 0;
964 	last_zero = -1;
965 
966 	desc_bit = 64;
967 
968 	while ( !last_device && (slave_count++ < dev->max_slave_count) ) {
969 		last_rn = rn;
970 		rn = 0;
971 
972 		/*
973 		 * Reset bus and all 1-wire device state machines
974 		 * so they can respond to our requests.
975 		 *
976 		 * Return 0 - device(s) present, 1 - no devices present.
977 		 */
978 		mutex_lock(&dev->bus_mutex);
979 		if (w1_reset_bus(dev)) {
980 			mutex_unlock(&dev->bus_mutex);
981 			dev_dbg(&dev->dev, "No devices present on the wire.\n");
982 			break;
983 		}
984 
985 		/* Do fast search on single slave bus */
986 		if (dev->max_slave_count == 1) {
987 			int rv;
988 			w1_write_8(dev, W1_READ_ROM);
989 			rv = w1_read_block(dev, (u8 *)&rn, 8);
990 			mutex_unlock(&dev->bus_mutex);
991 
992 			if (rv == 8 && rn)
993 				cb(dev, rn);
994 
995 			break;
996 		}
997 
998 		/* Start the search */
999 		w1_write_8(dev, search_type);
1000 		for (i = 0; i < 64; ++i) {
1001 			/* Determine the direction/search bit */
1002 			if (i == desc_bit)
1003 				search_bit = 1;	  /* took the 0 path last time, so take the 1 path */
1004 			else if (i > desc_bit)
1005 				search_bit = 0;	  /* take the 0 path on the next branch */
1006 			else
1007 				search_bit = ((last_rn >> i) & 0x1);
1008 
1009 			/* Read two bits and write one bit */
1010 			triplet_ret = w1_triplet(dev, search_bit);
1011 
1012 			/* quit if no device responded */
1013 			if ( (triplet_ret & 0x03) == 0x03 )
1014 				break;
1015 
1016 			/* If both directions were valid, and we took the 0 path... */
1017 			if (triplet_ret == 0)
1018 				last_zero = i;
1019 
1020 			/* extract the direction taken & update the device number */
1021 			tmp64 = (triplet_ret >> 2);
1022 			rn |= (tmp64 << i);
1023 
1024 			if (test_bit(W1_ABORT_SEARCH, &dev->flags)) {
1025 				mutex_unlock(&dev->bus_mutex);
1026 				dev_dbg(&dev->dev, "Abort w1_search\n");
1027 				return;
1028 			}
1029 		}
1030 		mutex_unlock(&dev->bus_mutex);
1031 
1032 		if ( (triplet_ret & 0x03) != 0x03 ) {
1033 			if ((desc_bit == last_zero) || (last_zero < 0)) {
1034 				last_device = 1;
1035 				dev->search_id = 0;
1036 			} else {
1037 				dev->search_id = rn;
1038 			}
1039 			desc_bit = last_zero;
1040 			cb(dev, rn);
1041 		}
1042 
1043 		if (!last_device && slave_count == dev->max_slave_count &&
1044 			!test_bit(W1_WARN_MAX_COUNT, &dev->flags)) {
1045 			/* Only max_slave_count will be scanned in a search,
1046 			 * but it will start where it left off next search
1047 			 * until all ids are identified and then it will start
1048 			 * over.  A continued search will report the previous
1049 			 * last id as the first id (provided it is still on the
1050 			 * bus).
1051 			 */
1052 			dev_info(&dev->dev, "%s: max_slave_count %d reached, "
1053 				"will continue next search.\n", __func__,
1054 				dev->max_slave_count);
1055 			set_bit(W1_WARN_MAX_COUNT, &dev->flags);
1056 		}
1057 	}
1058 }
1059 
1060 void w1_search_process_cb(struct w1_master *dev, u8 search_type,
1061 	w1_slave_found_callback cb)
1062 {
1063 	struct w1_slave *sl, *sln;
1064 
1065 	mutex_lock(&dev->list_mutex);
1066 	list_for_each_entry(sl, &dev->slist, w1_slave_entry)
1067 		clear_bit(W1_SLAVE_ACTIVE, &sl->flags);
1068 	mutex_unlock(&dev->list_mutex);
1069 
1070 	w1_search_devices(dev, search_type, cb);
1071 
1072 	mutex_lock(&dev->list_mutex);
1073 	list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
1074 		if (!test_bit(W1_SLAVE_ACTIVE, &sl->flags) && !--sl->ttl) {
1075 			mutex_unlock(&dev->list_mutex);
1076 			w1_slave_detach(sl);
1077 			mutex_lock(&dev->list_mutex);
1078 		}
1079 		else if (test_bit(W1_SLAVE_ACTIVE, &sl->flags))
1080 			sl->ttl = dev->slave_ttl;
1081 	}
1082 	mutex_unlock(&dev->list_mutex);
1083 
1084 	if (dev->search_count > 0)
1085 		dev->search_count--;
1086 }
1087 
1088 static void w1_search_process(struct w1_master *dev, u8 search_type)
1089 {
1090 	w1_search_process_cb(dev, search_type, w1_slave_found);
1091 }
1092 
1093 /**
1094  * w1_process_callbacks() - execute each dev->async_list callback entry
1095  * @dev: w1_master device
1096  *
1097  * Return: 1 if there were commands to executed 0 otherwise
1098  */
1099 int w1_process_callbacks(struct w1_master *dev)
1100 {
1101 	int ret = 0;
1102 	struct w1_async_cmd *async_cmd, *async_n;
1103 
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,
1107 			async_entry) {
1108 			/* drop the lock, if it is a search it can take a long
1109 			 * time */
1110 			mutex_unlock(&dev->list_mutex);
1111 			async_cmd->cb(dev, async_cmd);
1112 			ret = 1;
1113 			mutex_lock(&dev->list_mutex);
1114 		}
1115 	}
1116 	return ret;
1117 }
1118 
1119 int w1_process(void *data)
1120 {
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.
1124 	 */
1125 	const unsigned long jtime = msecs_to_jiffies(w1_timeout * 1000);
1126 	/* remainder if it woke up early */
1127 	unsigned long jremain = 0;
1128 
1129 	for (;;) {
1130 
1131 		if (!jremain && dev->search_count) {
1132 			mutex_lock(&dev->mutex);
1133 			w1_search_process(dev, W1_SEARCH);
1134 			mutex_unlock(&dev->mutex);
1135 		}
1136 
1137 		mutex_lock(&dev->list_mutex);
1138 		/* Note, w1_process_callback drops the lock while processing,
1139 		 * but locks it again before returning.
1140 		 */
1141 		if (!w1_process_callbacks(dev) && jremain) {
1142 			/* a wake up is either to stop the thread, process
1143 			 * callbacks, or search, it isn't process callbacks, so
1144 			 * schedule a search.
1145 			 */
1146 			jremain = 1;
1147 		}
1148 
1149 		try_to_freeze();
1150 		__set_current_state(TASK_INTERRUPTIBLE);
1151 
1152 		/* hold list_mutex until after interruptible to prevent loosing
1153 		 * the wakeup signal when async_cmd is added.
1154 		 */
1155 		mutex_unlock(&dev->list_mutex);
1156 
1157 		if (kthread_should_stop())
1158 			break;
1159 
1160 		/* Only sleep when the search is active. */
1161 		if (dev->search_count) {
1162 			if (!jremain)
1163 				jremain = jtime;
1164 			jremain = schedule_timeout(jremain);
1165 		}
1166 		else
1167 			schedule();
1168 	}
1169 
1170 	atomic_dec(&dev->refcnt);
1171 
1172 	return 0;
1173 }
1174 
1175 static int __init w1_init(void)
1176 {
1177 	int retval;
1178 
1179 	printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n");
1180 
1181 	w1_init_netlink();
1182 
1183 	retval = bus_register(&w1_bus_type);
1184 	if (retval) {
1185 		printk(KERN_ERR "Failed to register bus. err=%d.\n", retval);
1186 		goto err_out_exit_init;
1187 	}
1188 
1189 	retval = bus_register_notifier(&w1_bus_type, &w1_bus_nb);
1190 	if (retval)
1191 		goto err_out_bus_unregister;
1192 
1193 	retval = driver_register(&w1_master_driver);
1194 	if (retval) {
1195 		printk(KERN_ERR
1196 			"Failed to register master driver. err=%d.\n",
1197 			retval);
1198 		goto err_out_bus_unregister;
1199 	}
1200 
1201 	retval = driver_register(&w1_slave_driver);
1202 	if (retval) {
1203 		printk(KERN_ERR
1204 			"Failed to register slave driver. err=%d.\n",
1205 			retval);
1206 		goto err_out_master_unregister;
1207 	}
1208 
1209 	return 0;
1210 
1211 #if 0
1212 /* For undoing the slave register if there was a step after it. */
1213 err_out_slave_unregister:
1214 	driver_unregister(&w1_slave_driver);
1215 #endif
1216 
1217 err_out_master_unregister:
1218 	driver_unregister(&w1_master_driver);
1219 
1220 err_out_bus_unregister:
1221 	bus_unregister(&w1_bus_type);
1222 
1223 err_out_exit_init:
1224 	return retval;
1225 }
1226 
1227 static void __exit w1_fini(void)
1228 {
1229 	struct w1_master *dev;
1230 
1231 	/* Set netlink removal messages and some cleanup */
1232 	list_for_each_entry(dev, &w1_masters, w1_master_entry)
1233 		__w1_remove_master_device(dev);
1234 
1235 	w1_fini_netlink();
1236 
1237 	driver_unregister(&w1_slave_driver);
1238 	driver_unregister(&w1_master_driver);
1239 	bus_unregister(&w1_bus_type);
1240 }
1241 
1242 module_init(w1_init);
1243 module_exit(w1_fini);
1244