[linux-2.6-block.git] / net / ieee802154 / core.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2007, 2008, 2009 Siemens AG
 */

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

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

	if (WARN_ON(!str))
		return NULL;

	dev = class_find_device_by_name(&wpan_phy_class, str);
	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);
	init_waitqueue_head(&rdev->wpan_phy.sync_txq);

	spin_lock_init(&rdev->wpan_phy.queue_lock);

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

static void cfg802154_free_peer_structures(struct wpan_dev *wpan_dev)
{
	struct ieee802154_pan_device *child, *tmp;

	mutex_lock(&wpan_dev->association_lock);

	kfree(wpan_dev->parent);
	wpan_dev->parent = NULL;

	list_for_each_entry_safe(child, tmp, &wpan_dev->children, node) {
		list_del(&child->node);
		kfree(child);
	}

	wpan_dev->nchildren = 0;

	mutex_unlock(&wpan_dev->association_lock);
}

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->netns_immutable = false;
		err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
		if (err)
			break;
		wpan_dev->netdev->netns_immutable = true;
	}

	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->netns_immutable = false;
			err = dev_change_net_namespace(wpan_dev->netdev, net,
						       "wpan%d");
			WARN_ON(err);
			wpan_dev->netdev->netns_immutable = true;
		}

		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->netns_immutable = true;
		wpan_dev->identifier = ++rdev->wpan_dev_id;
		list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
		rdev->devlist_generation++;
		mutex_init(&wpan_dev->association_lock);
		INIT_LIST_HEAD(&wpan_dev->children);
		wpan_dev->max_associations = SZ_16K;

		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:
		cfg802154_free_peer_structures(wpan_dev);

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