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

// SPDX-License-Identifier: GPL-2.0-only
/*
 *
 * Authors:
 * (C) 2015 Pengutronix, Alexander Aring <aar@pengutronix.de>
 */

#include <linux/if_arp.h>
#include <linux/module.h>

#include <net/6lowpan.h>
#include <net/addrconf.h>

#include "6lowpan_i.h"

int lowpan_register_netdevice(struct net_device *dev,
			      enum lowpan_lltypes lltype)
{
	int i, ret;

	switch (lltype) {
	case LOWPAN_LLTYPE_IEEE802154:
		dev->addr_len = EUI64_ADDR_LEN;
		break;

	case LOWPAN_LLTYPE_BTLE:
		dev->addr_len = ETH_ALEN;
		break;
	}

	dev->type = ARPHRD_6LOWPAN;
	dev->mtu = IPV6_MIN_MTU;

	lowpan_dev(dev)->lltype = lltype;

	spin_lock_init(&lowpan_dev(dev)->ctx.lock);
	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)
		lowpan_dev(dev)->ctx.table[i].id = i;

	dev->ndisc_ops = &lowpan_ndisc_ops;

	ret = register_netdevice(dev);
	if (ret < 0)
		return ret;

	lowpan_dev_debugfs_init(dev);

	return ret;
}
EXPORT_SYMBOL(lowpan_register_netdevice);

int lowpan_register_netdev(struct net_device *dev,
			   enum lowpan_lltypes lltype)
{
	int ret;

	rtnl_lock();
	ret = lowpan_register_netdevice(dev, lltype);
	rtnl_unlock();
	return ret;
}
EXPORT_SYMBOL(lowpan_register_netdev);

void lowpan_unregister_netdevice(struct net_device *dev)
{
	unregister_netdevice(dev);
	lowpan_dev_debugfs_exit(dev);
}
EXPORT_SYMBOL(lowpan_unregister_netdevice);

void lowpan_unregister_netdev(struct net_device *dev)
{
	rtnl_lock();
	lowpan_unregister_netdevice(dev);
	rtnl_unlock();
}
EXPORT_SYMBOL(lowpan_unregister_netdev);

int addrconf_ifid_802154_6lowpan(u8 *eui, struct net_device *dev)
{
	struct wpan_dev *wpan_dev = lowpan_802154_dev(dev)->wdev->ieee802154_ptr;

	/* Set short_addr autoconfiguration if short_addr is present only */
	if (!lowpan_802154_is_valid_src_short_addr(wpan_dev->short_addr))
		return -1;

	/* For either address format, all zero addresses MUST NOT be used */
	if (wpan_dev->pan_id == cpu_to_le16(0x0000) &&
	    wpan_dev->short_addr == cpu_to_le16(0x0000))
		return -1;

	/* Alternatively, if no PAN ID is known, 16 zero bits may be used */
	if (wpan_dev->pan_id == cpu_to_le16(IEEE802154_PAN_ID_BROADCAST))
		memset(eui, 0, 2);
	else
		ieee802154_le16_to_be16(eui, &wpan_dev->pan_id);

	/* The "Universal/Local" (U/L) bit shall be set to zero */
	eui[0] &= ~2;
	eui[2] = 0;
	eui[3] = 0xFF;
	eui[4] = 0xFE;
	eui[5] = 0;
	ieee802154_le16_to_be16(&eui[6], &wpan_dev->short_addr);
	return 0;
}

static int lowpan_event(struct notifier_block *unused,
			unsigned long event, void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
	struct inet6_dev *idev;
	struct in6_addr addr;
	int i;

	if (dev->type != ARPHRD_6LOWPAN)
		return NOTIFY_DONE;

	idev = __in6_dev_get(dev);
	if (!idev)
		return NOTIFY_DONE;

	switch (event) {
	case NETDEV_UP:
	case NETDEV_CHANGE:
		/* (802.15.4 6LoWPAN short address slaac handling */
		if (lowpan_is_ll(dev, LOWPAN_LLTYPE_IEEE802154) &&
		    addrconf_ifid_802154_6lowpan(addr.s6_addr + 8, dev) == 0) {
			__ipv6_addr_set_half(&addr.s6_addr32[0],
					     htonl(0xFE800000), 0);
			addrconf_add_linklocal(idev, &addr, 0);
		}
		break;
	case NETDEV_DOWN:
		for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)
			clear_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE,
				  &lowpan_dev(dev)->ctx.table[i].flags);
		break;
	default:
		return NOTIFY_DONE;
	}

	return NOTIFY_OK;
}

static struct notifier_block lowpan_notifier = {
	.notifier_call = lowpan_event,
};

static int __init lowpan_module_init(void)
{
	int ret;

	lowpan_debugfs_init();

	ret = register_netdevice_notifier(&lowpan_notifier);
	if (ret < 0) {
		lowpan_debugfs_exit();
		return ret;
	}

	request_module_nowait("nhc_dest");
	request_module_nowait("nhc_fragment");
	request_module_nowait("nhc_hop");
	request_module_nowait("nhc_ipv6");
	request_module_nowait("nhc_mobility");
	request_module_nowait("nhc_routing");
	request_module_nowait("nhc_udp");

	return 0;
}

static void __exit lowpan_module_exit(void)
{
	lowpan_debugfs_exit();
	unregister_netdevice_notifier(&lowpan_notifier);
}

module_init(lowpan_module_init);
module_exit(lowpan_module_exit);

MODULE_LICENSE("GPL");
Commit	Line	Data
1802d0be TG	1	// SPDX-License-Identifier: GPL-2.0-only
1802d0be TG	2	/*
b72f6f51 AA	3	*
	4	* Authors:
	5	* (C) 2015 Pengutronix, Alexander Aring <aar@pengutronix.de>
	6	*/
	7
c78b8b20	8	#include <linux/if_arp.h>
4ae935c1 AA	9	#include <linux/module.h>
4ae935c1 AA	10
b72f6f51	11	#include <net/6lowpan.h>
2ad3ed59	12	#include <net/addrconf.h>
b72f6f51	13
b1815fd9 AA	14	#include "6lowpan_i.h"
b1815fd9 AA	15
00f59314 AA	16	int lowpan_register_netdevice(struct net_device *dev,
00f59314 AA	17	enum lowpan_lltypes lltype)
b72f6f51	18	{
5609c185	19	int i, ret;
b1815fd9	20
be054fc8 PF	21	switch (lltype) {
	22	case LOWPAN_LLTYPE_IEEE802154:
	23	dev->addr_len = EUI64_ADDR_LEN;
	24	break;
	25
	26	case LOWPAN_LLTYPE_BTLE:
	27	dev->addr_len = ETH_ALEN;
	28	break;
	29	}
	30
4d6a6aed AA	31	dev->type = ARPHRD_6LOWPAN;
4d6a6aed AA	32	dev->mtu = IPV6_MIN_MTU;
4d6a6aed	33
2e4d60cb	34	lowpan_dev(dev)->lltype = lltype;
00f59314	35
2e4d60cb	36	spin_lock_init(&lowpan_dev(dev)->ctx.lock);
5609c185	37	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)
2e4d60cb	38	lowpan_dev(dev)->ctx.table[i].id = i;
5609c185	39
bbe5f5ce AA	40	dev->ndisc_ops = &lowpan_ndisc_ops;
bbe5f5ce AA	41
92e17ee7	42	ret = register_netdevice(dev);
b1815fd9 AA	43	if (ret < 0)
	44	return ret;
	45
db50450d	46	lowpan_dev_debugfs_init(dev);
b1815fd9 AA	47
b1815fd9 AA	48	return ret;
00f59314 AA	49	}
	50	EXPORT_SYMBOL(lowpan_register_netdevice);
	51
	52	int lowpan_register_netdev(struct net_device *dev,
	53	enum lowpan_lltypes lltype)
	54	{
	55	int ret;
	56
	57	rtnl_lock();
	58	ret = lowpan_register_netdevice(dev, lltype);
	59	rtnl_unlock();
	60	return ret;
	61	}
	62	EXPORT_SYMBOL(lowpan_register_netdev);
	63
	64	void lowpan_unregister_netdevice(struct net_device *dev)
	65	{
	66	unregister_netdevice(dev);
b1815fd9	67	lowpan_dev_debugfs_exit(dev);
00f59314 AA	68	}
	69	EXPORT_SYMBOL(lowpan_unregister_netdevice);
	70
	71	void lowpan_unregister_netdev(struct net_device *dev)
	72	{
	73	rtnl_lock();
	74	lowpan_unregister_netdevice(dev);
	75	rtnl_unlock();
b72f6f51	76	}
00f59314	77	EXPORT_SYMBOL(lowpan_unregister_netdev);
4ae935c1	78
bbe5f5ce	79	int addrconf_ifid_802154_6lowpan(u8 eui, struct net_device dev)
2ad3ed59 AA	80	{
	81	struct wpan_dev *wpan_dev = lowpan_802154_dev(dev)->wdev->ieee802154_ptr;
	82
	83	/* Set short_addr autoconfiguration if short_addr is present only */
	84	if (!lowpan_802154_is_valid_src_short_addr(wpan_dev->short_addr))
	85	return -1;
	86
	87	/* For either address format, all zero addresses MUST NOT be used */
	88	if (wpan_dev->pan_id == cpu_to_le16(0x0000) &&
	89	wpan_dev->short_addr == cpu_to_le16(0x0000))
	90	return -1;
	91
	92	/* Alternatively, if no PAN ID is known, 16 zero bits may be used */
	93	if (wpan_dev->pan_id == cpu_to_le16(IEEE802154_PAN_ID_BROADCAST))
	94	memset(eui, 0, 2);
	95	else
	96	ieee802154_le16_to_be16(eui, &wpan_dev->pan_id);
	97
	98	/* The "Universal/Local" (U/L) bit shall be set to zero */
	99	eui[0] &= ~2;
	100	eui[2] = 0;
	101	eui[3] = 0xFF;
	102	eui[4] = 0xFE;
	103	eui[5] = 0;
	104	ieee802154_le16_to_be16(&eui[6], &wpan_dev->short_addr);
	105	return 0;
	106	}
	107
5609c185 AA	108	static int lowpan_event(struct notifier_block *unused,
	109	unsigned long event, void *ptr)
	110	{
	111	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2ad3ed59 AA	112	struct inet6_dev *idev;
2ad3ed59 AA	113	struct in6_addr addr;
5609c185 AA	114	int i;
	115
	116	if (dev->type != ARPHRD_6LOWPAN)
	117	return NOTIFY_DONE;
	118
2ad3ed59 AA	119	idev = __in6_dev_get(dev);
	120	if (!idev)
	121	return NOTIFY_DONE;
	122
5609c185	123	switch (event) {
2ad3ed59 AA	124	case NETDEV_UP:
	125	case NETDEV_CHANGE:
	126	/* (802.15.4 6LoWPAN short address slaac handling */
	127	if (lowpan_is_ll(dev, LOWPAN_LLTYPE_IEEE802154) &&
	128	addrconf_ifid_802154_6lowpan(addr.s6_addr + 8, dev) == 0) {
	129	__ipv6_addr_set_half(&addr.s6_addr32[0],
	130	htonl(0xFE800000), 0);
	131	addrconf_add_linklocal(idev, &addr, 0);
	132	}
	133	break;
5609c185 AA	134	case NETDEV_DOWN:
	135	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)
	136	clear_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE,
2e4d60cb	137	&lowpan_dev(dev)->ctx.table[i].flags);
5609c185 AA	138	break;
	139	default:
	140	return NOTIFY_DONE;
	141	}
	142
	143	return NOTIFY_OK;
	144	}
	145
	146	static struct notifier_block lowpan_notifier = {
	147	.notifier_call = lowpan_event,
	148	};
	149
4ae935c1 AA	150	static int __init lowpan_module_init(void)
4ae935c1 AA	151	{
b1815fd9 AA	152	int ret;
b1815fd9 AA	153
db50450d	154	lowpan_debugfs_init();
b1815fd9	155
5609c185 AA	156	ret = register_netdevice_notifier(&lowpan_notifier);
	157	if (ret < 0) {
	158	lowpan_debugfs_exit();
	159	return ret;
	160	}
	161
4ae935c1 AA	162	request_module_nowait("nhc_dest");
	163	request_module_nowait("nhc_fragment");
	164	request_module_nowait("nhc_hop");
	165	request_module_nowait("nhc_ipv6");
	166	request_module_nowait("nhc_mobility");
	167	request_module_nowait("nhc_routing");
	168	request_module_nowait("nhc_udp");
	169
	170	return 0;
	171	}
b1815fd9 AA	172
	173	static void __exit lowpan_module_exit(void)
	174	{
	175	lowpan_debugfs_exit();
5609c185	176	unregister_netdevice_notifier(&lowpan_notifier);
b1815fd9 AA	177	}
b1815fd9 AA	178
4ae935c1	179	module_init(lowpan_module_init);
b1815fd9	180	module_exit(lowpan_module_exit);
4ae935c1 AA	181
4ae935c1 AA	182	MODULE_LICENSE("GPL");