w1.c 25.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
E
Evgeniy Polyakov 已提交
2
 *	w1.c
L
Linus Torvalds 已提交
3
 *
4
 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
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

A
Arun Sharma 已提交
36
#include <linux/atomic.h>
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44

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

MODULE_LICENSE("GPL");
45
MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
L
Linus Torvalds 已提交
46 47 48 49 50 51 52 53 54 55
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
LIST_HEAD(w1_masters);

59 60
static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn);

L
Linus Torvalds 已提交
61 62 63 64 65 66 67 68 69 70 71 72
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)
{
73
	struct w1_master *md = dev_to_w1_master(dev);
74 75 76 77

	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 已提交
78 79 80 81
}

static void w1_slave_release(struct device *dev)
{
82
	struct w1_slave *sl = dev_to_w1_slave(dev);
83

D
David Fries 已提交
84
	dev_dbg(dev, "%s: Releasing %s.\n", __func__, sl->name);
85 86

	while (atomic_read(&sl->refcnt)) {
D
David Fries 已提交
87
		dev_dbg(dev, "Waiting for %s to become free: refcnt=%d.\n",
88 89 90 91 92 93 94 95 96
				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 已提交
97 98
}

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

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

106 107
static ssize_t w1_slave_read_id(struct device *dev,
	struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
108
{
109 110
	struct w1_slave *sl = dev_to_w1_slave(dev);
	ssize_t count = sizeof(sl->reg_num);
111

112
	memcpy(buf, (u8 *)&sl->reg_num, count);
113
	return count;
114
}
115 116 117

static struct device_attribute w1_slave_attr_name =
	__ATTR(name, S_IRUGO, w1_slave_read_name, NULL);
118 119
static struct device_attribute w1_slave_attr_id =
	__ATTR(id, S_IRUGO, w1_slave_read_id, NULL);
E
Evgeniy Polyakov 已提交
120

121
/* Default family */
122

123
static ssize_t w1_default_write(struct file *filp, struct kobject *kobj,
124 125
				struct bin_attribute *bin_attr,
				char *buf, loff_t off, size_t count)
126 127 128
{
	struct w1_slave *sl = kobj_to_w1_slave(kobj);

129
	mutex_lock(&sl->master->mutex);
130 131 132 133 134 135 136 137
	if (w1_reset_select_slave(sl)) {
		count = 0;
		goto out_up;
	}

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

out_up:
138
	mutex_unlock(&sl->master->mutex);
139 140 141
	return count;
}

142
static ssize_t w1_default_read(struct file *filp, struct kobject *kobj,
143 144
			       struct bin_attribute *bin_attr,
			       char *buf, loff_t off, size_t count)
145 146 147
{
	struct w1_slave *sl = kobj_to_w1_slave(kobj);

148
	mutex_lock(&sl->master->mutex);
149
	w1_read_block(sl->master, buf, count);
150
	mutex_unlock(&sl->master->mutex);
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
	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,
};
182

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

L
Linus Torvalds 已提交
185 186 187
static struct bus_type w1_bus_type = {
	.name = "w1",
	.match = w1_master_match,
188
	.uevent = w1_uevent,
L
Linus Torvalds 已提交
189 190
};

E
Evgeniy Polyakov 已提交
191 192
struct device_driver w1_master_driver = {
	.name = "w1_master_driver",
L
Linus Torvalds 已提交
193 194 195 196
	.bus = &w1_bus_type,
	.probe = w1_master_probe,
};

E
Evgeniy Polyakov 已提交
197
struct device w1_master_device = {
L
Linus Torvalds 已提交
198 199
	.parent = NULL,
	.bus = &w1_bus_type,
200
	.init_name = "w1 bus master",
E
Evgeniy Polyakov 已提交
201
	.driver = &w1_master_driver,
L
Linus Torvalds 已提交
202 203 204
	.release = &w1_master_release
};

E
Evgeniy Polyakov 已提交
205
static struct device_driver w1_slave_driver = {
E
Evgeniy Polyakov 已提交
206 207 208 209
	.name = "w1_slave_driver",
	.bus = &w1_bus_type,
};

E
Evgeniy Polyakov 已提交
210
#if 0
E
Evgeniy Polyakov 已提交
211 212 213
struct device w1_slave_device = {
	.parent = NULL,
	.bus = &w1_bus_type,
214
	.init_name = "w1 bus slave",
E
Evgeniy Polyakov 已提交
215
	.driver = &w1_slave_driver,
216
	.release = &w1_slave_release
E
Evgeniy Polyakov 已提交
217
};
E
Evgeniy Polyakov 已提交
218
#endif  /*  0  */
E
Evgeniy Polyakov 已提交
219

220
static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
221
{
222
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
223
	ssize_t count;
E
Evgeniy Polyakov 已提交
224

225
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
226
	count = sprintf(buf, "%s\n", md->name);
227
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
228 229 230 231

	return count;
}

232 233 234 235
static ssize_t w1_master_attribute_store_search(struct device * dev,
						struct device_attribute *attr,
						const char * buf, size_t count)
{
236
	long tmp;
237
	struct w1_master *md = dev_to_w1_master(dev);
238

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

242
	mutex_lock(&md->mutex);
243
	md->search_count = tmp;
244
	mutex_unlock(&md->mutex);
D
David Fries 已提交
245
	wake_up_process(md->thread);
246 247 248 249 250 251 252 253

	return count;
}

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

257
	mutex_lock(&md->mutex);
258
	count = sprintf(buf, "%d\n", md->search_count);
259
	mutex_unlock(&md->mutex);
260 261 262 263

	return count;
}

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
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;
}

296
static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
297
{
298
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
299
	ssize_t count;
E
Evgeniy Polyakov 已提交
300

301
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
302
	count = sprintf(buf, "0x%p\n", md->bus_master);
303
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
304 305 306
	return count;
}

307
static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
308 309 310 311 312 313
{
	ssize_t count;
	count = sprintf(buf, "%d\n", w1_timeout);
	return count;
}

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

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

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

330
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
331
	count = sprintf(buf, "%lu\n", md->attempts);
332
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
333 334 335
	return count;
}

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

341
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
342
	count = sprintf(buf, "%d\n", md->slave_count);
343
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
344 345 346
	return count;
}

347 348
static ssize_t w1_master_attribute_show_slaves(struct device *dev,
	struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
349
{
350
	struct w1_master *md = dev_to_w1_master(dev);
L
Linus Torvalds 已提交
351 352
	int c = PAGE_SIZE;

353
	mutex_lock(&md->mutex);
L
Linus Torvalds 已提交
354 355 356 357 358 359 360 361 362 363

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

368
	mutex_unlock(&md->mutex);
L
Linus Torvalds 已提交
369 370 371 372

	return PAGE_SIZE - c;
}

373 374 375 376 377 378 379 380 381 382 383 384 385 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 421 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 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
static ssize_t w1_master_attribute_show_add(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	int c = PAGE_SIZE;
	c -= snprintf(buf+PAGE_SIZE - c, c,
		"write device id xx-xxxxxxxxxxxx to add slave\n");
	return PAGE_SIZE - c;
}

static int w1_atoreg_num(struct device *dev, const char *buf, size_t count,
	struct w1_reg_num *rn)
{
	unsigned int family;
	unsigned long long id;
	int i;
	u64 rn64_le;

	/* The CRC value isn't read from the user because the sysfs directory
	 * doesn't include it and most messages from the bus search don't
	 * print it either.  It would be unreasonable for the user to then
	 * provide it.
	 */
	const char *error_msg = "bad slave string format, expecting "
		"ff-dddddddddddd\n";

	if (buf[2] != '-') {
		dev_err(dev, "%s", error_msg);
		return -EINVAL;
	}
	i = sscanf(buf, "%02x-%012llx", &family, &id);
	if (i != 2) {
		dev_err(dev, "%s", error_msg);
		return -EINVAL;
	}
	rn->family = family;
	rn->id = id;

	rn64_le = cpu_to_le64(*(u64 *)rn);
	rn->crc = w1_calc_crc8((u8 *)&rn64_le, 7);

#if 0
	dev_info(dev, "With CRC device is %02x.%012llx.%02x.\n",
		  rn->family, (unsigned long long)rn->id, rn->crc);
#endif

	return 0;
}

/* Searches the slaves in the w1_master and returns a pointer or NULL.
 * Note: must hold the mutex
 */
static struct w1_slave *w1_slave_search_device(struct w1_master *dev,
	struct w1_reg_num *rn)
{
	struct w1_slave *sl;
	list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
		if (sl->reg_num.family == rn->family &&
				sl->reg_num.id == rn->id &&
				sl->reg_num.crc == rn->crc) {
			return sl;
		}
	}
	return NULL;
}

static ssize_t w1_master_attribute_store_add(struct device *dev,
						struct device_attribute *attr,
						const char *buf, size_t count)
{
	struct w1_master *md = dev_to_w1_master(dev);
	struct w1_reg_num rn;
	struct w1_slave *sl;
	ssize_t result = count;

	if (w1_atoreg_num(dev, buf, count, &rn))
		return -EINVAL;

	mutex_lock(&md->mutex);
	sl = w1_slave_search_device(md, &rn);
	/* It would be nice to do a targeted search one the one-wire bus
	 * for the new device to see if it is out there or not.  But the
	 * current search doesn't support that.
	 */
	if (sl) {
		dev_info(dev, "Device %s already exists\n", sl->name);
		result = -EINVAL;
	} else {
		w1_attach_slave_device(md, &rn);
	}
	mutex_unlock(&md->mutex);

	return result;
}

static ssize_t w1_master_attribute_show_remove(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	int c = PAGE_SIZE;
	c -= snprintf(buf+PAGE_SIZE - c, c,
		"write device id xx-xxxxxxxxxxxx to remove slave\n");
	return PAGE_SIZE - c;
}

static ssize_t w1_master_attribute_store_remove(struct device *dev,
						struct device_attribute *attr,
						const char *buf, size_t count)
{
	struct w1_master *md = dev_to_w1_master(dev);
	struct w1_reg_num rn;
	struct w1_slave *sl;
	ssize_t result = count;

	if (w1_atoreg_num(dev, buf, count, &rn))
		return -EINVAL;

	mutex_lock(&md->mutex);
	sl = w1_slave_search_device(md, &rn);
	if (sl) {
		w1_slave_detach(sl);
	} else {
		dev_info(dev, "Device %02x-%012llx doesn't exists\n", rn.family,
			(unsigned long long)rn.id);
		result = -EINVAL;
	}
	mutex_unlock(&md->mutex);

	return result;
}

E
Evgeniy Polyakov 已提交
502 503 504 505 506
#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)

507 508 509 510 511 512
#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 已提交
513 514 515 516 517 518 519
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);
520 521 522 523
static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUSR | S_IWGRP);
static W1_MASTER_ATTR_RW(pullup, S_IRUGO | S_IWUSR | S_IWGRP);
static W1_MASTER_ATTR_RW(add, S_IRUGO | S_IWUSR | S_IWGRP);
static W1_MASTER_ATTR_RW(remove, S_IRUGO | S_IWUSR | S_IWGRP);
E
Evgeniy Polyakov 已提交
524 525 526 527 528 529 530 531 532

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,
533
	&w1_master_attribute_search.attr,
534
	&w1_master_attribute_pullup.attr,
535 536
	&w1_master_attribute_add.attr,
	&w1_master_attribute_remove.attr,
E
Evgeniy Polyakov 已提交
537
	NULL
L
Linus Torvalds 已提交
538 539
};

E
Evgeniy Polyakov 已提交
540 541
static struct attribute_group w1_master_defattr_group = {
	.attrs = w1_master_default_attrs,
L
Linus Torvalds 已提交
542 543
};

E
Evgeniy Polyakov 已提交
544 545 546 547 548
int w1_create_master_attributes(struct w1_master *master)
{
	return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
}

549
void w1_destroy_master_attributes(struct w1_master *master)
E
Evgeniy Polyakov 已提交
550 551 552 553
{
	sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
}

E
Evgeniy Polyakov 已提交
554
#ifdef CONFIG_HOTPLUG
555
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
E
Evgeniy Polyakov 已提交
556 557 558 559
{
	struct w1_master *md = NULL;
	struct w1_slave *sl = NULL;
	char *event_owner, *name;
560
	int err;
E
Evgeniy Polyakov 已提交
561 562 563 564 565 566 567 568 569 570

	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 {
571
		dev_dbg(dev, "Unknown event.\n");
E
Evgeniy Polyakov 已提交
572 573 574
		return -EINVAL;
	}

A
Andrew Morton 已提交
575
	dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
576
			event_owner, name, dev_name(dev));
E
Evgeniy Polyakov 已提交
577 578 579 580

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

581
	err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);
E
Evgeniy Polyakov 已提交
582 583 584
	if (err)
		return err;

585 586
	err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",
			     (unsigned long long)sl->reg_num.id);
E
Evgeniy Polyakov 已提交
587 588 589 590 591 592
	if (err)
		return err;

	return 0;
};
#else
593
static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
E
Evgeniy Polyakov 已提交
594 595 596 597 598
{
	return 0;
}
#endif

L
Linus Torvalds 已提交
599 600 601 602 603
static int __w1_attach_slave_device(struct w1_slave *sl)
{
	int err;

	sl->dev.parent = &sl->master->dev;
E
Evgeniy Polyakov 已提交
604
	sl->dev.driver = &w1_slave_driver;
L
Linus Torvalds 已提交
605 606 607
	sl->dev.bus = &w1_bus_type;
	sl->dev.release = &w1_slave_release;

608
	dev_set_name(&sl->dev, "%02x-%012llx",
609 610 611 612 613 614
		 (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 已提交
615

A
Andrew Morton 已提交
616
	dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
617
		dev_name(&sl->dev), sl);
L
Linus Torvalds 已提交
618 619 620 621

	err = device_register(&sl->dev);
	if (err < 0) {
		dev_err(&sl->dev,
622
			"Device registration [%s] failed. err=%d\n",
623
			dev_name(&sl->dev), err);
L
Linus Torvalds 已提交
624 625 626
		return err;
	}

627 628 629 630 631
	/* 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",
632
			dev_name(&sl->dev), err);
633 634
		goto out_unreg;
	}
L
Linus Torvalds 已提交
635

636
	/* Create "id" entry */
637
	err = device_create_file(&sl->dev, &w1_slave_attr_id);
L
Linus Torvalds 已提交
638 639
	if (err < 0) {
		dev_err(&sl->dev,
640
			"sysfs file creation for [%s] failed. err=%d\n",
641
			dev_name(&sl->dev), err);
642
		goto out_rem1;
L
Linus Torvalds 已提交
643 644
	}

645 646 647 648 649
	/* 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",
650
			dev_name(&sl->dev), err);
651
		goto out_rem2;
L
Linus Torvalds 已提交
652 653 654 655 656
	}

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

	return 0;
657 658

out_rem2:
659
	device_remove_file(&sl->dev, &w1_slave_attr_id);
660 661 662 663 664
out_rem1:
	device_remove_file(&sl->dev, &w1_slave_attr_name);
out_unreg:
	device_unregister(&sl->dev);
	return err;
L
Linus Torvalds 已提交
665 666 667 668 669 670 671 672 673
}

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;

674
	sl = kzalloc(sizeof(struct w1_slave), GFP_KERNEL);
L
Linus Torvalds 已提交
675 676 677 678 679 680 681 682 683 684 685 686
	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);

687
	memset(&msg, 0, sizeof(msg));
L
Linus Torvalds 已提交
688 689
	memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
	atomic_set(&sl->refcnt, 0);
690
	init_completion(&sl->released);
L
Linus Torvalds 已提交
691 692 693 694

	spin_lock(&w1_flock);
	f = w1_family_registered(rn->family);
	if (!f) {
695
		f= &w1_default_family;
L
Linus Torvalds 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
		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++;

718
	memcpy(msg.id.id, rn, sizeof(msg.id));
L
Linus Torvalds 已提交
719 720 721 722 723 724
	msg.type = W1_SLAVE_ADD;
	w1_netlink_send(dev, &msg);

	return 0;
}

725
void w1_slave_detach(struct w1_slave *sl)
L
Linus Torvalds 已提交
726 727
{
	struct w1_netlink_msg msg;
E
Evgeniy Polyakov 已提交
728

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

731
	list_del(&sl->w1_slave_entry);
L
Linus Torvalds 已提交
732

733 734 735
	if (sl->family->fops && sl->family->fops->remove_slave)
		sl->family->fops->remove_slave(sl);

736 737
	memset(&msg, 0, sizeof(msg));
	memcpy(msg.id.id, &sl->reg_num, sizeof(msg.id));
738 739 740
	msg.type = W1_SLAVE_REMOVE;
	w1_netlink_send(sl->master, &msg);

741
	device_remove_file(&sl->dev, &w1_slave_attr_id);
742
	device_remove_file(&sl->dev, &w1_slave_attr_name);
L
Linus Torvalds 已提交
743 744
	device_unregister(&sl->dev);

745 746
	wait_for_completion(&sl->released);
	kfree(sl);
L
Linus Torvalds 已提交
747 748
}

749 750 751 752 753
struct w1_master *w1_search_master_id(u32 id)
{
	struct w1_master *dev;
	int found = 0;

754
	mutex_lock(&w1_mlock);
755 756 757 758 759 760 761
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
		if (dev->id == id) {
			found = 1;
			atomic_inc(&dev->refcnt);
			break;
		}
	}
762
	mutex_unlock(&w1_mlock);
763 764 765 766 767 768 769 770 771 772

	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;

773
	mutex_lock(&w1_mlock);
774
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
775
		mutex_lock(&dev->mutex);
776 777 778 779 780 781 782 783 784 785
		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;
			}
		}
786
		mutex_unlock(&dev->mutex);
787 788 789 790

		if (found)
			break;
	}
791
	mutex_unlock(&w1_mlock);
792 793 794 795

	return (found)?sl:NULL;
}

796
void w1_reconnect_slaves(struct w1_family *f, int attach)
797
{
798
	struct w1_slave *sl, *sln;
799 800
	struct w1_master *dev;

801
	mutex_lock(&w1_mlock);
802
	list_for_each_entry(dev, &w1_masters, w1_master_entry) {
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
		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);
826
	}
827
	mutex_unlock(&w1_mlock);
828 829
}

830
void w1_slave_found(struct w1_master *dev, u64 rn)
L
Linus Torvalds 已提交
831 832 833
{
	struct w1_slave *sl;
	struct w1_reg_num *tmp;
834
	u64 rn_le = cpu_to_le64(rn);
L
Linus Torvalds 已提交
835

836
	atomic_inc(&dev->refcnt);
E
Evgeniy Polyakov 已提交
837

L
Linus Torvalds 已提交
838 839
	tmp = (struct w1_reg_num *) &rn;

D
David Fries 已提交
840 841 842 843 844 845
	sl = w1_slave_search_device(dev, tmp);
	if (sl) {
		set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
	} else {
		if (rn && tmp->crc == w1_calc_crc8((u8 *)&rn_le, 7))
			w1_attach_slave_device(dev, tmp);
L
Linus Torvalds 已提交
846
	}
E
Evgeniy Polyakov 已提交
847

L
Linus Torvalds 已提交
848 849 850
	atomic_dec(&dev->refcnt);
}

851 852 853 854 855 856 857 858 859 860 861 862 863 864
/**
 * 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
 */
865
void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
L
Linus Torvalds 已提交
866
{
867 868 869 870 871
	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 已提交
872

873 874 875 876
	search_bit = 0;
	rn = last_rn = 0;
	last_device = 0;
	last_zero = -1;
L
Linus Torvalds 已提交
877 878 879

	desc_bit = 64;

880 881
	while ( !last_device && (slave_count++ < dev->max_slave_count) ) {
		last_rn = rn;
L
Linus Torvalds 已提交
882 883 884 885 886 887 888 889 890
		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)) {
891
			dev_dbg(&dev->dev, "No devices present on the wire.\n");
L
Linus Torvalds 已提交
892 893 894
			break;
		}

895 896 897 898 899 900 901 902 903 904
		/* Do fast search on single slave bus */
		if (dev->max_slave_count == 1) {
			w1_write_8(dev, W1_READ_ROM);

			if (w1_read_block(dev, (u8 *)&rn, 8) == 8 && rn)
				cb(dev, rn);

			break;
		}

905
		/* Start the search */
906
		w1_write_8(dev, search_type);
L
Linus Torvalds 已提交
907
		for (i = 0; i < 64; ++i) {
908 909 910 911 912
			/* 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 已提交
913
			else
914
				search_bit = ((last_rn >> i) & 0x1);
L
Linus Torvalds 已提交
915

916 917 918 919 920 921
			/** 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 已提交
922

923 924 925
			/* If both directions were valid, and we took the 0 path... */
			if (triplet_ret == 0)
				last_zero = i;
L
Linus Torvalds 已提交
926

927 928 929
			/* extract the direction taken & update the device number */
			tmp64 = (triplet_ret >> 2);
			rn |= (tmp64 << i);
D
David Fries 已提交
930

D
David Fries 已提交
931
			if (kthread_should_stop()) {
D
David Fries 已提交
932
				dev_dbg(&dev->dev, "Abort w1_search\n");
D
David Fries 已提交
933 934
				return;
			}
935
		}
E
Evgeniy Polyakov 已提交
936

937 938 939 940
		if ( (triplet_ret & 0x03) != 0x03 ) {
			if ( (desc_bit == last_zero) || (last_zero < 0))
				last_device = 1;
			desc_bit = last_zero;
941
			cb(dev, rn);
942
		}
L
Linus Torvalds 已提交
943 944 945
	}
}

946 947
void w1_search_process_cb(struct w1_master *dev, u8 search_type,
	w1_slave_found_callback cb)
948 949 950 951 952 953
{
	struct w1_slave *sl, *sln;

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

954
	w1_search_devices(dev, search_type, cb);
955 956

	list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
957
		if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl)
958
			w1_slave_detach(sl);
959
		else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
960 961 962 963 964 965 966
			sl->ttl = dev->slave_ttl;
	}

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

967 968 969 970 971
static void w1_search_process(struct w1_master *dev, u8 search_type)
{
	w1_search_process_cb(dev, search_type, w1_slave_found);
}

L
Linus Torvalds 已提交
972 973 974
int w1_process(void *data)
{
	struct w1_master *dev = (struct w1_master *) data;
D
David Fries 已提交
975 976 977 978
	/* 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 已提交
979

D
David Fries 已提交
980
	while (!kthread_should_stop()) {
D
David Fries 已提交
981 982 983 984 985 986
		if (dev->search_count) {
			mutex_lock(&dev->mutex);
			w1_search_process(dev, W1_SEARCH);
			mutex_unlock(&dev->mutex);
		}

987
		try_to_freeze();
D
David Fries 已提交
988 989 990 991 992 993 994 995 996 997
		__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 已提交
998 999 1000 1001 1002 1003 1004
	}

	atomic_dec(&dev->refcnt);

	return 0;
}

1005
static int __init w1_init(void)
L
Linus Torvalds 已提交
1006 1007 1008 1009 1010
{
	int retval;

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

1011 1012
	w1_init_netlink();

L
Linus Torvalds 已提交
1013 1014 1015 1016 1017 1018
	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 已提交
1019
	retval = driver_register(&w1_master_driver);
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026
	if (retval) {
		printk(KERN_ERR
			"Failed to register master driver. err=%d.\n",
			retval);
		goto err_out_bus_unregister;
	}

E
Evgeniy Polyakov 已提交
1027 1028 1029 1030 1031 1032 1033 1034
	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 已提交
1035 1036
	return 0;

1037 1038
#if 0
/* For undoing the slave register if there was a step after it. */
E
Evgeniy Polyakov 已提交
1039 1040
err_out_slave_unregister:
	driver_unregister(&w1_slave_driver);
1041
#endif
E
Evgeniy Polyakov 已提交
1042 1043 1044

err_out_master_unregister:
	driver_unregister(&w1_master_driver);
L
Linus Torvalds 已提交
1045 1046 1047 1048 1049 1050 1051 1052

err_out_bus_unregister:
	bus_unregister(&w1_bus_type);

err_out_exit_init:
	return retval;
}

1053
static void __exit w1_fini(void)
L
Linus Torvalds 已提交
1054 1055 1056
{
	struct w1_master *dev;

1057
	/* Set netlink removal messages and some cleanup */
E
Evgeniy Polyakov 已提交
1058
	list_for_each_entry(dev, &w1_masters, w1_master_entry)
L
Linus Torvalds 已提交
1059 1060
		__w1_remove_master_device(dev);

1061 1062
	w1_fini_netlink();

E
Evgeniy Polyakov 已提交
1063 1064
	driver_unregister(&w1_slave_driver);
	driver_unregister(&w1_master_driver);
L
Linus Torvalds 已提交
1065 1066 1067 1068 1069
	bus_unregister(&w1_bus_type);
}

module_init(w1_init);
module_exit(w1_fini);