[mirror_ubuntu-jammy-kernel.git] / net / 6lowpan / core.c

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

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