w1.c 21.4 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
	struct w1_master *md = dev_to_w1_master(dev);
250

251
	mutex_lock(&md->mutex);
252
	md->search_count = simple_strtol(buf, NULL, 0);
253
	mutex_unlock(&md->mutex);
254 255 256 257 258 259 260 261

	return count;
}

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

265
	mutex_lock(&md->mutex);
266
	count = sprintf(buf, "%d\n", md->search_count);
267
	mutex_unlock(&md->mutex);
268 269 270 271

	return count;
}

272
static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
273
{
274
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
275
	ssize_t count;
E
Evgeniy Polyakov 已提交
276

277
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
278
	count = sprintf(buf, "0x%p\n", md->bus_master);
279
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
280 281 282
	return count;
}

283
static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
284 285 286 287 288 289
{
	ssize_t count;
	count = sprintf(buf, "%d\n", w1_timeout);
	return count;
}

290
static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
291
{
292
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
293
	ssize_t count;
E
Evgeniy Polyakov 已提交
294

295
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
296
	count = sprintf(buf, "%d\n", md->max_slave_count);
297
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
298 299 300
	return count;
}

301
static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
302
{
303
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
304
	ssize_t count;
E
Evgeniy Polyakov 已提交
305

306
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
307
	count = sprintf(buf, "%lu\n", md->attempts);
308
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
309 310 311
	return count;
}

312
static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
313
{
314
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
315
	ssize_t count;
E
Evgeniy Polyakov 已提交
316

317
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
318
	count = sprintf(buf, "%d\n", md->slave_count);
319
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
320 321 322
	return count;
}

323
static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
324
{
325
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
326 327
	int c = PAGE_SIZE;

328
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
329 330 331 332 333 334 335 336 337 338

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

343
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
344 345 346 347

	return PAGE_SIZE - c;
}

E
Evgeniy Polyakov 已提交
348 349 350 351 352
#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)

353 354 355 356 357 358
#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 已提交
359 360 361 362 363 364 365
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);
366
static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUGO);
E
Evgeniy Polyakov 已提交
367 368 369 370 371 372 373 374 375

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,
376
	&w1_master_attribute_search.attr,
E
Evgeniy Polyakov 已提交
377
	NULL
L
Linus Torvalds 已提交
378 379
};

E
Evgeniy Polyakov 已提交
380 381
static struct attribute_group w1_master_defattr_group = {
	.attrs = w1_master_default_attrs,
L
Linus Torvalds 已提交
382 383
};

E
Evgeniy Polyakov 已提交
384 385 386 387 388
int w1_create_master_attributes(struct w1_master *master)
{
	return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
}

389
void w1_destroy_master_attributes(struct w1_master *master)
E
Evgeniy Polyakov 已提交
390 391 392 393
{
	sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
}

E
Evgeniy Polyakov 已提交
394
#ifdef CONFIG_HOTPLUG
395
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
E
Evgeniy Polyakov 已提交
396 397 398 399
{
	struct w1_master *md = NULL;
	struct w1_slave *sl = NULL;
	char *event_owner, *name;
400
	int err;
E
Evgeniy Polyakov 已提交
401 402 403 404 405 406 407 408 409 410

	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 {
411
		dev_dbg(dev, "Unknown event.\n");
E
Evgeniy Polyakov 已提交
412 413 414
		return -EINVAL;
	}

A
Andrew Morton 已提交
415 416
	dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
			event_owner, name, dev->bus_id);
E
Evgeniy Polyakov 已提交
417 418 419 420

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

421
	err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);
E
Evgeniy Polyakov 已提交
422 423 424
	if (err)
		return err;

425 426
	err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",
			     (unsigned long long)sl->reg_num.id);
E
Evgeniy Polyakov 已提交
427 428 429 430 431 432
	if (err)
		return err;

	return 0;
};
#else
433
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
E
Evgeniy Polyakov 已提交
434 435 436 437 438
{
	return 0;
}
#endif

L
Linus Torvalds 已提交
439 440 441 442 443
static int __w1_attach_slave_device(struct w1_slave *sl)
{
	int err;

	sl->dev.parent = &sl->master->dev;
E
Evgeniy Polyakov 已提交
444
	sl->dev.driver = &w1_slave_driver;
L
Linus Torvalds 已提交
445 446 447 448
	sl->dev.bus = &w1_bus_type;
	sl->dev.release = &w1_slave_release;

	snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),
449 450 451 452 453 454 455
		 "%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 已提交
456

A
Andrew Morton 已提交
457
	dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
E
Evgeniy Polyakov 已提交
458
		&sl->dev.bus_id[0], sl);
L
Linus Torvalds 已提交
459 460 461 462

	err = device_register(&sl->dev);
	if (err < 0) {
		dev_err(&sl->dev,
463 464
			"Device registration [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
L
Linus Torvalds 已提交
465 466 467
		return err;
	}

468 469 470 471 472 473 474 475
	/* 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 已提交
476

477 478
	/* Create "id" entry */
	err = sysfs_create_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id);
L
Linus Torvalds 已提交
479 480
	if (err < 0) {
		dev_err(&sl->dev,
481 482
			"sysfs file creation for [%s] failed. err=%d\n",
			sl->dev.bus_id, err);
483
		goto out_rem1;
L
Linus Torvalds 已提交
484 485
	}

486 487 488 489 490 491 492
	/* 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 已提交
493 494 495 496 497
	}

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

	return 0;
498 499 500 501 502 503 504 505

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 已提交
506 507 508 509 510 511 512 513 514
}

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;

515
	sl = kzalloc(sizeof(struct w1_slave), GFP_KERNEL);
L
Linus Torvalds 已提交
516 517 518 519 520 521 522 523 524 525 526 527
	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);

528
	memset(&msg, 0, sizeof(msg));
L
Linus Torvalds 已提交
529 530
	memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
	atomic_set(&sl->refcnt, 0);
531
	init_completion(&sl->released);
L
Linus Torvalds 已提交
532 533 534 535

	spin_lock(&w1_flock);
	f = w1_family_registered(rn->family);
	if (!f) {
536
		f= &w1_default_family;
L
Linus Torvalds 已提交
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
		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++;

559
	memcpy(msg.id.id, rn, sizeof(msg.id));
L
Linus Torvalds 已提交
560 561 562 563 564 565
	msg.type = W1_SLAVE_ADD;
	w1_netlink_send(dev, &msg);

	return 0;
}

566
void w1_slave_detach(struct w1_slave *sl)
L
Linus Torvalds 已提交
567 568
{
	struct w1_netlink_msg msg;
E
Evgeniy Polyakov 已提交
569

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

572
	list_del(&sl->w1_slave_entry);
L
Linus Torvalds 已提交
573

574 575 576
	if (sl->family->fops && sl->family->fops->remove_slave)
		sl->family->fops->remove_slave(sl);

577 578
	memset(&msg, 0, sizeof(msg));
	memcpy(msg.id.id, &sl->reg_num, sizeof(msg.id));
579 580 581
	msg.type = W1_SLAVE_REMOVE;
	w1_netlink_send(sl->master, &msg);

582 583
	sysfs_remove_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id);
	device_remove_file(&sl->dev, &w1_slave_attr_name);
L
Linus Torvalds 已提交
584 585
	device_unregister(&sl->dev);

586 587
	wait_for_completion(&sl->released);
	kfree(sl);
L
Linus Torvalds 已提交
588 589
}

590 591 592 593 594
struct w1_master *w1_search_master_id(u32 id)
{
	struct w1_master *dev;
	int found = 0;

595
	mutex_lock(&w1_mlock);
596 597 598 599 600 601 602
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
		if (dev->id == id) {
			found = 1;
			atomic_inc(&dev->refcnt);
			break;
		}
	}
603
	mutex_unlock(&w1_mlock);
604 605 606 607 608 609 610 611 612 613

	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;

614
	mutex_lock(&w1_mlock);
615
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
616
		mutex_lock(&dev->mutex);
617 618 619 620 621 622 623 624 625 626
		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;
			}
		}
627
		mutex_unlock(&dev->mutex);
628 629 630 631

		if (found)
			break;
	}
632
	mutex_unlock(&w1_mlock);
633 634 635 636

	return (found)?sl:NULL;
}

637
void w1_reconnect_slaves(struct w1_family *f, int attach)
638
{
639
	struct w1_slave *sl, *sln;
640 641
	struct w1_master *dev;

642
	mutex_lock(&w1_mlock);
643
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
		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);
667
	}
668
	mutex_unlock(&w1_mlock);
669 670
}

671
static void w1_slave_found(struct w1_master *dev, u64 rn)
L
Linus Torvalds 已提交
672 673 674 675 676
{
	int slave_count;
	struct w1_slave *sl;
	struct list_head *ent;
	struct w1_reg_num *tmp;
677
	u64 rn_le = cpu_to_le64(rn);
L
Linus Torvalds 已提交
678

679
	atomic_inc(&dev->refcnt);
E
Evgeniy Polyakov 已提交
680

L
Linus Torvalds 已提交
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
	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++;
	}

698
	if (slave_count == dev->slave_count &&
699
		rn && ((rn >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn_le, 7)) {
700
		w1_attach_slave_device(dev, tmp);
L
Linus Torvalds 已提交
701
	}
E
Evgeniy Polyakov 已提交
702

L
Linus Torvalds 已提交
703 704 705
	atomic_dec(&dev->refcnt);
}

706 707 708 709 710 711 712 713 714 715 716 717 718 719
/**
 * 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
 */
720
void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
L
Linus Torvalds 已提交
721
{
722 723 724 725 726
	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 已提交
727

728 729 730 731
	search_bit = 0;
	rn = last_rn = 0;
	last_device = 0;
	last_zero = -1;
L
Linus Torvalds 已提交
732 733 734

	desc_bit = 64;

735 736
	while ( !last_device && (slave_count++ < dev->max_slave_count) ) {
		last_rn = rn;
L
Linus Torvalds 已提交
737 738 739 740 741 742 743 744 745
		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)) {
746
			dev_dbg(&dev->dev, "No devices present on the wire.\n");
L
Linus Torvalds 已提交
747 748 749
			break;
		}

750
		/* Start the search */
751
		w1_write_8(dev, search_type);
L
Linus Torvalds 已提交
752
		for (i = 0; i < 64; ++i) {
753 754 755 756 757
			/* 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 已提交
758
			else
759
				search_bit = ((last_rn >> i) & 0x1);
L
Linus Torvalds 已提交
760

761 762 763 764 765 766
			/** 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 已提交
767

768 769 770
			/* If both directions were valid, and we took the 0 path... */
			if (triplet_ret == 0)
				last_zero = i;
L
Linus Torvalds 已提交
771

772 773 774
			/* extract the direction taken & update the device number */
			tmp64 = (triplet_ret >> 2);
			rn |= (tmp64 << i);
D
David Fries 已提交
775 776 777 778 779

			if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
				printk(KERN_INFO "Abort w1_search (exiting)\n");
				return;
			}
780
		}
E
Evgeniy Polyakov 已提交
781

782 783 784 785
		if ( (triplet_ret & 0x03) != 0x03 ) {
			if ( (desc_bit == last_zero) || (last_zero < 0))
				last_device = 1;
			desc_bit = last_zero;
786
			cb(dev, rn);
787
		}
L
Linus Torvalds 已提交
788 789 790
	}
}

791 792 793 794 795 796 797 798 799 800
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) {
801
		if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl)
802
			w1_slave_detach(sl);
803
		else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
804 805 806 807 808 809 810
			sl->ttl = dev->slave_ttl;
	}

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

L
Linus Torvalds 已提交
811 812 813 814
int w1_process(void *data)
{
	struct w1_master *dev = (struct w1_master *) data;

E
Evgeniy Polyakov 已提交
815
	while (!kthread_should_stop() && !test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
D
David Fries 已提交
816 817 818 819 820 821
		if (dev->search_count) {
			mutex_lock(&dev->mutex);
			w1_search_process(dev, W1_SEARCH);
			mutex_unlock(&dev->mutex);
		}

822
		try_to_freeze();
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830
		msleep_interruptible(w1_timeout * 1000);
	}

	atomic_dec(&dev->refcnt);

	return 0;
}

E
Evgeniy Polyakov 已提交
831
static int w1_init(void)
L
Linus Torvalds 已提交
832 833 834 835 836
{
	int retval;

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

837 838
	w1_init_netlink();

L
Linus Torvalds 已提交
839 840 841 842 843 844
	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 已提交
845
	retval = driver_register(&w1_master_driver);
L
Linus Torvalds 已提交
846 847 848 849 850 851 852
	if (retval) {
		printk(KERN_ERR
			"Failed to register master driver. err=%d.\n",
			retval);
		goto err_out_bus_unregister;
	}

E
Evgeniy Polyakov 已提交
853 854 855 856 857 858 859 860
	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 已提交
861 862
	return 0;

863 864
#if 0
/* For undoing the slave register if there was a step after it. */
E
Evgeniy Polyakov 已提交
865 866
err_out_slave_unregister:
	driver_unregister(&w1_slave_driver);
867
#endif
E
Evgeniy Polyakov 已提交
868 869 870

err_out_master_unregister:
	driver_unregister(&w1_master_driver);
L
Linus Torvalds 已提交
871 872 873 874 875 876 877 878

err_out_bus_unregister:
	bus_unregister(&w1_bus_type);

err_out_exit_init:
	return retval;
}

E
Evgeniy Polyakov 已提交
879
static void w1_fini(void)
L
Linus Torvalds 已提交
880 881 882
{
	struct w1_master *dev;

883
	/* Set netlink removal messages and some cleanup */
E
Evgeniy Polyakov 已提交
884
	list_for_each_entry(dev, &w1_masters, w1_master_entry)
L
Linus Torvalds 已提交
885 886
		__w1_remove_master_device(dev);

887 888
	w1_fini_netlink();

E
Evgeniy Polyakov 已提交
889 890
	driver_unregister(&w1_slave_driver);
	driver_unregister(&w1_master_driver);
L
Linus Torvalds 已提交
891 892 893 894 895
	bus_unregister(&w1_bus_type);
}

module_init(w1_init);
module_exit(w1_fini);