[mirror_ubuntu-bionic-kernel.git] / net / ieee802154 / core.c

/*
 * Copyright (C) 2007, 2008, 2009 Siemens AG
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * 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/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>

#include <net/cfg802154.h>
#include <net/rtnetlink.h>

#include "ieee802154.h"
#include "nl802154.h"
#include "sysfs.h"
#include "core.h"

/* name for sysfs, %d is appended */
#define PHY_NAME "phy"

/* RCU-protected (and RTNL for writers) */
LIST_HEAD(cfg802154_rdev_list);
int cfg802154_rdev_list_generation;

static int wpan_phy_match(struct device *dev, const void *data)
{
	return !strcmp(dev_name(dev), (const char *)data);
}

struct wpan_phy *wpan_phy_find(const char *str)
{
	struct device *dev;

	if (WARN_ON(!str))
		return NULL;

	dev = class_find_device(&wpan_phy_class, NULL, str, wpan_phy_match);
	if (!dev)
		return NULL;

	return container_of(dev, struct wpan_phy, dev);
}
EXPORT_SYMBOL(wpan_phy_find);

struct wpan_phy_iter_data {
	int (*fn)(struct wpan_phy *phy, void *data);
	void *data;
};

static int wpan_phy_iter(struct device *dev, void *_data)
{
	struct wpan_phy_iter_data *wpid = _data;
	struct wpan_phy *phy = container_of(dev, struct wpan_phy, dev);

	return wpid->fn(phy, wpid->data);
}

int wpan_phy_for_each(int (*fn)(struct wpan_phy *phy, void *data),
		      void *data)
{
	struct wpan_phy_iter_data wpid = {
		.fn = fn,
		.data = data,
	};

	return class_for_each_device(&wpan_phy_class, NULL,
			&wpid, wpan_phy_iter);
}
EXPORT_SYMBOL(wpan_phy_for_each);

struct cfg802154_registered_device *
cfg802154_rdev_by_wpan_phy_idx(int wpan_phy_idx)
{
	struct cfg802154_registered_device *result = NULL, *rdev;

	ASSERT_RTNL();

	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
		if (rdev->wpan_phy_idx == wpan_phy_idx) {
			result = rdev;
			break;
		}
	}

	return result;
}

struct wpan_phy *wpan_phy_idx_to_wpan_phy(int wpan_phy_idx)
{
	struct cfg802154_registered_device *rdev;

	ASSERT_RTNL();

	rdev = cfg802154_rdev_by_wpan_phy_idx(wpan_phy_idx);
	if (!rdev)
		return NULL;
	return &rdev->wpan_phy;
}

struct wpan_phy *
wpan_phy_new(const struct cfg802154_ops *ops, size_t priv_size)
{
	static atomic_t wpan_phy_counter = ATOMIC_INIT(0);
	struct cfg802154_registered_device *rdev;
	size_t alloc_size;

	alloc_size = sizeof(*rdev) + priv_size;
	rdev = kzalloc(alloc_size, GFP_KERNEL);
	if (!rdev)
		return NULL;

	rdev->ops = ops;

	rdev->wpan_phy_idx = atomic_inc_return(&wpan_phy_counter);

	if (unlikely(rdev->wpan_phy_idx < 0)) {
		/* ugh, wrapped! */
		atomic_dec(&wpan_phy_counter);
		kfree(rdev);
		return NULL;
	}

	/* atomic_inc_return makes it start at 1, make it start at 0 */
	rdev->wpan_phy_idx--;

	INIT_LIST_HEAD(&rdev->wpan_dev_list);
	device_initialize(&rdev->wpan_phy.dev);
	dev_set_name(&rdev->wpan_phy.dev, PHY_NAME "%d", rdev->wpan_phy_idx);

	rdev->wpan_phy.dev.class = &wpan_phy_class;
	rdev->wpan_phy.dev.platform_data = rdev;

	wpan_phy_net_set(&rdev->wpan_phy, &init_net);

	init_waitqueue_head(&rdev->dev_wait);

	return &rdev->wpan_phy;
}
EXPORT_SYMBOL(wpan_phy_new);

int wpan_phy_register(struct wpan_phy *phy)
{
	struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
	int ret;

	rtnl_lock();
	ret = device_add(&phy->dev);
	if (ret) {
		rtnl_unlock();
		return ret;
	}

	list_add_rcu(&rdev->list, &cfg802154_rdev_list);
	cfg802154_rdev_list_generation++;

	/* TODO phy registered lock */
	rtnl_unlock();

	/* TODO nl802154 phy notify */

	return 0;
}
EXPORT_SYMBOL(wpan_phy_register);

void wpan_phy_unregister(struct wpan_phy *phy)
{
	struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);

	wait_event(rdev->dev_wait, ({
		int __count;
		rtnl_lock();
		__count = rdev->opencount;
		rtnl_unlock();
		__count == 0; }));

	rtnl_lock();
	/* TODO nl802154 phy notify */
	/* TODO phy registered lock */

	WARN_ON(!list_empty(&rdev->wpan_dev_list));

	/* First remove the hardware from everywhere, this makes
	 * it impossible to find from userspace.
	 */
	list_del_rcu(&rdev->list);
	synchronize_rcu();

	cfg802154_rdev_list_generation++;

	device_del(&phy->dev);

	rtnl_unlock();
}
EXPORT_SYMBOL(wpan_phy_unregister);

void wpan_phy_free(struct wpan_phy *phy)
{
	put_device(&phy->dev);
}
EXPORT_SYMBOL(wpan_phy_free);

int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
			   struct net *net)
{
	struct wpan_dev *wpan_dev;
	int err = 0;

	list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
		if (!wpan_dev->netdev)
			continue;
		wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
		err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
		if (err)
			break;
		wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
	}

	if (err) {
		/* failed -- clean up to old netns */
		net = wpan_phy_net(&rdev->wpan_phy);

		list_for_each_entry_continue_reverse(wpan_dev,
						     &rdev->wpan_dev_list,
						     list) {
			if (!wpan_dev->netdev)
				continue;
			wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
			err = dev_change_net_namespace(wpan_dev->netdev, net,
						       "wpan%d");
			WARN_ON(err);
			wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
		}

		return err;
	}

	wpan_phy_net_set(&rdev->wpan_phy, net);

	err = device_rename(&rdev->wpan_phy.dev, dev_name(&rdev->wpan_phy.dev));
	WARN_ON(err);

	return 0;
}

void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
{
	kfree(rdev);
}

static void
cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
			   int iftype, int num)
{
	ASSERT_RTNL();

	rdev->num_running_ifaces += num;
}

static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
					  unsigned long state, void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
	struct cfg802154_registered_device *rdev;

	if (!wpan_dev)
		return NOTIFY_DONE;

	rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);

	/* TODO WARN_ON unspec type */

	switch (state) {
		/* TODO NETDEV_DEVTYPE */
	case NETDEV_REGISTER:
		dev->features |= NETIF_F_NETNS_LOCAL;
		wpan_dev->identifier = ++rdev->wpan_dev_id;
		list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
		rdev->devlist_generation++;

		wpan_dev->netdev = dev;
		break;
	case NETDEV_DOWN:
		cfg802154_update_iface_num(rdev, wpan_dev->iftype, -1);

		rdev->opencount--;
		wake_up(&rdev->dev_wait);
		break;
	case NETDEV_UP:
		cfg802154_update_iface_num(rdev, wpan_dev->iftype, 1);

		rdev->opencount++;
		break;
	case NETDEV_UNREGISTER:
		/* It is possible to get NETDEV_UNREGISTER
		 * multiple times. To detect that, check
		 * that the interface is still on the list
		 * of registered interfaces, and only then
		 * remove and clean it up.
		 */
		if (!list_empty(&wpan_dev->list)) {
			list_del_rcu(&wpan_dev->list);
			rdev->devlist_generation++;
		}
		/* synchronize (so that we won't find this netdev
		 * from other code any more) and then clear the list
		 * head so that the above code can safely check for
		 * !list_empty() to avoid double-cleanup.
		 */
		synchronize_rcu();
		INIT_LIST_HEAD(&wpan_dev->list);
		break;
	default:
		return NOTIFY_DONE;
	}

	return NOTIFY_OK;
}

static struct notifier_block cfg802154_netdev_notifier = {
	.notifier_call = cfg802154_netdev_notifier_call,
};

static void __net_exit cfg802154_pernet_exit(struct net *net)
{
	struct cfg802154_registered_device *rdev;

	rtnl_lock();
	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
		if (net_eq(wpan_phy_net(&rdev->wpan_phy), net))
			WARN_ON(cfg802154_switch_netns(rdev, &init_net));
	}
	rtnl_unlock();
}

static struct pernet_operations cfg802154_pernet_ops = {
	.exit = cfg802154_pernet_exit,
};

static int __init wpan_phy_class_init(void)
{
	int rc;

	rc = register_pernet_device(&cfg802154_pernet_ops);
	if (rc)
		goto err;

	rc = wpan_phy_sysfs_init();
	if (rc)
		goto err_sysfs;

	rc = register_netdevice_notifier(&cfg802154_netdev_notifier);
	if (rc)
		goto err_nl;

	rc = ieee802154_nl_init();
	if (rc)
		goto err_notifier;

	rc = nl802154_init();
	if (rc)
		goto err_ieee802154_nl;

	return 0;

err_ieee802154_nl:
	ieee802154_nl_exit();

err_notifier:
	unregister_netdevice_notifier(&cfg802154_netdev_notifier);
err_nl:
	wpan_phy_sysfs_exit();
err_sysfs:
	unregister_pernet_device(&cfg802154_pernet_ops);
err:
	return rc;
}
subsys_initcall(wpan_phy_class_init);

static void __exit wpan_phy_class_exit(void)
{
	nl802154_exit();
	ieee802154_nl_exit();
	unregister_netdevice_notifier(&cfg802154_netdev_notifier);
	wpan_phy_sysfs_exit();
	unregister_pernet_device(&cfg802154_pernet_ops);
}
module_exit(wpan_phy_class_exit);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
MODULE_AUTHOR("Dmitry Eremin-Solenikov");
Commit	Line	Data
2bfb1070 DES	1	/*
	2	* Copyright (C) 2007, 2008, 2009 Siemens AG
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2
	6	* as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
2bfb1070 DES	13	*/
2bfb1070 DES	14
5a0e3ad6	15	#include <linux/slab.h>
2bfb1070 DES	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/device.h>
	19
5ad60d36	20	#include <net/cfg802154.h>
f3ada640	21	#include <net/rtnetlink.h>
2bfb1070	22
cb6b3763	23	#include "ieee802154.h"
79fe1a2a	24	#include "nl802154.h"
e23e9ec1	25	#include "sysfs.h"
a5dd1d72	26	#include "core.h"
2bfb1070	27
c4dd7471 AA	28	/* name for sysfs, %d is appended */
	29	#define PHY_NAME "phy"
	30
f3ada640	31	/* RCU-protected (and RTNL for writers) */
79fe1a2a	32	LIST_HEAD(cfg802154_rdev_list);
ca20ce20	33	int cfg802154_rdev_list_generation;
f3ada640	34
9f3b795a	35	static int wpan_phy_match(struct device dev, const void data)
2bfb1070 DES	36	{
	37	return !strcmp(dev_name(dev), (const char *)data);
	38	}
	39
	40	struct wpan_phy wpan_phy_find(const char str)
	41	{
	42	struct device *dev;
	43
	44	if (WARN_ON(!str))
	45	return NULL;
	46
9f3b795a	47	dev = class_find_device(&wpan_phy_class, NULL, str, wpan_phy_match);
2bfb1070 DES	48	if (!dev)
	49	return NULL;
	50
	51	return container_of(dev, struct wpan_phy, dev);
	52	}
	53	EXPORT_SYMBOL(wpan_phy_find);
	54
1c889f4d DES	55	struct wpan_phy_iter_data {
	56	int (fn)(struct wpan_phy phy, void *data);
	57	void *data;
	58	};
	59
	60	static int wpan_phy_iter(struct device dev, void _data)
	61	{
	62	struct wpan_phy_iter_data *wpid = _data;
	63	struct wpan_phy *phy = container_of(dev, struct wpan_phy, dev);
4710d806	64
1c889f4d DES	65	return wpid->fn(phy, wpid->data);
	66	}
	67
	68	int wpan_phy_for_each(int (fn)(struct wpan_phy phy, void *data),
4710d806	69	void *data)
1c889f4d DES	70	{
	71	struct wpan_phy_iter_data wpid = {
	72	.fn = fn,
	73	.data = data,
	74	};
	75
	76	return class_for_each_device(&wpan_phy_class, NULL,
	77	&wpid, wpan_phy_iter);
	78	}
	79	EXPORT_SYMBOL(wpan_phy_for_each);
	80
79fe1a2a AA	81	struct cfg802154_registered_device *
	82	cfg802154_rdev_by_wpan_phy_idx(int wpan_phy_idx)
	83	{
	84	struct cfg802154_registered_device result = NULL, rdev;
	85
	86	ASSERT_RTNL();
	87
	88	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
	89	if (rdev->wpan_phy_idx == wpan_phy_idx) {
	90	result = rdev;
	91	break;
	92	}
	93	}
	94
	95	return result;
	96	}
	97
a26c5fd7 AA	98	struct wpan_phy *wpan_phy_idx_to_wpan_phy(int wpan_phy_idx)
	99	{
	100	struct cfg802154_registered_device *rdev;
	101
	102	ASSERT_RTNL();
	103
	104	rdev = cfg802154_rdev_by_wpan_phy_idx(wpan_phy_idx);
	105	if (!rdev)
	106	return NULL;
	107	return &rdev->wpan_phy;
	108	}
	109
a5dd1d72	110	struct wpan_phy *
f601379f	111	wpan_phy_new(const struct cfg802154_ops *ops, size_t priv_size)
2bfb1070	112	{
53f9ee61	113	static atomic_t wpan_phy_counter = ATOMIC_INIT(0);
a5dd1d72 AA	114	struct cfg802154_registered_device *rdev;
	115	size_t alloc_size;
	116
	117	alloc_size = sizeof(*rdev) + priv_size;
	118	rdev = kzalloc(alloc_size, GFP_KERNEL);
	119	if (!rdev)
	120	return NULL;
	121
	122	rdev->ops = ops;
2bfb1070	123
53f9ee61 AA	124	rdev->wpan_phy_idx = atomic_inc_return(&wpan_phy_counter);
	125
	126	if (unlikely(rdev->wpan_phy_idx < 0)) {
	127	/* ugh, wrapped! */
	128	atomic_dec(&wpan_phy_counter);
a5dd1d72	129	kfree(rdev);
53f9ee61	130	return NULL;
2bfb1070	131	}
53f9ee61 AA	132
	133	/* atomic_inc_return makes it start at 1, make it start at 0 */
	134	rdev->wpan_phy_idx--;
2bfb1070	135
fcf39e6e	136	INIT_LIST_HEAD(&rdev->wpan_dev_list);
a5dd1d72	137	device_initialize(&rdev->wpan_phy.dev);
c4dd7471	138	dev_set_name(&rdev->wpan_phy.dev, PHY_NAME "%d", rdev->wpan_phy_idx);
2bfb1070	139
a5dd1d72 AA	140	rdev->wpan_phy.dev.class = &wpan_phy_class;
a5dd1d72 AA	141	rdev->wpan_phy.dev.platform_data = rdev;
2bfb1070	142
66e5c267 AA	143	wpan_phy_net_set(&rdev->wpan_phy, &init_net);
66e5c267 AA	144
fcf39e6e AA	145	init_waitqueue_head(&rdev->dev_wait);
fcf39e6e AA	146
a5dd1d72	147	return &rdev->wpan_phy;
2bfb1070	148	}
f601379f	149	EXPORT_SYMBOL(wpan_phy_new);
2bfb1070	150
e9cf356c	151	int wpan_phy_register(struct wpan_phy *phy)
2bfb1070	152	{
f3ada640 AA	153	struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
	154	int ret;
	155
	156	rtnl_lock();
	157	ret = device_add(&phy->dev);
	158	if (ret) {
	159	rtnl_unlock();
	160	return ret;
	161	}
	162
	163	list_add_rcu(&rdev->list, &cfg802154_rdev_list);
	164	cfg802154_rdev_list_generation++;
	165
	166	/* TODO phy registered lock */
	167	rtnl_unlock();
	168
	169	/* TODO nl802154 phy notify */
	170
	171	return 0;
2bfb1070 DES	172	}
	173	EXPORT_SYMBOL(wpan_phy_register);
	174
	175	void wpan_phy_unregister(struct wpan_phy *phy)
	176	{
f3ada640 AA	177	struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
f3ada640 AA	178
fcf39e6e AA	179	wait_event(rdev->dev_wait, ({
	180	int __count;
	181	rtnl_lock();
	182	__count = rdev->opencount;
	183	rtnl_unlock();
	184	__count == 0; }));
f3ada640 AA	185
	186	rtnl_lock();
	187	/* TODO nl802154 phy notify */
	188	/* TODO phy registered lock */
	189
fcf39e6e	190	WARN_ON(!list_empty(&rdev->wpan_dev_list));
f3ada640 AA	191
	192	/* First remove the hardware from everywhere, this makes
	193	* it impossible to find from userspace.
	194	*/
	195	list_del_rcu(&rdev->list);
	196	synchronize_rcu();
	197
	198	cfg802154_rdev_list_generation++;
	199
2bfb1070	200	device_del(&phy->dev);
f3ada640 AA	201
f3ada640 AA	202	rtnl_unlock();
2bfb1070 DES	203	}
	204	EXPORT_SYMBOL(wpan_phy_unregister);
	205
	206	void wpan_phy_free(struct wpan_phy *phy)
	207	{
	208	put_device(&phy->dev);
	209	}
	210	EXPORT_SYMBOL(wpan_phy_free);
	211
66e5c267 AA	212	int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
	213	struct net *net)
	214	{
	215	struct wpan_dev *wpan_dev;
	216	int err = 0;
	217
	218	list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
	219	if (!wpan_dev->netdev)
	220	continue;
	221	wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
	222	err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
	223	if (err)
	224	break;
	225	wpan_dev->netdev->features \|= NETIF_F_NETNS_LOCAL;
	226	}
	227
	228	if (err) {
	229	/* failed -- clean up to old netns */
	230	net = wpan_phy_net(&rdev->wpan_phy);
	231
	232	list_for_each_entry_continue_reverse(wpan_dev,
	233	&rdev->wpan_dev_list,
	234	list) {
	235	if (!wpan_dev->netdev)
	236	continue;
	237	wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
	238	err = dev_change_net_namespace(wpan_dev->netdev, net,
	239	"wpan%d");
	240	WARN_ON(err);
	241	wpan_dev->netdev->features \|= NETIF_F_NETNS_LOCAL;
	242	}
	243
	244	return err;
	245	}
	246
	247	wpan_phy_net_set(&rdev->wpan_phy, net);
	248
	249	err = device_rename(&rdev->wpan_phy.dev, dev_name(&rdev->wpan_phy.dev));
	250	WARN_ON(err);
	251
	252	return 0;
	253	}
	254
a5dd1d72 AA	255	void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
	256	{
	257	kfree(rdev);
	258	}
	259
fcf39e6e AA	260	static void
	261	cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
	262	int iftype, int num)
	263	{
	264	ASSERT_RTNL();
	265
	266	rdev->num_running_ifaces += num;
	267	}
	268
	269	static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
	270	unsigned long state, void *ptr)
	271	{
	272	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
	273	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
	274	struct cfg802154_registered_device *rdev;
	275
	276	if (!wpan_dev)
	277	return NOTIFY_DONE;
	278
	279	rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);
	280
	281	/* TODO WARN_ON unspec type */
	282
	283	switch (state) {
	284	/* TODO NETDEV_DEVTYPE */
	285	case NETDEV_REGISTER:
f9d1ce8f	286	dev->features \|= NETIF_F_NETNS_LOCAL;
fcf39e6e AA	287	wpan_dev->identifier = ++rdev->wpan_dev_id;
	288	list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
	289	rdev->devlist_generation++;
	290
	291	wpan_dev->netdev = dev;
	292	break;
	293	case NETDEV_DOWN:
	294	cfg802154_update_iface_num(rdev, wpan_dev->iftype, -1);
	295
	296	rdev->opencount--;
	297	wake_up(&rdev->dev_wait);
	298	break;
	299	case NETDEV_UP:
	300	cfg802154_update_iface_num(rdev, wpan_dev->iftype, 1);
	301
	302	rdev->opencount++;
	303	break;
	304	case NETDEV_UNREGISTER:
	305	/* It is possible to get NETDEV_UNREGISTER
	306	* multiple times. To detect that, check
	307	* that the interface is still on the list
	308	* of registered interfaces, and only then
	309	* remove and clean it up.
	310	*/
	311	if (!list_empty(&wpan_dev->list)) {
	312	list_del_rcu(&wpan_dev->list);
	313	rdev->devlist_generation++;
	314	}
	315	/* synchronize (so that we won't find this netdev
	316	* from other code any more) and then clear the list
	317	* head so that the above code can safely check for
	318	* !list_empty() to avoid double-cleanup.
	319	*/
	320	synchronize_rcu();
	321	INIT_LIST_HEAD(&wpan_dev->list);
	322	break;
	323	default:
	324	return NOTIFY_DONE;
	325	}
	326
	327	return NOTIFY_OK;
	328	}
	329
	330	static struct notifier_block cfg802154_netdev_notifier = {
	331	.notifier_call = cfg802154_netdev_notifier_call,
	332	};
	333
66e5c267 AA	334	static void __net_exit cfg802154_pernet_exit(struct net *net)
	335	{
	336	struct cfg802154_registered_device *rdev;
	337
	338	rtnl_lock();
	339	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
	340	if (net_eq(wpan_phy_net(&rdev->wpan_phy), net))
	341	WARN_ON(cfg802154_switch_netns(rdev, &init_net));
	342	}
	343	rtnl_unlock();
	344	}
	345
	346	static struct pernet_operations cfg802154_pernet_ops = {
	347	.exit = cfg802154_pernet_exit,
	348	};
	349
2bfb1070 DES	350	static int __init wpan_phy_class_init(void)
2bfb1070 DES	351	{
cb6b3763	352	int rc;
4710d806	353
66e5c267	354	rc = register_pernet_device(&cfg802154_pernet_ops);
cb6b3763 DES	355	if (rc)
	356	goto err;
	357
66e5c267 AA	358	rc = wpan_phy_sysfs_init();
	359	if (rc)
	360	goto err_sysfs;
	361
fcf39e6e	362	rc = register_netdevice_notifier(&cfg802154_netdev_notifier);
cb6b3763 DES	363	if (rc)
	364	goto err_nl;
	365
fcf39e6e AA	366	rc = ieee802154_nl_init();
	367	if (rc)
	368	goto err_notifier;
	369
79fe1a2a AA	370	rc = nl802154_init();
	371	if (rc)
	372	goto err_ieee802154_nl;
	373
cb6b3763	374	return 0;
fcf39e6e	375
79fe1a2a AA	376	err_ieee802154_nl:
	377	ieee802154_nl_exit();
	378
fcf39e6e AA	379	err_notifier:
fcf39e6e AA	380	unregister_netdevice_notifier(&cfg802154_netdev_notifier);
cb6b3763	381	err_nl:
e23e9ec1	382	wpan_phy_sysfs_exit();
66e5c267 AA	383	err_sysfs:
66e5c267 AA	384	unregister_pernet_device(&cfg802154_pernet_ops);
cb6b3763 DES	385	err:
cb6b3763 DES	386	return rc;
2bfb1070	387	}
282a3954	388	subsys_initcall(wpan_phy_class_init);
2bfb1070 DES	389
	390	static void __exit wpan_phy_class_exit(void)
	391	{
79fe1a2a	392	nl802154_exit();
cb6b3763	393	ieee802154_nl_exit();
fcf39e6e	394	unregister_netdevice_notifier(&cfg802154_netdev_notifier);
e23e9ec1	395	wpan_phy_sysfs_exit();
66e5c267	396	unregister_pernet_device(&cfg802154_pernet_ops);
2bfb1070 DES	397	}
	398	module_exit(wpan_phy_class_exit);
	399
2bfb1070	400	MODULE_LICENSE("GPL v2");
cb6b3763 DES	401	MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
cb6b3763 DES	402	MODULE_AUTHOR("Dmitry Eremin-Solenikov");
2bfb1070	403