w1.c 22.5 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
 *
 * 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>
E
Evgeniy Polyakov 已提交
33
#include <linux/kthread.h>
34
#include <linux/freezer.h>
L
Linus Torvalds 已提交
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#include <asm/atomic.h>

#include "w1.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);

56
DEFINE_MUTEX(w1_mlock);
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70
LIST_HEAD(w1_masters);

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 void w1_master_release(struct device *dev)
{
71
	struct w1_master *md = dev_to_w1_master(dev);
72 73 74 75

	dev_dbg(dev, "%s: Releasing %s.\n", __func__, md->name);
	memset(md, 0, sizeof(struct w1_master) + sizeof(struct w1_bus_master));
	kfree(md);
L
Linus Torvalds 已提交
76 77 78 79
}

static void w1_slave_release(struct device *dev)
{
80
	struct w1_slave *sl = dev_to_w1_slave(dev);
81

82
	printk("%s: Releasing %s.\n", __func__, sl->name);
83 84

	while (atomic_read(&sl->refcnt)) {
85
		printk("Waiting for %s to become free: refcnt=%d.\n",
86 87 88 89 90 91 92 93 94
				sl->name, atomic_read(&sl->refcnt));
		if (msleep_interruptible(1000))
			flush_signals(current);
	}

	w1_family_put(sl->family);
	sl->master->slave_count--;

	complete(&sl->released);
L
Linus Torvalds 已提交
95 96
}

97
static ssize_t w1_slave_read_name(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
98
{
99
	struct w1_slave *sl = dev_to_w1_slave(dev);
100

101
	return sprintf(buf, "%s\n", sl->name);
L
Linus Torvalds 已提交
102 103
}

104 105 106
static ssize_t w1_slave_read_id(struct kobject *kobj,
				struct bin_attribute *bin_attr,
				char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
107
{
108
	struct w1_slave *sl = kobj_to_w1_slave(kobj);
L
Linus Torvalds 已提交
109

110 111
	if (off > 8) {
		count = 0;
112 113 114 115 116 117 118 119
	} else {
		if (off + count > 8)
			count = 8 - off;

		memcpy(buf, (u8 *)&sl->reg_num, count);
	}

	return count;
120
}
121 122 123 124 125 126 127 128 129 130 131

static struct device_attribute w1_slave_attr_name =
	__ATTR(name, S_IRUGO, w1_slave_read_name, NULL);

static struct bin_attribute w1_slave_attr_bin_id = {
      .attr = {
              .name = "id",
              .mode = S_IRUGO,
      },
      .size = 8,
      .read = w1_slave_read_id,
E
Evgeniy Polyakov 已提交
132 133
};

134
/* Default family */
135

136 137 138
static ssize_t w1_default_write(struct kobject *kobj,
				struct bin_attribute *bin_attr,
				char *buf, loff_t off, size_t count)
139 140 141
{
	struct w1_slave *sl = kobj_to_w1_slave(kobj);

142
	mutex_lock(&sl->master->mutex);
143 144 145 146 147 148 149 150
	if (w1_reset_select_slave(sl)) {
		count = 0;
		goto out_up;
	}

	w1_write_block(sl->master, buf, count);

out_up:
151
	mutex_unlock(&sl->master->mutex);
152 153 154
	return count;
}

155 156 157
static ssize_t w1_default_read(struct kobject *kobj,
			       struct bin_attribute *bin_attr,
			       char *buf, loff_t off, size_t count)
158 159 160
{
	struct w1_slave *sl = kobj_to_w1_slave(kobj);

161
	mutex_lock(&sl->master->mutex);
162
	w1_read_block(sl->master, buf, count);
163
	mutex_unlock(&sl->master->mutex);
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
	return count;
}

static struct bin_attribute w1_default_attr = {
      .attr = {
              .name = "rw",
              .mode = S_IRUGO | S_IWUSR,
      },
      .size = PAGE_SIZE,
      .read = w1_default_read,
      .write = w1_default_write,
};

static int w1_default_add_slave(struct w1_slave *sl)
{
	return sysfs_create_bin_file(&sl->dev.kobj, &w1_default_attr);
}

static void w1_default_remove_slave(struct w1_slave *sl)
{
	sysfs_remove_bin_file(&sl->dev.kobj, &w1_default_attr);
}

static struct w1_family_ops w1_default_fops = {
	.add_slave	= w1_default_add_slave,
	.remove_slave	= w1_default_remove_slave,
};

static struct w1_family w1_default_family = {
	.fops = &w1_default_fops,
};
195

196
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env);
E
Evgeniy Polyakov 已提交
197

L
Linus Torvalds 已提交
198 199 200
static struct bus_type w1_bus_type = {
	.name = "w1",
	.match = w1_master_match,
201
	.uevent = w1_uevent,
L
Linus Torvalds 已提交
202 203
};

E
Evgeniy Polyakov 已提交
204 205
struct device_driver w1_master_driver = {
	.name = "w1_master_driver",
L
Linus Torvalds 已提交
206 207 208 209
	.bus = &w1_bus_type,
	.probe = w1_master_probe,
};

E
Evgeniy Polyakov 已提交
210
struct device w1_master_device = {
L
Linus Torvalds 已提交
211 212 213
	.parent = NULL,
	.bus = &w1_bus_type,
	.bus_id = "w1 bus master",
E
Evgeniy Polyakov 已提交
214
	.driver = &w1_master_driver,
L
Linus Torvalds 已提交
215 216 217
	.release = &w1_master_release
};

E
Evgeniy Polyakov 已提交
218
static struct device_driver w1_slave_driver = {
E
Evgeniy Polyakov 已提交
219 220 221 222
	.name = "w1_slave_driver",
	.bus = &w1_bus_type,
};

E
Evgeniy Polyakov 已提交
223
#if 0
E
Evgeniy Polyakov 已提交
224 225 226 227 228
struct device w1_slave_device = {
	.parent = NULL,
	.bus = &w1_bus_type,
	.bus_id = "w1 bus slave",
	.driver = &w1_slave_driver,
229
	.release = &w1_slave_release
E
Evgeniy Polyakov 已提交
230
};
E
Evgeniy Polyakov 已提交
231
#endif  /*  0  */
E
Evgeniy Polyakov 已提交
232

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

238
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
239
	count = sprintf(buf, "%s\n", md->name);
240
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
241 242 243 244

	return count;
}

245 246 247 248
static ssize_t w1_master_attribute_store_search(struct device * dev,
						struct device_attribute *attr,
						const char * buf, size_t count)
{
249
	long tmp;
250
	struct w1_master *md = dev_to_w1_master(dev);
251

252 253 254
	if (strict_strtol(buf, 0, &tmp) == -EINVAL)
		return -EINVAL;

255
	mutex_lock(&md->mutex);
256
	md->search_count = tmp;
257
	mutex_unlock(&md->mutex);
D
David Fries 已提交
258
	wake_up_process(md->thread);
259 260 261 262 263 264 265 266

	return count;
}

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

270
	mutex_lock(&md->mutex);
271
	count = sprintf(buf, "%d\n", md->search_count);
272
	mutex_unlock(&md->mutex);
273 274 275 276

	return count;
}

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
static ssize_t w1_master_attribute_store_pullup(struct device *dev,
						struct device_attribute *attr,
						const char *buf, size_t count)
{
	long tmp;
	struct w1_master *md = dev_to_w1_master(dev);

	if (strict_strtol(buf, 0, &tmp) == -EINVAL)
		return -EINVAL;

	mutex_lock(&md->mutex);
	md->enable_pullup = tmp;
	mutex_unlock(&md->mutex);
	wake_up_process(md->thread);

	return count;
}

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

	mutex_lock(&md->mutex);
	count = sprintf(buf, "%d\n", md->enable_pullup);
	mutex_unlock(&md->mutex);

	return count;
}

309
static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
310
{
311
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
312
	ssize_t count;
E
Evgeniy Polyakov 已提交
313

314
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
315
	count = sprintf(buf, "0x%p\n", md->bus_master);
316
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
317 318 319
	return count;
}

320
static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
321 322 323 324 325 326
{
	ssize_t count;
	count = sprintf(buf, "%d\n", w1_timeout);
	return count;
}

327
static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
328
{
329
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
330
	ssize_t count;
E
Evgeniy Polyakov 已提交
331

332
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
333
	count = sprintf(buf, "%d\n", md->max_slave_count);
334
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
335 336 337
	return count;
}

338
static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
339
{
340
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
341
	ssize_t count;
E
Evgeniy Polyakov 已提交
342

343
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
344
	count = sprintf(buf, "%lu\n", md->attempts);
345
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
346 347 348
	return count;
}

349
static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
350
{
351
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
352
	ssize_t count;
E
Evgeniy Polyakov 已提交
353

354
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
355
	count = sprintf(buf, "%d\n", md->slave_count);
356
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
357 358 359
	return count;
}

360
static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
361
{
362
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
363 364
	int c = PAGE_SIZE;

365
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
366 367 368 369 370 371 372 373 374 375

	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 已提交
376
			c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name);
L
Linus Torvalds 已提交
377 378 379
		}
	}

380
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
381 382 383 384

	return PAGE_SIZE - c;
}

E
Evgeniy Polyakov 已提交
385 386 387 388 389
#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)

390 391 392 393 394 395
#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 已提交
396 397 398 399 400 401 402
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);
403
static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUGO);
404
static W1_MASTER_ATTR_RW(pullup, S_IRUGO | S_IWUGO);
E
Evgeniy Polyakov 已提交
405 406 407 408 409 410 411 412 413

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,
414
	&w1_master_attribute_search.attr,
415
	&w1_master_attribute_pullup.attr,
E
Evgeniy Polyakov 已提交
416
	NULL
L
Linus Torvalds 已提交
417 418
};

E
Evgeniy Polyakov 已提交
419 420
static struct attribute_group w1_master_defattr_group = {
	.attrs = w1_master_default_attrs,
L
Linus Torvalds 已提交
421 422
};

E
Evgeniy Polyakov 已提交
423 424 425 426 427
int w1_create_master_attributes(struct w1_master *master)
{
	return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
}

428
void w1_destroy_master_attributes(struct w1_master *master)
E
Evgeniy Polyakov 已提交
429 430 431 432
{
	sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
}

E
Evgeniy Polyakov 已提交
433
#ifdef CONFIG_HOTPLUG
434
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
E
Evgeniy Polyakov 已提交
435 436 437 438
{
	struct w1_master *md = NULL;
	struct w1_slave *sl = NULL;
	char *event_owner, *name;
439
	int err;
E
Evgeniy Polyakov 已提交
440 441 442 443 444 445 446 447 448 449

	if (dev->driver == &w1_master_driver) {
		md = container_of(dev, struct w1_master, dev);
		event_owner = "master";
		name = md->name;
	} else if (dev->driver == &w1_slave_driver) {
		sl = container_of(dev, struct w1_slave, dev);
		event_owner = "slave";
		name = sl->name;
	} else {
450
		dev_dbg(dev, "Unknown event.\n");
E
Evgeniy Polyakov 已提交
451 452 453
		return -EINVAL;
	}

A
Andrew Morton 已提交
454 455
	dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
			event_owner, name, dev->bus_id);
E
Evgeniy Polyakov 已提交
456 457 458 459

	if (dev->driver != &w1_slave_driver || !sl)
		return 0;

460
	err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);
E
Evgeniy Polyakov 已提交
461 462 463
	if (err)
		return err;

464 465
	err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",
			     (unsigned long long)sl->reg_num.id);
E
Evgeniy Polyakov 已提交
466 467 468 469 470 471
	if (err)
		return err;

	return 0;
};
#else
472
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
E
Evgeniy Polyakov 已提交
473 474 475 476 477
{
	return 0;
}
#endif

L
Linus Torvalds 已提交
478 479 480 481 482
static int __w1_attach_slave_device(struct w1_slave *sl)
{
	int err;

	sl->dev.parent = &sl->master->dev;
E
Evgeniy Polyakov 已提交
483
	sl->dev.driver = &w1_slave_driver;
L
Linus Torvalds 已提交
484 485 486 487
	sl->dev.bus = &w1_bus_type;
	sl->dev.release = &w1_slave_release;

	snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),
488 489 490 491 492 493 494
		 "%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 已提交
495

A
Andrew Morton 已提交
496
	dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
E
Evgeniy Polyakov 已提交
497
		&sl->dev.bus_id[0], sl);
L
Linus Torvalds 已提交
498 499 500 501

	err = device_register(&sl->dev);
	if (err < 0) {
		dev_err(&sl->dev,
502 503
			"Device registration [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
L
Linus Torvalds 已提交
504 505 506
		return err;
	}

507 508 509 510 511 512 513 514
	/* Create "name" entry */
	err = device_create_file(&sl->dev, &w1_slave_attr_name);
	if (err < 0) {
		dev_err(&sl->dev,
			"sysfs file creation for [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
		goto out_unreg;
	}
L
Linus Torvalds 已提交
515

516 517
	/* Create "id" entry */
	err = sysfs_create_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id);
L
Linus Torvalds 已提交
518 519
	if (err < 0) {
		dev_err(&sl->dev,
520 521
			"sysfs file creation for [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
522
		goto out_rem1;
L
Linus Torvalds 已提交
523 524
	}

525 526 527 528 529 530 531
	/* if the family driver needs to initialize something... */
	if (sl->family->fops && sl->family->fops->add_slave &&
	    ((err = sl->family->fops->add_slave(sl)) < 0)) {
		dev_err(&sl->dev,
			"sysfs file creation for [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
		goto out_rem2;
L
Linus Torvalds 已提交
532 533 534 535 536
	}

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

	return 0;
537 538 539 540 541 542 543 544

out_rem2:
	sysfs_remove_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id);
out_rem1:
	device_remove_file(&sl->dev, &w1_slave_attr_name);
out_unreg:
	device_unregister(&sl->dev);
	return err;
L
Linus Torvalds 已提交
545 546 547 548 549 550 551 552 553
}

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;

554
	sl = kzalloc(sizeof(struct w1_slave), GFP_KERNEL);
L
Linus Torvalds 已提交
555 556 557 558 559 560 561 562 563 564 565 566
	if (!sl) {
		dev_err(&dev->dev,
			 "%s: failed to allocate new slave device.\n",
			 __func__);
		return -ENOMEM;
	}


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

567
	memset(&msg, 0, sizeof(msg));
L
Linus Torvalds 已提交
568 569
	memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
	atomic_set(&sl->refcnt, 0);
570
	init_completion(&sl->released);
L
Linus Torvalds 已提交
571 572 573 574

	spin_lock(&w1_flock);
	f = w1_family_registered(rn->family);
	if (!f) {
575
		f= &w1_default_family;
L
Linus Torvalds 已提交
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
		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++;

598
	memcpy(msg.id.id, rn, sizeof(msg.id));
L
Linus Torvalds 已提交
599 600 601 602 603 604
	msg.type = W1_SLAVE_ADD;
	w1_netlink_send(dev, &msg);

	return 0;
}

605
void w1_slave_detach(struct w1_slave *sl)
L
Linus Torvalds 已提交
606 607
{
	struct w1_netlink_msg msg;
E
Evgeniy Polyakov 已提交
608

609
	dev_dbg(&sl->dev, "%s: detaching %s [%p].\n", __func__, sl->name, sl);
L
Linus Torvalds 已提交
610

611
	list_del(&sl->w1_slave_entry);
L
Linus Torvalds 已提交
612

613 614 615
	if (sl->family->fops && sl->family->fops->remove_slave)
		sl->family->fops->remove_slave(sl);

616 617
	memset(&msg, 0, sizeof(msg));
	memcpy(msg.id.id, &sl->reg_num, sizeof(msg.id));
618 619 620
	msg.type = W1_SLAVE_REMOVE;
	w1_netlink_send(sl->master, &msg);

621 622
	sysfs_remove_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id);
	device_remove_file(&sl->dev, &w1_slave_attr_name);
L
Linus Torvalds 已提交
623 624
	device_unregister(&sl->dev);

625 626
	wait_for_completion(&sl->released);
	kfree(sl);
L
Linus Torvalds 已提交
627 628
}

629 630 631 632 633
struct w1_master *w1_search_master_id(u32 id)
{
	struct w1_master *dev;
	int found = 0;

634
	mutex_lock(&w1_mlock);
635 636 637 638 639 640 641
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
		if (dev->id == id) {
			found = 1;
			atomic_inc(&dev->refcnt);
			break;
		}
	}
642
	mutex_unlock(&w1_mlock);
643 644 645 646 647 648 649 650 651 652

	return (found)?dev:NULL;
}

struct w1_slave *w1_search_slave(struct w1_reg_num *id)
{
	struct w1_master *dev;
	struct w1_slave *sl = NULL;
	int found = 0;

653
	mutex_lock(&w1_mlock);
654
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
655
		mutex_lock(&dev->mutex);
656 657 658 659 660 661 662 663 664 665
		list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
			if (sl->reg_num.family == id->family &&
					sl->reg_num.id == id->id &&
					sl->reg_num.crc == id->crc) {
				found = 1;
				atomic_inc(&dev->refcnt);
				atomic_inc(&sl->refcnt);
				break;
			}
		}
666
		mutex_unlock(&dev->mutex);
667 668 669 670

		if (found)
			break;
	}
671
	mutex_unlock(&w1_mlock);
672 673 674 675

	return (found)?sl:NULL;
}

676
void w1_reconnect_slaves(struct w1_family *f, int attach)
677
{
678
	struct w1_slave *sl, *sln;
679 680
	struct w1_master *dev;

681
	mutex_lock(&w1_mlock);
682
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
		dev_dbg(&dev->dev, "Reconnecting slaves in device %s "
			"for family %02x.\n", dev->name, f->fid);
		mutex_lock(&dev->mutex);
		list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
			/* If it is a new family, slaves with the default
			 * family driver and are that family will be
			 * connected.  If the family is going away, devices
			 * matching that family are reconneced.
			 */
			if ((attach && sl->family->fid == W1_FAMILY_DEFAULT
				&& sl->reg_num.family == f->fid) ||
				(!attach && sl->family->fid == f->fid)) {
				struct w1_reg_num rn;

				memcpy(&rn, &sl->reg_num, sizeof(rn));
				w1_slave_detach(sl);

				w1_attach_slave_device(dev, &rn);
			}
		}
		dev_dbg(&dev->dev, "Reconnecting slaves in device %s "
			"has been finished.\n", dev->name);
		mutex_unlock(&dev->mutex);
706
	}
707
	mutex_unlock(&w1_mlock);
708 709
}

710
static void w1_slave_found(struct w1_master *dev, u64 rn)
L
Linus Torvalds 已提交
711 712 713 714 715
{
	int slave_count;
	struct w1_slave *sl;
	struct list_head *ent;
	struct w1_reg_num *tmp;
716
	u64 rn_le = cpu_to_le64(rn);
L
Linus Torvalds 已提交
717

718
	atomic_inc(&dev->refcnt);
E
Evgeniy Polyakov 已提交
719

L
Linus Torvalds 已提交
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
	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;
		}

		slave_count++;
	}

737
	if (slave_count == dev->slave_count &&
738
		rn && ((rn >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn_le, 7)) {
739
		w1_attach_slave_device(dev, tmp);
L
Linus Torvalds 已提交
740
	}
E
Evgeniy Polyakov 已提交
741

L
Linus Torvalds 已提交
742 743 744
	atomic_dec(&dev->refcnt);
}

745 746 747 748 749 750 751 752 753 754 755 756 757 758
/**
 * 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
 */
759
void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
L
Linus Torvalds 已提交
760
{
761 762 763 764 765
	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 已提交
766

767 768 769 770
	search_bit = 0;
	rn = last_rn = 0;
	last_device = 0;
	last_zero = -1;
L
Linus Torvalds 已提交
771 772 773

	desc_bit = 64;

774 775
	while ( !last_device && (slave_count++ < dev->max_slave_count) ) {
		last_rn = rn;
L
Linus Torvalds 已提交
776 777 778 779 780 781 782 783 784
		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)) {
785
			dev_dbg(&dev->dev, "No devices present on the wire.\n");
L
Linus Torvalds 已提交
786 787 788
			break;
		}

789
		/* Start the search */
790
		w1_write_8(dev, search_type);
L
Linus Torvalds 已提交
791
		for (i = 0; i < 64; ++i) {
792 793 794 795 796
			/* 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 已提交
797
			else
798
				search_bit = ((last_rn >> i) & 0x1);
L
Linus Torvalds 已提交
799

800 801 802 803 804 805
			/** 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 已提交
806

807 808 809
			/* If both directions were valid, and we took the 0 path... */
			if (triplet_ret == 0)
				last_zero = i;
L
Linus Torvalds 已提交
810

811 812 813
			/* extract the direction taken & update the device number */
			tmp64 = (triplet_ret >> 2);
			rn |= (tmp64 << i);
D
David Fries 已提交
814

D
David Fries 已提交
815
			if (kthread_should_stop()) {
D
David Fries 已提交
816 817 818
				printk(KERN_INFO "Abort w1_search (exiting)\n");
				return;
			}
819
		}
E
Evgeniy Polyakov 已提交
820

821 822 823 824
		if ( (triplet_ret & 0x03) != 0x03 ) {
			if ( (desc_bit == last_zero) || (last_zero < 0))
				last_device = 1;
			desc_bit = last_zero;
825
			cb(dev, rn);
826
		}
L
Linus Torvalds 已提交
827 828 829
	}
}

830 831 832 833 834 835 836 837 838 839
void w1_search_process(struct w1_master *dev, u8 search_type)
{
	struct w1_slave *sl, *sln;

	list_for_each_entry(sl, &dev->slist, w1_slave_entry)
		clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);

	w1_search_devices(dev, search_type, w1_slave_found);

	list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
840
		if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl)
841
			w1_slave_detach(sl);
842
		else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
843 844 845 846 847 848 849
			sl->ttl = dev->slave_ttl;
	}

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

L
Linus Torvalds 已提交
850 851 852
int w1_process(void *data)
{
	struct w1_master *dev = (struct w1_master *) data;
D
David Fries 已提交
853 854 855 856
	/* As long as w1_timeout is only set by a module parameter the sleep
	 * time can be calculated in jiffies once.
	 */
	const unsigned long jtime = msecs_to_jiffies(w1_timeout * 1000);
L
Linus Torvalds 已提交
857

D
David Fries 已提交
858
	while (!kthread_should_stop()) {
D
David Fries 已提交
859 860 861 862 863 864
		if (dev->search_count) {
			mutex_lock(&dev->mutex);
			w1_search_process(dev, W1_SEARCH);
			mutex_unlock(&dev->mutex);
		}

865
		try_to_freeze();
D
David Fries 已提交
866 867 868 869 870 871 872 873 874 875
		__set_current_state(TASK_INTERRUPTIBLE);

		if (kthread_should_stop())
			break;

		/* Only sleep when the search is active. */
		if (dev->search_count)
			schedule_timeout(jtime);
		else
			schedule();
L
Linus Torvalds 已提交
876 877 878 879 880 881 882
	}

	atomic_dec(&dev->refcnt);

	return 0;
}

E
Evgeniy Polyakov 已提交
883
static int w1_init(void)
L
Linus Torvalds 已提交
884 885 886 887 888
{
	int retval;

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

889 890
	w1_init_netlink();

L
Linus Torvalds 已提交
891 892 893 894 895 896
	retval = bus_register(&w1_bus_type);
	if (retval) {
		printk(KERN_ERR "Failed to register bus. err=%d.\n", retval);
		goto err_out_exit_init;
	}

E
Evgeniy Polyakov 已提交
897
	retval = driver_register(&w1_master_driver);
L
Linus Torvalds 已提交
898 899 900 901 902 903 904
	if (retval) {
		printk(KERN_ERR
			"Failed to register master driver. err=%d.\n",
			retval);
		goto err_out_bus_unregister;
	}

E
Evgeniy Polyakov 已提交
905 906 907 908 909 910 911 912
	retval = driver_register(&w1_slave_driver);
	if (retval) {
		printk(KERN_ERR
			"Failed to register master driver. err=%d.\n",
			retval);
		goto err_out_master_unregister;
	}

L
Linus Torvalds 已提交
913 914
	return 0;

915 916
#if 0
/* For undoing the slave register if there was a step after it. */
E
Evgeniy Polyakov 已提交
917 918
err_out_slave_unregister:
	driver_unregister(&w1_slave_driver);
919
#endif
E
Evgeniy Polyakov 已提交
920 921 922

err_out_master_unregister:
	driver_unregister(&w1_master_driver);
L
Linus Torvalds 已提交
923 924 925 926 927 928 929 930

err_out_bus_unregister:
	bus_unregister(&w1_bus_type);

err_out_exit_init:
	return retval;
}

E
Evgeniy Polyakov 已提交
931
static void w1_fini(void)
L
Linus Torvalds 已提交
932 933 934
{
	struct w1_master *dev;

935
	/* Set netlink removal messages and some cleanup */
E
Evgeniy Polyakov 已提交
936
	list_for_each_entry(dev, &w1_masters, w1_master_entry)
L
Linus Torvalds 已提交
937 938
		__w1_remove_master_device(dev);

939 940
	w1_fini_netlink();

E
Evgeniy Polyakov 已提交
941 942
	driver_unregister(&w1_slave_driver);
	driver_unregister(&w1_master_driver);
L
Linus Torvalds 已提交
943 944 945 946 947
	bus_unregister(&w1_bus_type);
}

module_init(w1_init);
module_exit(w1_fini);