Release 4.11 drivers/w1/w1.c

/*
 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
 *
 * 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.
 */

#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 <linux/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 <zbr@ioremap.net>");
MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");


static int w1_timeout = 10;

static int w1_timeout_us = 0;

int w1_max_slave_count = 64;

int w1_max_slave_ttl = 10;

module_param_named(timeout, w1_timeout, int, 0);
MODULE_PARM_DESC(timeout, "time in seconds between automatic slave searches");
module_param_named(timeout_us, w1_timeout_us, int, 0);
MODULE_PARM_DESC(timeout_us,
		 "time in microseconds between automatic slave searches");
/* A search stops when w1_max_slave_count devices have been found in that
 * search.  The next search will start over and detect the same set of devices
 * on a static 1-wire bus.  Memory is not allocated based on this number, just
 * on the number of devices known to the kernel.  Having a high number does not
 * consume additional resources.  As a special case, if there is only one
 * device on the network and w1_max_slave_count is set to 1, the device id can
 * be read directly skipping the normal slower search process.
 */
module_param_named(max_slave_count, w1_max_slave_count, int, 0);
MODULE_PARM_DESC(max_slave_count,
	"maximum number of slaves detected in a search");
module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);
MODULE_PARM_DESC(slave_ttl,
	"Number of searches not seeing a slave before it will be removed");


DEFINE_MUTEX(w1_mlock);

LIST_HEAD(w1_masters);



static int w1_master_match(struct device *dev, struct device_driver *drv)
{
	return 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
33
56.90%
2
66.67%
Greg Kroah-Hartman
25
43.10%
1
33.33%
Total
58
100.00%
3
100.00%



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

	dev_dbg(dev, "%s: Releasing %s [%p]\n", __func__, sl->name, sl);

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
26
52.00%
2
40.00%
Greg Kroah-Hartman
20
40.00%
1
20.00%
David Fries
4
8.00%
2
40.00%
Total
50
100.00%
5
100.00%



static ssize_t name_show(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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
22
52.38%
2
50.00%
Evgeniy Polyakov
15
35.71%
1
25.00%
Yani Ioannou
5
11.90%
1
25.00%
Total
42
100.00%
4
100.00%

static DEVICE_ATTR_RO(name);



static ssize_t id_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct w1_slave *sl = dev_to_w1_slave(dev);
	ssize_t count = sizeof(sl->reg_num);

	memcpy(buf, (u8 *)&sl->reg_num, count);
	return count;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
24
40.68%
1
20.00%
Greg Kroah-Hartman
17
28.81%
2
40.00%
David Fries
15
25.42%
1
20.00%
Rui Zhang
3
5.08%
1
20.00%
Total
59
100.00%
5
100.00%

static DEVICE_ATTR_RO(id);


static struct attribute *w1_slave_attrs[] = {
	&dev_attr_name.attr,
	&dev_attr_id.attr,
	NULL,
};

ATTRIBUTE_GROUPS(w1_slave);

/* Default family */



static ssize_t rw_write(struct file *filp, 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
82
88.17%
2
40.00%
Rui Zhang
5
5.38%
1
20.00%
Chris Wright
5
5.38%
1
20.00%
Greg Kroah-Hartman
1
1.08%
1
20.00%
Total
93
100.00%
5
100.00%



static ssize_t rw_read(struct file *filp, 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
64
85.33%
2
40.00%
Chris Wright
5
6.67%
1
20.00%
Rui Zhang
5
6.67%
1
20.00%
Greg Kroah-Hartman
1
1.33%
1
20.00%
Total
75
100.00%
5
100.00%

static BIN_ATTR_RW(rw, PAGE_SIZE);


static struct bin_attribute *w1_slave_bin_attrs[] = {
	&bin_attr_rw,
	NULL,
};


static const struct attribute_group w1_slave_default_group = {
	.bin_attrs = w1_slave_bin_attrs,
};


static const struct attribute_group *w1_slave_default_groups[] = {
	&w1_slave_default_group,
	NULL,
};


static struct w1_family_ops w1_default_fops = {
	.groups		= w1_slave_default_groups,
};


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,
	.init_name = "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 0
struct device w1_slave_device = {
        .parent = NULL,
        .bus = &w1_bus_type,
        .init_name = "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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
60
92.31%
4
80.00%
Yani Ioannou
5
7.69%
1
20.00%
Total
65
100.00%
5
100.00%



static ssize_t w1_master_attribute_store_search(struct device * dev,
						struct device_attribute *attr,
						const char * buf, size_t count)
{
	long tmp;
	struct w1_master *md = dev_to_w1_master(dev);
	int ret;

	ret = kstrtol(buf, 0, &tmp);
	if (ret)
		return ret;

	mutex_lock(&md->mutex);
	md->search_count = tmp;
	mutex_unlock(&md->mutex);
	/* Only wake if it is going to be searching. */
	if (tmp)
		wake_up_process(md->thread);

	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
45
46.88%
3
50.00%
David Fries
40
41.67%
2
33.33%
Jingoo Han
11
11.46%
1
16.67%
Total
96
100.00%
6
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
62
95.38%
1
50.00%
Evgeniy Polyakov
3
4.62%
1
50.00%
Total
65
100.00%
2
100.00%



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);
	int ret;

	ret = kstrtol(buf, 0, &tmp);
	if (ret)
		return ret;

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

	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
57
67.86%
1
25.00%
Evgeniy Polyakov
16
19.05%
2
50.00%
Jingoo Han
11
13.10%
1
25.00%
Total
84
100.00%
4
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
63
96.92%
3
75.00%
David Fries
2
3.08%
1
25.00%
Total
65
100.00%
4
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
60
92.31%
4
80.00%
Yani Ioannou
5
7.69%
1
20.00%
Total
65
100.00%
5
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
32
86.49%
2
66.67%
Yani Ioannou
5
13.51%
1
33.33%
Total
37
100.00%
3
100.00%



static ssize_t w1_master_attribute_show_timeout_us(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	ssize_t count;
	count = sprintf(buf, "%d\n", w1_timeout_us);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dmitry Khromov
37
100.00%
1
100.00%
Total
37
100.00%
1
100.00%



static ssize_t w1_master_attribute_store_max_slave_count(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	int tmp;
	struct w1_master *md = dev_to_w1_master(dev);

	if (kstrtoint(buf, 0, &tmp) || tmp < 1)
		return -EINVAL;

	mutex_lock(&md->mutex);
	md->max_slave_count = tmp;
	/* allow each time the max_slave_count is updated */
	clear_bit(W1_WARN_MAX_COUNT, &md->flags);
	mutex_unlock(&md->mutex);

	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
91
97.85%
1
50.00%
Dan Carpenter
2
2.15%
1
50.00%
Total
93
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
60
92.31%
4
80.00%
Yani Ioannou
5
7.69%
1
20.00%
Total
65
100.00%
5
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
60
92.31%
4
80.00%
Yani Ioannou
5
7.69%
1
20.00%
Total
65
100.00%
5
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
60
92.31%
4
80.00%
Yani Ioannou
5
7.69%
1
20.00%
Total
65
100.00%
5
100.00%



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;
	struct list_head *ent, *n;
	struct w1_slave *sl = NULL;

	mutex_lock(&md->list_mutex);

	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);
	}
	if (!sl)
		c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n");

	mutex_unlock(&md->list_mutex);

	return PAGE_SIZE - c;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
96
72.73%
4
66.67%
David Fries
31
23.48%
1
16.67%
Yani Ioannou
5
3.79%
1
16.67%
Total
132
100.00%
6
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
36
80.00%
1
33.33%
Evgeniy Polyakov
9
20.00%
2
66.67%
Total
45
100.00%
3
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
139
88.54%
2
50.00%
Evgeniy Polyakov
18
11.46%
2
50.00%
Total
157
100.00%
4
100.00%

/* Searches the slaves in the w1_master and returns a pointer or NULL.
 * Note: must not hold list_mutex
 */


struct w1_slave *w1_slave_search_device(struct w1_master *dev,
	struct w1_reg_num *rn)
{
	struct w1_slave *sl;
	mutex_lock(&dev->list_mutex);
	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) {
			mutex_unlock(&dev->list_mutex);
			return sl;
		}
	}
	mutex_unlock(&dev->list_mutex);
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
93
96.88%
2
50.00%
Evgeniy Polyakov
3
3.12%
2
50.00%
Total
96
100.00%
4
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
129
100.00%
1
100.00%
Total
129
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
45
100.00%
1
100.00%
Total
45
100.00%
1
100.00%



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) {
		result = w1_slave_detach(sl);
		/* refcnt 0 means it was detached in the call */
		if (result == 0)
			result = count;
	} 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Fries
147
100.00%
2
100.00%
Total
147
100.00%
2
100.00%


#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_RW(max_slave_count, S_IRUGO | S_IWUSR | S_IWGRP);
static W1_MASTER_ATTR_RO(attempts, S_IRUGO);
static W1_MASTER_ATTR_RO(timeout, S_IRUGO);
static W1_MASTER_ATTR_RO(timeout_us, S_IRUGO);
static W1_MASTER_ATTR_RO(pointer, S_IRUGO);
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);


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_timeout_us.attr,
	&w1_master_attribute_pointer.attr,
	&w1_master_attribute_search.attr,
	&w1_master_attribute_pullup.attr,
	&w1_master_attribute_add.attr,
	&w1_master_attribute_remove.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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
20
83.33%
2
66.67%
Greg Kroah-Hartman
4
16.67%
1
33.33%
Total
24
100.00%
3
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
18
78.26%
1
50.00%
Greg Kroah-Hartman
5
21.74%
1
50.00%
Total
23
100.00%
2
100.00%



static 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 = 0;

	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_name(dev));

	if (dev->driver != &w1_slave_driver || !sl)
		goto end;

	err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);
	if (err)
		goto end;

	err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",
			     (unsigned long long)sl->reg_num.id);
end:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Evgeniy Polyakov
176
87.56%
2
28.57%
Kay Sievers
12
5.97%
3
42.86%
Devendra Naga
10
4.98%
1
14.29%
Andrew Morton
3
1.49%
1
14.29%
Total
201
100.00%
7
100.00%



static int w1_family_notify(unsigned long action, struct w1_slave *sl)
{
	struct w1_family_ops *fops;
	int err;

	fops = sl->family->fops;

	if (!fops)
		return 0;

	switch (action) {
	case BUS_NOTIFY_ADD_DEVICE:
		/* if the family driver needs to initialize something... */
		if (fops->add_slave) {
			err = fops->add_slave(sl);
			if (err < 0) {
				dev_err(&sl->dev,
					"add_slave() call failed. err=%d\n",
					err);
				return err;