/* *	w1.c * * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru> * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */#include <linux/delay.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/moduleparam.h>#include <linux/list.h>#include <linux/interrupt.h>#include <linux/spinlock.h>#include <linux/timer.h>#include <linux/device.h>#include <linux/slab.h>#include <linux/sched.h>#include <linux/kthread.h>#include <linux/freezer.h>#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;static int w1_control_timeout = 1;int w1_max_slave_count = 10;int w1_max_slave_ttl = 10;module_param_named(timeout, w1_timeout, int, 0);module_param_named(control_timeout, w1_control_timeout, int, 0);module_param_named(max_slave_count, w1_max_slave_count, int, 0);module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);DEFINE_MUTEX(w1_mlock);LIST_HEAD(w1_masters);static struct task_struct *w1_control_thread;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){	struct w1_master *md = dev_to_w1_master(dev);	dev_dbg(dev, "%s: Releasing %s.\n", __func__, md->name);	memset(md, 0, sizeof(struct w1_master) + sizeof(struct w1_bus_master));	kfree(md);}static void w1_slave_release(struct device *dev){	struct w1_slave *sl = dev_to_w1_slave(dev);	printk("%s: Releasing %s.\n", __func__, sl->name);	while (atomic_read(&sl->refcnt)) {		printk("Waiting for %s to become free: refcnt=%d.\n",				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);}static ssize_t w1_slave_read_name(struct device *dev, struct device_attribute *attr, char *buf){	struct w1_slave *sl = dev_to_w1_slave(dev);	return sprintf(buf, "%s\n", sl->name);}static ssize_t w1_slave_read_id(struct kobject *kobj,				struct bin_attribute *bin_attr,				char *buf, loff_t off, size_t count){	struct w1_slave *sl = kobj_to_w1_slave(kobj);	if (off > 8) {		count = 0;	} else {		if (off + count > 8)			count = 8 - off;		memcpy(buf, (u8 *)&sl->reg_num, count);	}	return count;}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,};/* Default family */static ssize_t w1_default_write(struct kobject *kobj,				struct bin_attribute *bin_attr,				char *buf, loff_t off, size_t count){	struct w1_slave *sl = kobj_to_w1_slave(kobj);	mutex_lock(&sl->master->mutex);	if (w1_reset_select_slave(sl)) {		count = 0;		goto out_up;	}	w1_write_block(sl->master, buf, count);out_up:	mutex_unlock(&sl->master->mutex);	return count;}static ssize_t w1_default_read(struct kobject *kobj,			       struct bin_attribute *bin_attr,			       char *buf, loff_t off, size_t count){	struct w1_slave *sl = kobj_to_w1_slave(kobj);	mutex_lock(&sl->master->mutex);	w1_read_block(sl->master, buf, count);	mutex_unlock(&sl->master->mutex);	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,};static int w1_uevent(struct device *dev, struct kobj_uevent_env *env);static struct bus_type w1_bus_type = {	.name = "w1",	.match = w1_master_match,	.uevent = w1_uevent,};struct device_driver w1_master_driver = {	.name = "w1_master_driver",	.bus = &w1_bus_type,	.probe = w1_master_probe,};struct device w1_master_device = {	.parent = NULL,	.bus = &w1_bus_type,	.bus_id = "w1 bus master",	.driver = &w1_master_driver,	.release = &w1_master_release};static struct device_driver w1_slave_driver = {	.name = "w1_slave_driver",	.bus = &w1_bus_type,};#if 0struct device w1_slave_device = {	.parent = NULL,	.bus = &w1_bus_type,	.bus_id = "w1 bus slave",	.driver = &w1_slave_driver,	.release = &w1_slave_release};#endif  /*  0  */static ssize_t w1_master_attribute_show_name(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, "%s\n", md->name);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_store_search(struct device * dev,						struct device_attribute *attr,						const char * buf, size_t count){	struct w1_master *md = dev_to_w1_master(dev);	mutex_lock(&md->mutex);	md->search_count = simple_strtol(buf, NULL, 0);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_show_search(struct device *dev,					       struct device_attribute *attr,					       char *buf){	struct w1_master *md = dev_to_w1_master(dev);	ssize_t count;	mutex_lock(&md->mutex);	count = sprintf(buf, "%d\n", md->search_count);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_show_pointer(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, "0x%p\n", md->bus_master);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf){	ssize_t count;	count = sprintf(buf, "%d\n", w1_timeout);	return count;}static ssize_t w1_master_attribute_show_max_slave_count(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->max_slave_count);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_show_attempts(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, "%lu\n", md->attempts);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_show_slave_count(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->slave_count);	mutex_unlock(&md->mutex);	return count;}static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device_attribute *attr, char *buf){	struct w1_master *md = dev_to_w1_master(dev);	int c = PAGE_SIZE;	mutex_lock(&md->mutex);	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);			c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name);		}	}	mutex_unlock(&md->mutex);	return PAGE_SIZE - c;}#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)#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)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);static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUGO);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,	&w1_master_attribute_search.attr,	NULL};static struct attribute_group w1_master_defattr_group = {	.attrs = w1_master_default_attrs,};int w1_create_master_attributes(struct w1_master *master){	return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);}static void w1_destroy_master_attributes(struct w1_master *master){	sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);}#ifdef CONFIG_HOTPLUGstatic int w1_uevent(struct device *dev, struct kobj_uevent_env *env){	struct w1_master *md = NULL;	struct w1_slave *sl = NULL;	char *event_owner, *name;	int err;	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 {		dev_dbg(dev, "Unknown event.\n");		return -EINVAL;	}	dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",			event_owner, name, dev->bus_id);	if (dev->driver != &w1_slave_driver || !sl)		return 0;	err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);	if (err)		return err;	err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",			     (unsigned long long)sl->reg_num.id);	if (err)		return err;	return 0;};#elsestatic int w1_uevent(struct device *dev, struct kobj_uevent_env *env){	return 0;}#endifstatic int __w1_attach_slave_device(struct w1_slave *sl){	int err;	sl->dev.parent = &sl->master->dev;	sl->dev.driver = &w1_slave_driver;	sl->dev.bus = &w1_bus_type;	sl->dev.release = &w1_slave_release;	snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),		 "%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);	dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,		&sl->dev.bus_id[0], sl);	err = device_register(&sl->dev);	if (err < 0) {		dev_err(&sl->dev,			"Device registration [%s] failed. err=%d\n",			sl->dev.bus_id, err);		return err;	}	/* 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;	}	/* Create "id" entry */	err = sysfs_create_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id);	if (err < 0) {		dev_err(&sl->dev,			"sysfs file creation for [%s] failed. err=%d\n",			sl->dev.bus_id, err);		goto out_rem1;	}	/* if the family driver needs to initialize something... */