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

	ret = lowpan_dev_debugfs_init(dev);
	if (ret < 0)
		unregister_netdevice(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;

	ret = lowpan_debugfs_init();
	if (ret < 0)
		return ret;

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