w1.c 19.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
E
Evgeniy Polyakov 已提交
2
 *	w1.c
L
Linus Torvalds 已提交
3 4
 *
 * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
E
Evgeniy Polyakov 已提交
5
 *
L
Linus Torvalds 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/sched.h>

#include <asm/atomic.h>

#include "w1.h"
#include "w1_io.h"
#include "w1_log.h"
#include "w1_int.h"
#include "w1_family.h"
#include "w1_netlink.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");

static int w1_timeout = 10;
int w1_max_slave_count = 10;
int w1_max_slave_ttl = 10;

module_param_named(timeout, w1_timeout, int, 0);
module_param_named(max_slave_count, w1_max_slave_count, int, 0);
module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);

DEFINE_SPINLOCK(w1_mlock);
LIST_HEAD(w1_masters);

static pid_t control_thread;
static int control_needs_exit;
static DECLARE_COMPLETION(w1_control_complete);

62 63 64 65 66 67 68 69 70 71 72 73 74
/* stuff for the default family */
static ssize_t w1_famdefault_read_name(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	return(sprintf(buf, "%s\n", sl->name));
}
static struct w1_family_ops w1_default_fops = {
	.rname = &w1_famdefault_read_name,
};
static struct w1_family w1_default_family = {
	.fops = &w1_default_fops,
};

L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
static int w1_master_match(struct device *dev, struct device_driver *drv)
{
	return 1;
}

static int w1_master_probe(struct device *dev)
{
	return -ENODEV;
}

static int w1_master_remove(struct device *dev)
{
	return 0;
}

static void w1_master_release(struct device *dev)
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);

	complete(&md->dev_released);
}

static void w1_slave_release(struct device *dev)
{
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);

	complete(&sl->dev_released);
}

104
static ssize_t w1_default_read_name(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
105 106 107 108 109 110 111 112 113 114
{
	return sprintf(buf, "No family registered.\n");
}

static ssize_t w1_default_read_bin(struct kobject *kobj, char *buf, loff_t off,
		     size_t count)
{
	return sprintf(buf, "No family registered.\n");
}

E
Evgeniy Polyakov 已提交
115 116 117 118 119 120 121 122 123 124 125 126 127 128
static struct device_attribute w1_slave_attribute =
	__ATTR(name, S_IRUGO, w1_default_read_name, NULL);

static struct bin_attribute w1_slave_bin_attribute = {
	.attr = {
		.name = "w1_slave",
		.mode = S_IRUGO,
		.owner = THIS_MODULE,
	},
	.size = W1_SLAVE_DATA_SIZE,
	.read = &w1_default_read_bin,
};


L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
static struct bus_type w1_bus_type = {
	.name = "w1",
	.match = w1_master_match,
};

struct device_driver w1_driver = {
	.name = "w1_driver",
	.bus = &w1_bus_type,
	.probe = w1_master_probe,
	.remove = w1_master_remove,
};

struct device w1_device = {
	.parent = NULL,
	.bus = &w1_bus_type,
	.bus_id = "w1 bus master",
	.driver = &w1_driver,
	.release = &w1_master_release
};

149
static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
150
{
151
	struct w1_master *md = container_of(dev, struct w1_master, dev);
L
Linus Torvalds 已提交
152
	ssize_t count;
E
Evgeniy Polyakov 已提交
153

L
Linus Torvalds 已提交
154 155 156 157
	if (down_interruptible (&md->mutex))
		return -EBUSY;

	count = sprintf(buf, "%s\n", md->name);
E
Evgeniy Polyakov 已提交
158

L
Linus Torvalds 已提交
159 160 161 162 163
	up(&md->mutex);

	return count;
}

164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
static ssize_t w1_master_attribute_store_search(struct device * dev,
						struct device_attribute *attr,
						const char * buf, size_t count)
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);

	if (down_interruptible (&md->mutex))
		return -EBUSY;

	md->search_count = simple_strtol(buf, NULL, 0);

	up(&md->mutex);

	return count;
}

static ssize_t w1_master_attribute_show_search(struct device *dev,
					       struct device_attribute *attr,
					       char *buf)
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);
	ssize_t count;

	if (down_interruptible (&md->mutex))
		return -EBUSY;

	count = sprintf(buf, "%d\n", md->search_count);

	up(&md->mutex);

	return count;
}

197
static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
198 199 200
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);
	ssize_t count;
E
Evgeniy Polyakov 已提交
201

L
Linus Torvalds 已提交
202 203 204 205
	if (down_interruptible(&md->mutex))
		return -EBUSY;

	count = sprintf(buf, "0x%p\n", md->bus_master);
E
Evgeniy Polyakov 已提交
206

L
Linus Torvalds 已提交
207 208 209 210
	up(&md->mutex);
	return count;
}

211
static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
212 213 214 215 216 217
{
	ssize_t count;
	count = sprintf(buf, "%d\n", w1_timeout);
	return count;
}

218
static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
219 220 221
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);
	ssize_t count;
E
Evgeniy Polyakov 已提交
222

L
Linus Torvalds 已提交
223 224 225 226
	if (down_interruptible(&md->mutex))
		return -EBUSY;

	count = sprintf(buf, "%d\n", md->max_slave_count);
E
Evgeniy Polyakov 已提交
227

L
Linus Torvalds 已提交
228 229 230 231
	up(&md->mutex);
	return count;
}

232
static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
233 234 235
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);
	ssize_t count;
E
Evgeniy Polyakov 已提交
236

L
Linus Torvalds 已提交
237 238 239 240
	if (down_interruptible(&md->mutex))
		return -EBUSY;

	count = sprintf(buf, "%lu\n", md->attempts);
E
Evgeniy Polyakov 已提交
241

L
Linus Torvalds 已提交
242 243 244 245
	up(&md->mutex);
	return count;
}

246
static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
247 248 249
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);
	ssize_t count;
E
Evgeniy Polyakov 已提交
250

L
Linus Torvalds 已提交
251 252 253 254
	if (down_interruptible(&md->mutex))
		return -EBUSY;

	count = sprintf(buf, "%d\n", md->slave_count);
E
Evgeniy Polyakov 已提交
255

L
Linus Torvalds 已提交
256 257 258 259
	up(&md->mutex);
	return count;
}

260
static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
{
	struct w1_master *md = container_of(dev, struct w1_master, dev);
	int c = PAGE_SIZE;

	if (down_interruptible(&md->mutex))
		return -EBUSY;

	if (md->slave_count == 0)
		c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n");
	else {
		struct list_head *ent, *n;
		struct w1_slave *sl;

		list_for_each_safe(ent, n, &md->slist) {
			sl = list_entry(ent, struct w1_slave, w1_slave_entry);

E
Evgeniy Polyakov 已提交
277
			c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name);
L
Linus Torvalds 已提交
278 279 280 281 282 283 284 285
		}
	}

	up(&md->mutex);

	return PAGE_SIZE - c;
}

E
Evgeniy Polyakov 已提交
286 287 288 289 290
#define W1_MASTER_ATTR_RO(_name, _mode)				\
	struct device_attribute w1_master_attribute_##_name =	\
		__ATTR(w1_master_##_name, _mode,		\
		       w1_master_attribute_show_##_name, NULL)

291 292 293 294 295 296
#define W1_MASTER_ATTR_RW(_name, _mode)				\
	struct device_attribute w1_master_attribute_##_name =	\
		__ATTR(w1_master_##_name, _mode,		\
		       w1_master_attribute_show_##_name,	\
		       w1_master_attribute_store_##_name)

E
Evgeniy Polyakov 已提交
297 298 299 300 301 302 303
static W1_MASTER_ATTR_RO(name, S_IRUGO);
static W1_MASTER_ATTR_RO(slaves, S_IRUGO);
static W1_MASTER_ATTR_RO(slave_count, S_IRUGO);
static W1_MASTER_ATTR_RO(max_slave_count, S_IRUGO);
static W1_MASTER_ATTR_RO(attempts, S_IRUGO);
static W1_MASTER_ATTR_RO(timeout, S_IRUGO);
static W1_MASTER_ATTR_RO(pointer, S_IRUGO);
304
static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUGO);
E
Evgeniy Polyakov 已提交
305 306 307 308 309 310 311 312 313

static struct attribute *w1_master_default_attrs[] = {
	&w1_master_attribute_name.attr,
	&w1_master_attribute_slaves.attr,
	&w1_master_attribute_slave_count.attr,
	&w1_master_attribute_max_slave_count.attr,
	&w1_master_attribute_attempts.attr,
	&w1_master_attribute_timeout.attr,
	&w1_master_attribute_pointer.attr,
314
	&w1_master_attribute_search.attr,
E
Evgeniy Polyakov 已提交
315
	NULL
L
Linus Torvalds 已提交
316 317
};

E
Evgeniy Polyakov 已提交
318 319
static struct attribute_group w1_master_defattr_group = {
	.attrs = w1_master_default_attrs,
L
Linus Torvalds 已提交
320 321
};

E
Evgeniy Polyakov 已提交
322 323 324 325 326 327 328 329 330 331
int w1_create_master_attributes(struct w1_master *master)
{
	return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
}

void w1_destroy_master_attributes(struct w1_master *master)
{
	sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
}

L
Linus Torvalds 已提交
332 333 334 335 336 337 338 339 340 341
static int __w1_attach_slave_device(struct w1_slave *sl)
{
	int err;

	sl->dev.parent = &sl->master->dev;
	sl->dev.driver = sl->master->driver;
	sl->dev.bus = &w1_bus_type;
	sl->dev.release = &w1_slave_release;

	snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),
342 343 344 345 346 347 348
		 "%02x-%012llx",
		 (unsigned int) sl->reg_num.family,
		 (unsigned long long) sl->reg_num.id);
	snprintf(&sl->name[0], sizeof(sl->name),
		 "%02x-%012llx",
		 (unsigned int) sl->reg_num.family,
		 (unsigned long long) sl->reg_num.id);
L
Linus Torvalds 已提交
349 350 351 352 353 354 355

	dev_dbg(&sl->dev, "%s: registering %s.\n", __func__,
		&sl->dev.bus_id[0]);

	err = device_register(&sl->dev);
	if (err < 0) {
		dev_err(&sl->dev,
356 357
			"Device registration [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
L
Linus Torvalds 已提交
358 359 360 361 362
		return err;
	}

	memcpy(&sl->attr_bin, &w1_slave_bin_attribute, sizeof(sl->attr_bin));
	memcpy(&sl->attr_name, &w1_slave_attribute, sizeof(sl->attr_name));
E
Evgeniy Polyakov 已提交
363

L
Linus Torvalds 已提交
364 365 366 367 368 369
	sl->attr_bin.read = sl->family->fops->rbin;
	sl->attr_name.show = sl->family->fops->rname;

	err = device_create_file(&sl->dev, &sl->attr_name);
	if (err < 0) {
		dev_err(&sl->dev,
370 371
			"sysfs file creation for [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
L
Linus Torvalds 已提交
372 373 374 375
		device_unregister(&sl->dev);
		return err;
	}

376 377 378 379 380 381 382 383 384 385
	if ( sl->attr_bin.read ) {
		err = sysfs_create_bin_file(&sl->dev.kobj, &sl->attr_bin);
		if (err < 0) {
			dev_err(&sl->dev,
				"sysfs file creation for [%s] failed. err=%d\n",
				sl->dev.bus_id, err);
			device_remove_file(&sl->dev, &sl->attr_name);
			device_unregister(&sl->dev);
			return err;
		}
L
Linus Torvalds 已提交
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
	}

	list_add_tail(&sl->w1_slave_entry, &sl->master->slist);

	return 0;
}

static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn)
{
	struct w1_slave *sl;
	struct w1_family *f;
	int err;
	struct w1_netlink_msg msg;

	sl = kmalloc(sizeof(struct w1_slave), GFP_KERNEL);
	if (!sl) {
		dev_err(&dev->dev,
			 "%s: failed to allocate new slave device.\n",
			 __func__);
		return -ENOMEM;
	}

	memset(sl, 0, sizeof(*sl));

	sl->owner = THIS_MODULE;
	sl->master = dev;
	set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);

	memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
	atomic_set(&sl->refcnt, 0);
	init_completion(&sl->dev_released);

	spin_lock(&w1_flock);
	f = w1_family_registered(rn->family);
	if (!f) {
421
		f= &w1_default_family;
L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
		dev_info(&dev->dev, "Family %x for %02x.%012llx.%02x is not registered.\n",
			  rn->family, rn->family,
			  (unsigned long long)rn->id, rn->crc);
	}
	__w1_family_get(f);
	spin_unlock(&w1_flock);

	sl->family = f;


	err = __w1_attach_slave_device(sl);
	if (err < 0) {
		dev_err(&dev->dev, "%s: Attaching %s failed.\n", __func__,
			 sl->name);
		w1_family_put(sl->family);
		kfree(sl);
		return err;
	}

	sl->ttl = dev->slave_ttl;
	dev->slave_count++;

	memcpy(&msg.id.id, rn, sizeof(msg.id.id));
	msg.type = W1_SLAVE_ADD;
	w1_netlink_send(dev, &msg);

	return 0;
}

static void w1_slave_detach(struct w1_slave *sl)
{
	struct w1_netlink_msg msg;
E
Evgeniy Polyakov 已提交
454

L
Linus Torvalds 已提交
455 456 457 458 459 460 461 462 463 464
	dev_info(&sl->dev, "%s: detaching %s.\n", __func__, sl->name);

	while (atomic_read(&sl->refcnt)) {
		printk(KERN_INFO "Waiting for %s to become free: refcnt=%d.\n",
				sl->name, atomic_read(&sl->refcnt));

		if (msleep_interruptible(1000))
			flush_signals(current);
	}

465 466 467
	if ( sl->attr_bin.read ) {
		sysfs_remove_bin_file (&sl->dev.kobj, &sl->attr_bin);
	}
L
Linus Torvalds 已提交
468 469 470 471
	device_remove_file(&sl->dev, &sl->attr_name);
	device_unregister(&sl->dev);
	w1_family_put(sl->family);

472 473
	sl->master->slave_count--;

L
Linus Torvalds 已提交
474 475 476 477 478 479 480 481 482
	memcpy(&msg.id.id, &sl->reg_num, sizeof(msg.id.id));
	msg.type = W1_SLAVE_REMOVE;
	w1_netlink_send(sl->master, &msg);
}

static struct w1_master *w1_search_master(unsigned long data)
{
	struct w1_master *dev;
	int found = 0;
E
Evgeniy Polyakov 已提交
483 484

	spin_lock_bh(&w1_mlock);
L
Linus Torvalds 已提交
485 486 487 488 489 490 491
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
		if (dev->bus_master->data == data) {
			found = 1;
			atomic_inc(&dev->refcnt);
			break;
		}
	}
E
Evgeniy Polyakov 已提交
492
	spin_unlock_bh(&w1_mlock);
L
Linus Torvalds 已提交
493 494 495 496

	return (found)?dev:NULL;
}

497 498 499 500 501 502 503 504 505 506 507 508 509 510
void w1_reconnect_slaves(struct w1_family *f)
{
	struct w1_master *dev;

	spin_lock_bh(&w1_mlock);
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
		dev_info(&dev->dev, "Reconnecting slaves in %s into new family %02x.\n",
				dev->name, f->fid);
		set_bit(W1_MASTER_NEED_RECONNECT, &dev->flags);
	}
	spin_unlock_bh(&w1_mlock);
}


E
Evgeniy Polyakov 已提交
511
static void w1_slave_found(unsigned long data, u64 rn)
L
Linus Torvalds 已提交
512 513 514 515 516 517 518 519 520 521 522 523 524 525
{
	int slave_count;
	struct w1_slave *sl;
	struct list_head *ent;
	struct w1_reg_num *tmp;
	int family_found = 0;
	struct w1_master *dev;

	dev = w1_search_master(data);
	if (!dev) {
		printk(KERN_ERR "Failed to find w1 master device for data %08lx, it is impossible.\n",
				data);
		return;
	}
E
Evgeniy Polyakov 已提交
526

L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534 535 536 537 538
	tmp = (struct w1_reg_num *) &rn;

	slave_count = 0;
	list_for_each(ent, &dev->slist) {

		sl = list_entry(ent, struct w1_slave, w1_slave_entry);

		if (sl->reg_num.family == tmp->family &&
		    sl->reg_num.id == tmp->id &&
		    sl->reg_num.crc == tmp->crc) {
			set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
			break;
E
Evgeniy Polyakov 已提交
539
		} else if (sl->reg_num.family == tmp->family) {
L
Linus Torvalds 已提交
540 541 542 543 544 545 546
			family_found = 1;
			break;
		}

		slave_count++;
	}

547 548 549 550 551
	rn = cpu_to_le64(rn);

	if (slave_count == dev->slave_count &&
		rn && ((le64_to_cpu(rn) >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn, 7)) {
		w1_attach_slave_device(dev, tmp);
L
Linus Torvalds 已提交
552
	}
E
Evgeniy Polyakov 已提交
553

L
Linus Torvalds 已提交
554 555 556
	atomic_dec(&dev->refcnt);
}

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
/**
 * Performs a ROM Search & registers any devices found.
 * The 1-wire search is a simple binary tree search.
 * For each bit of the address, we read two bits and write one bit.
 * The bit written will put to sleep all devies that don't match that bit.
 * When the two reads differ, the direction choice is obvious.
 * When both bits are 0, we must choose a path to take.
 * When we can scan all 64 bits without having to choose a path, we are done.
 *
 * See "Application note 187 1-wire search algorithm" at www.maxim-ic.com
 *
 * @dev        The master device to search
 * @cb         Function to call when a device is found
 */
void w1_search(struct w1_master *dev, w1_slave_found_callback cb)
L
Linus Torvalds 已提交
572
{
573 574 575 576 577
	u64 last_rn, rn, tmp64;
	int i, slave_count = 0;
	int last_zero, last_device;
	int search_bit, desc_bit;
	u8  triplet_ret = 0;
L
Linus Torvalds 已提交
578

579 580 581 582
	search_bit = 0;
	rn = last_rn = 0;
	last_device = 0;
	last_zero = -1;
L
Linus Torvalds 已提交
583 584 585

	desc_bit = 64;

586 587
	while ( !last_device && (slave_count++ < dev->max_slave_count) ) {
		last_rn = rn;
L
Linus Torvalds 已提交
588 589 590 591 592 593 594 595 596 597 598 599 600
		rn = 0;

		/*
		 * Reset bus and all 1-wire device state machines
		 * so they can respond to our requests.
		 *
		 * Return 0 - device(s) present, 1 - no devices present.
		 */
		if (w1_reset_bus(dev)) {
			dev_info(&dev->dev, "No devices present on the wire.\n");
			break;
		}

601
		/* Start the search */
L
Linus Torvalds 已提交
602 603
		w1_write_8(dev, W1_SEARCH);
		for (i = 0; i < 64; ++i) {
604 605 606 607 608
			/* Determine the direction/search bit */
			if (i == desc_bit)
				search_bit = 1;	  /* took the 0 path last time, so take the 1 path */
			else if (i > desc_bit)
				search_bit = 0;	  /* take the 0 path on the next branch */
L
Linus Torvalds 已提交
609
			else
610
				search_bit = ((last_rn >> i) & 0x1);
L
Linus Torvalds 已提交
611

612 613 614 615 616 617
			/** Read two bits and write one bit */
			triplet_ret = w1_triplet(dev, search_bit);

			/* quit if no device responded */
			if ( (triplet_ret & 0x03) == 0x03 )
				break;
L
Linus Torvalds 已提交
618

619 620 621
			/* If both directions were valid, and we took the 0 path... */
			if (triplet_ret == 0)
				last_zero = i;
L
Linus Torvalds 已提交
622

623 624 625 626
			/* extract the direction taken & update the device number */
			tmp64 = (triplet_ret >> 2);
			rn |= (tmp64 << i);
		}
E
Evgeniy Polyakov 已提交
627

628 629 630 631 632 633
		if ( (triplet_ret & 0x03) != 0x03 ) {
			if ( (desc_bit == last_zero) || (last_zero < 0))
				last_device = 1;
			desc_bit = last_zero;
			cb(dev->bus_master->data, rn);
		}
L
Linus Torvalds 已提交
634 635 636
	}
}

E
Evgeniy Polyakov 已提交
637
static int w1_control(void *data)
L
Linus Torvalds 已提交
638
{
E
Evgeniy Polyakov 已提交
639 640
	struct w1_slave *sl, *sln;
	struct w1_master *dev, *n;
L
Linus Torvalds 已提交
641 642 643 644 645 646 647 648
	int err, have_to_wait = 0;

	daemonize("w1_control");
	allow_signal(SIGTERM);

	while (!control_needs_exit || have_to_wait) {
		have_to_wait = 0;

649
		try_to_freeze();
L
Linus Torvalds 已提交
650 651 652 653 654
		msleep_interruptible(w1_timeout * 1000);

		if (signal_pending(current))
			flush_signals(current);

E
Evgeniy Polyakov 已提交
655
		list_for_each_entry_safe(dev, n, &w1_masters, w1_master_entry) {
656
			if (!control_needs_exit && !dev->flags)
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667
				continue;
			/*
			 * Little race: we can create thread but not set the flag.
			 * Get a chance for external process to set flag up.
			 */
			if (!dev->initialized) {
				have_to_wait = 1;
				continue;
			}

			if (control_needs_exit) {
668
				set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
L
Linus Torvalds 已提交
669 670 671 672 673 674 675 676

				err = kill_proc(dev->kpid, SIGTERM, 1);
				if (err)
					dev_err(&dev->dev,
						 "Failed to send signal to w1 kernel thread %d.\n",
						 dev->kpid);
			}

677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
			if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
				wait_for_completion(&dev->dev_exited);
				spin_lock_bh(&w1_mlock);
				list_del(&dev->w1_master_entry);
				spin_unlock_bh(&w1_mlock);

				list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
					list_del(&sl->w1_slave_entry);

					w1_slave_detach(sl);
					kfree(sl);
				}
				w1_destroy_master_attributes(dev);
				atomic_dec(&dev->refcnt);
				continue;
			}

			if (test_bit(W1_MASTER_NEED_RECONNECT, &dev->flags)) {
				dev_info(&dev->dev, "Reconnecting slaves in device %s.\n", dev->name);
				down(&dev->mutex);
				list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
					if (sl->family->fid == W1_FAMILY_DEFAULT) {
						struct w1_reg_num rn;
						list_del(&sl->w1_slave_entry);
						w1_slave_detach(sl);

						memcpy(&rn, &sl->reg_num, sizeof(rn));
L
Linus Torvalds 已提交
704

705
						kfree(sl);
L
Linus Torvalds 已提交
706

707 708 709 710 711
						w1_attach_slave_device(dev, &rn);
					}
				}
				clear_bit(W1_MASTER_NEED_RECONNECT, &dev->flags);
				up(&dev->mutex);
L
Linus Torvalds 已提交
712 713 714 715 716 717 718 719 720 721
			}
		}
	}

	complete_and_exit(&w1_control_complete, 0);
}

int w1_process(void *data)
{
	struct w1_master *dev = (struct w1_master *) data;
E
Evgeniy Polyakov 已提交
722
	struct w1_slave *sl, *sln;
L
Linus Torvalds 已提交
723 724 725 726

	daemonize("%s", dev->name);
	allow_signal(SIGTERM);

727
	while (!test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
728
		try_to_freeze();
L
Linus Torvalds 已提交
729 730 731 732 733
		msleep_interruptible(w1_timeout * 1000);

		if (signal_pending(current))
			flush_signals(current);

734
		if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags))
L
Linus Torvalds 已提交
735 736 737 738 739
			break;

		if (!dev->initialized)
			continue;

740 741 742
		if (dev->search_count == 0)
			continue;

L
Linus Torvalds 已提交
743 744 745
		if (down_interruptible(&dev->mutex))
			continue;

E
Evgeniy Polyakov 已提交
746
		list_for_each_entry(sl, &dev->slist, w1_slave_entry)
747
			clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
L
Linus Torvalds 已提交
748

E
Evgeniy Polyakov 已提交
749
		w1_search_devices(dev, w1_slave_found);
L
Linus Torvalds 已提交
750

E
Evgeniy Polyakov 已提交
751 752
		list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
			if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl) {
L
Linus Torvalds 已提交
753 754 755 756 757 758
				list_del (&sl->w1_slave_entry);

				w1_slave_detach (sl);
				kfree (sl);

				dev->slave_count--;
E
Evgeniy Polyakov 已提交
759
			} else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
L
Linus Torvalds 已提交
760 761
				sl->ttl = dev->slave_ttl;
		}
762 763 764 765

		if (dev->search_count > 0)
			dev->search_count--;

L
Linus Torvalds 已提交
766 767 768 769 770 771 772 773 774
		up(&dev->mutex);
	}

	atomic_dec(&dev->refcnt);
	complete_and_exit(&dev->dev_exited, 0);

	return 0;
}

E
Evgeniy Polyakov 已提交
775
static int w1_init(void)
L
Linus Torvalds 已提交
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
{
	int retval;

	printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n");

	retval = bus_register(&w1_bus_type);
	if (retval) {
		printk(KERN_ERR "Failed to register bus. err=%d.\n", retval);
		goto err_out_exit_init;
	}

	retval = driver_register(&w1_driver);
	if (retval) {
		printk(KERN_ERR
			"Failed to register master driver. err=%d.\n",
			retval);
		goto err_out_bus_unregister;
	}

	control_thread = kernel_thread(&w1_control, NULL, 0);
	if (control_thread < 0) {
		printk(KERN_ERR "Failed to create control thread. err=%d\n",
			control_thread);
		retval = control_thread;
		goto err_out_driver_unregister;
	}

	return 0;

err_out_driver_unregister:
	driver_unregister(&w1_driver);

err_out_bus_unregister:
	bus_unregister(&w1_bus_type);

err_out_exit_init:
	return retval;
}

E
Evgeniy Polyakov 已提交
815
static void w1_fini(void)
L
Linus Torvalds 已提交
816 817 818
{
	struct w1_master *dev;

E
Evgeniy Polyakov 已提交
819
	list_for_each_entry(dev, &w1_masters, w1_master_entry)
L
Linus Torvalds 已提交
820 821 822 823 824 825 826 827 828 829 830
		__w1_remove_master_device(dev);

	control_needs_exit = 1;
	wait_for_completion(&w1_control_complete);

	driver_unregister(&w1_driver);
	bus_unregister(&w1_bus_type);
}

module_init(w1_init);
module_exit(w1_fini);