[linux.git] / net / mac802154 / cfg.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *
 * Authors:
 * Alexander Aring <[email protected]>
 *
 * Based on: net/mac80211/cfg.c
 */

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

#include "ieee802154_i.h"
#include "driver-ops.h"
#include "cfg.h"

static struct net_device *
ieee802154_add_iface_deprecated(struct wpan_phy *wpan_phy,
				const char *name,
				unsigned char name_assign_type, int type)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	struct net_device *dev;

	rtnl_lock();
	dev = ieee802154_if_add(local, name, name_assign_type, type,
				cpu_to_le64(0x0000000000000000ULL));
	rtnl_unlock();

	return dev;
}

static void ieee802154_del_iface_deprecated(struct wpan_phy *wpan_phy,
					    struct net_device *dev)
{
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);

	ieee802154_if_remove(sdata);
}

#ifdef CONFIG_PM
static int ieee802154_suspend(struct wpan_phy *wpan_phy)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);

	if (!local->open_count)
		goto suspend;

	ieee802154_stop_queue(&local->hw);
	synchronize_net();

	/* stop hardware - this must stop RX */
	ieee802154_stop_device(local);

suspend:
	local->suspended = true;
	return 0;
}

static int ieee802154_resume(struct wpan_phy *wpan_phy)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	int ret;

	/* nothing to do if HW shouldn't run */
	if (!local->open_count)
		goto wake_up;

	/* restart hardware */
	ret = drv_start(local);
	if (ret)
		return ret;

wake_up:
	ieee802154_wake_queue(&local->hw);
	local->suspended = false;
	return 0;
}
#else
#define ieee802154_suspend NULL
#define ieee802154_resume NULL
#endif

static int
ieee802154_add_iface(struct wpan_phy *phy, const char *name,
		     unsigned char name_assign_type,
		     enum nl802154_iftype type, __le64 extended_addr)
{
	struct ieee802154_local *local = wpan_phy_priv(phy);
	struct net_device *err;

	err = ieee802154_if_add(local, name, name_assign_type, type,
				extended_addr);
	return PTR_ERR_OR_ZERO(err);
}

static int
ieee802154_del_iface(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev)
{
	ieee802154_if_remove(IEEE802154_WPAN_DEV_TO_SUB_IF(wpan_dev));

	return 0;
}

static int
ieee802154_set_channel(struct wpan_phy *wpan_phy, u8 page, u8 channel)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	int ret;

	ASSERT_RTNL();

	if (wpan_phy->current_page == page &&
	    wpan_phy->current_channel == channel)
		return 0;

	ret = drv_set_channel(local, page, channel);
	if (!ret) {
		wpan_phy->current_page = page;
		wpan_phy->current_channel = channel;
	}

	return ret;
}

static int
ieee802154_set_cca_mode(struct wpan_phy *wpan_phy,
			const struct wpan_phy_cca *cca)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	int ret;

	ASSERT_RTNL();

	if (wpan_phy_cca_cmp(&wpan_phy->cca, cca))
		return 0;

	ret = drv_set_cca_mode(local, cca);
	if (!ret)
		wpan_phy->cca = *cca;

	return ret;
}

static int
ieee802154_set_cca_ed_level(struct wpan_phy *wpan_phy, s32 ed_level)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	int ret;

	ASSERT_RTNL();

	if (wpan_phy->cca_ed_level == ed_level)
		return 0;

	ret = drv_set_cca_ed_level(local, ed_level);
	if (!ret)
		wpan_phy->cca_ed_level = ed_level;

	return ret;
}

static int
ieee802154_set_tx_power(struct wpan_phy *wpan_phy, s32 power)
{
	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	int ret;

	ASSERT_RTNL();

	if (wpan_phy->transmit_power == power)
		return 0;

	ret = drv_set_tx_power(local, power);
	if (!ret)
		wpan_phy->transmit_power = power;

	return ret;
}

static int
ieee802154_set_pan_id(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
		      __le16 pan_id)
{
	int ret;

	ASSERT_RTNL();

	if (wpan_dev->pan_id == pan_id)
		return 0;

	ret = mac802154_wpan_update_llsec(wpan_dev->netdev);
	if (!ret)
		wpan_dev->pan_id = pan_id;

	return ret;
}

static int
ieee802154_set_backoff_exponent(struct wpan_phy *wpan_phy,
				struct wpan_dev *wpan_dev,
				u8 min_be, u8 max_be)
{
	ASSERT_RTNL();

	wpan_dev->min_be = min_be;
	wpan_dev->max_be = max_be;
	return 0;
}

static int
ieee802154_set_short_addr(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
			  __le16 short_addr)
{
	ASSERT_RTNL();

	wpan_dev->short_addr = short_addr;
	return 0;
}

static int
ieee802154_set_max_csma_backoffs(struct wpan_phy *wpan_phy,
				 struct wpan_dev *wpan_dev,
				 u8 max_csma_backoffs)
{
	ASSERT_RTNL();

	wpan_dev->csma_retries = max_csma_backoffs;
	return 0;
}

static int
ieee802154_set_max_frame_retries(struct wpan_phy *wpan_phy,
				 struct wpan_dev *wpan_dev,
				 s8 max_frame_retries)
{
	ASSERT_RTNL();

	wpan_dev->frame_retries = max_frame_retries;
	return 0;
}

static int
ieee802154_set_lbt_mode(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
			bool mode)
{
	ASSERT_RTNL();

	wpan_dev->lbt = mode;
	return 0;
}

static int
ieee802154_set_ackreq_default(struct wpan_phy *wpan_phy,
			      struct wpan_dev *wpan_dev, bool ackreq)
{
	ASSERT_RTNL();

	wpan_dev->ackreq = ackreq;
	return 0;
}

#ifdef CONFIG_IEEE802154_NL802154_EXPERIMENTAL
static void
ieee802154_get_llsec_table(struct wpan_phy *wpan_phy,
			   struct wpan_dev *wpan_dev,
			   struct ieee802154_llsec_table **table)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);

	*table = &sdata->sec.table;
}

static void
ieee802154_lock_llsec_table(struct wpan_phy *wpan_phy,
			    struct wpan_dev *wpan_dev)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);

	mutex_lock(&sdata->sec_mtx);
}

static void
ieee802154_unlock_llsec_table(struct wpan_phy *wpan_phy,
			      struct wpan_dev *wpan_dev)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);

	mutex_unlock(&sdata->sec_mtx);
}

static int
ieee802154_set_llsec_params(struct wpan_phy *wpan_phy,
			    struct wpan_dev *wpan_dev,
			    const struct ieee802154_llsec_params *params,
			    int changed)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_set_params(&sdata->sec, params, changed);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_get_llsec_params(struct wpan_phy *wpan_phy,
			    struct wpan_dev *wpan_dev,
			    struct ieee802154_llsec_params *params)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_get_params(&sdata->sec, params);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_add_llsec_key(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
			 const struct ieee802154_llsec_key_id *id,
			 const struct ieee802154_llsec_key *key)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_key_add(&sdata->sec, id, key);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_del_llsec_key(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
			 const struct ieee802154_llsec_key_id *id)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_key_del(&sdata->sec, id);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_add_seclevel(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
			const struct ieee802154_llsec_seclevel *sl)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_seclevel_add(&sdata->sec, sl);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_del_seclevel(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
			const struct ieee802154_llsec_seclevel *sl)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_seclevel_del(&sdata->sec, sl);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_add_device(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
		      const struct ieee802154_llsec_device *dev_desc)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_dev_add(&sdata->sec, dev_desc);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_del_device(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
		      __le64 extended_addr)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_dev_del(&sdata->sec, extended_addr);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_add_devkey(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
		      __le64 extended_addr,
		      const struct ieee802154_llsec_device_key *key)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_devkey_add(&sdata->sec, extended_addr, key);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}

static int
ieee802154_del_devkey(struct wpan_phy *wpan_phy, struct wpan_dev *wpan_dev,
		      __le64 extended_addr,
		      const struct ieee802154_llsec_device_key *key)
{
	struct net_device *dev = wpan_dev->netdev;
	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	int res;

	mutex_lock(&sdata->sec_mtx);
	res = mac802154_llsec_devkey_del(&sdata->sec, extended_addr, key);
	mutex_unlock(&sdata->sec_mtx);

	return res;
}
#endif /* CONFIG_IEEE802154_NL802154_EXPERIMENTAL */

const struct cfg802154_ops mac802154_config_ops = {
	.add_virtual_intf_deprecated = ieee802154_add_iface_deprecated,
	.del_virtual_intf_deprecated = ieee802154_del_iface_deprecated,
	.suspend = ieee802154_suspend,
	.resume = ieee802154_resume,
	.add_virtual_intf = ieee802154_add_iface,
	.del_virtual_intf = ieee802154_del_iface,
	.set_channel = ieee802154_set_channel,
	.set_cca_mode = ieee802154_set_cca_mode,
	.set_cca_ed_level = ieee802154_set_cca_ed_level,
	.set_tx_power = ieee802154_set_tx_power,
	.set_pan_id = ieee802154_set_pan_id,
	.set_short_addr = ieee802154_set_short_addr,
	.set_backoff_exponent = ieee802154_set_backoff_exponent,
	.set_max_csma_backoffs = ieee802154_set_max_csma_backoffs,
	.set_max_frame_retries = ieee802154_set_max_frame_retries,
	.set_lbt_mode = ieee802154_set_lbt_mode,
	.set_ackreq_default = ieee802154_set_ackreq_default,
#ifdef CONFIG_IEEE802154_NL802154_EXPERIMENTAL
	.get_llsec_table = ieee802154_get_llsec_table,
	.lock_llsec_table = ieee802154_lock_llsec_table,
	.unlock_llsec_table = ieee802154_unlock_llsec_table,
	/* TODO above */
	.set_llsec_params = ieee802154_set_llsec_params,
	.get_llsec_params = ieee802154_get_llsec_params,
	.add_llsec_key = ieee802154_add_llsec_key,
	.del_llsec_key = ieee802154_del_llsec_key,
	.add_seclevel = ieee802154_add_seclevel,
	.del_seclevel = ieee802154_del_seclevel,
	.add_device = ieee802154_add_device,
	.del_device = ieee802154_del_device,
	.add_devkey = ieee802154_add_devkey,
	.del_devkey = ieee802154_del_devkey,
#endif /* CONFIG_IEEE802154_NL802154_EXPERIMENTAL */
};
Commit	Line	Data
1802d0be TG	1	// SPDX-License-Identifier: GPL-2.0-only
1802d0be TG	2	/*
1201cd22 AA	3	*
	4	* Authors:
	5	* Alexander Aring <[email protected]>
	6	*
	7	* Based on: net/mac80211/cfg.c
	8	*/
	9
d5ae67ba	10	#include <net/rtnetlink.h>
1201cd22 AA	11	#include <net/cfg802154.h>
1201cd22 AA	12
4a9a816a	13	#include "ieee802154_i.h"
ab0bd561	14	#include "driver-ops.h"
fdd2068a	15	#include "cfg.h"
4a9a816a AA	16
	17	static struct net_device *
	18	ieee802154_add_iface_deprecated(struct wpan_phy *wpan_phy,
5b4a1039 VB	19	const char *name,
5b4a1039 VB	20	unsigned char name_assign_type, int type)
4a9a816a	21	{
986a8abf	22	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
d5ae67ba	23	struct net_device *dev;
986a8abf	24
d5ae67ba	25	rtnl_lock();
5b4a1039	26	dev = ieee802154_if_add(local, name, name_assign_type, type,
0e57547e	27	cpu_to_le64(0x0000000000000000ULL));
d5ae67ba AA	28	rtnl_unlock();
	29
	30	return dev;
4a9a816a AA	31	}
	32
	33	static void ieee802154_del_iface_deprecated(struct wpan_phy *wpan_phy,
	34	struct net_device *dev)
	35	{
b210b187 AA	36	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	37
	38	ieee802154_if_remove(sdata);
4a9a816a AA	39	}
4a9a816a AA	40
3cf24cf8 AA	41	#ifdef CONFIG_PM
	42	static int ieee802154_suspend(struct wpan_phy *wpan_phy)
	43	{
	44	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	45
	46	if (!local->open_count)
	47	goto suspend;
	48
	49	ieee802154_stop_queue(&local->hw);
	50	synchronize_net();
	51
	52	/* stop hardware - this must stop RX */
	53	ieee802154_stop_device(local);
	54
	55	suspend:
	56	local->suspended = true;
	57	return 0;
	58	}
	59
	60	static int ieee802154_resume(struct wpan_phy *wpan_phy)
	61	{
	62	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	63	int ret;
	64
	65	/* nothing to do if HW shouldn't run */
	66	if (!local->open_count)
	67	goto wake_up;
	68
	69	/* restart hardware */
	70	ret = drv_start(local);
	71	if (ret)
	72	return ret;
	73
	74	wake_up:
	75	ieee802154_wake_queue(&local->hw);
	76	local->suspended = false;
	77	return 0;
	78	}
	79	#else
	80	#define ieee802154_suspend NULL
	81	#define ieee802154_resume NULL
	82	#endif
	83
f3ea5e44 AA	84	static int
f3ea5e44 AA	85	ieee802154_add_iface(struct wpan_phy phy, const char name,
5b4a1039	86	unsigned char name_assign_type,
0e57547e	87	enum nl802154_iftype type, __le64 extended_addr)
f3ea5e44 AA	88	{
	89	struct ieee802154_local *local = wpan_phy_priv(phy);
	90	struct net_device *err;
	91
5b4a1039 VB	92	err = ieee802154_if_add(local, name, name_assign_type, type,
5b4a1039 VB	93	extended_addr);
36cf942a	94	return PTR_ERR_OR_ZERO(err);
f3ea5e44 AA	95	}
f3ea5e44 AA	96
b821ecd4 AA	97	static int
	98	ieee802154_del_iface(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev)
	99	{
	100	ieee802154_if_remove(IEEE802154_WPAN_DEV_TO_SUB_IF(wpan_dev));
	101
	102	return 0;
	103	}
	104
ab0bd561	105	static int
6d5fb877	106	ieee802154_set_channel(struct wpan_phy *wpan_phy, u8 page, u8 channel)
ab0bd561 AA	107	{
	108	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	109	int ret;
	110
	111	ASSERT_RTNL();
	112
791021bf AA	113	if (wpan_phy->current_page == page &&
	114	wpan_phy->current_channel == channel)
	115	return 0;
	116
ab0bd561 AA	117	ret = drv_set_channel(local, page, channel);
	118	if (!ret) {
	119	wpan_phy->current_page = page;
	120	wpan_phy->current_channel = channel;
	121	}
	122
	123	return ret;
	124	}
	125
ba2a9506 AA	126	static int
	127	ieee802154_set_cca_mode(struct wpan_phy *wpan_phy,
	128	const struct wpan_phy_cca *cca)
	129	{
	130	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	131	int ret;
	132
	133	ASSERT_RTNL();
	134
791021bf AA	135	if (wpan_phy_cca_cmp(&wpan_phy->cca, cca))
	136	return 0;
	137
ba2a9506 AA	138	ret = drv_set_cca_mode(local, cca);
	139	if (!ret)
	140	wpan_phy->cca = *cca;
	141
	142	return ret;
	143	}
	144
b69644c1 AA	145	static int
	146	ieee802154_set_cca_ed_level(struct wpan_phy *wpan_phy, s32 ed_level)
	147	{
	148	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	149	int ret;
	150
	151	ASSERT_RTNL();
	152
	153	if (wpan_phy->cca_ed_level == ed_level)
	154	return 0;
	155
	156	ret = drv_set_cca_ed_level(local, ed_level);
	157	if (!ret)
	158	wpan_phy->cca_ed_level = ed_level;
	159
	160	return ret;
	161	}
	162
0f999b09 VB	163	static int
	164	ieee802154_set_tx_power(struct wpan_phy *wpan_phy, s32 power)
	165	{
	166	struct ieee802154_local *local = wpan_phy_priv(wpan_phy);
	167	int ret;
	168
	169	ASSERT_RTNL();
	170
	171	if (wpan_phy->transmit_power == power)
	172	return 0;
	173
	174	ret = drv_set_tx_power(local, power);
	175	if (!ret)
	176	wpan_phy->transmit_power = power;
	177
	178	return ret;
	179	}
	180
6d5fb877 AA	181	static int
6d5fb877 AA	182	ieee802154_set_pan_id(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
ee7b9053	183	__le16 pan_id)
702bf371	184	{
d77b4852 AA	185	int ret;
d77b4852 AA	186
702bf371 AA	187	ASSERT_RTNL();
702bf371 AA	188
791021bf AA	189	if (wpan_dev->pan_id == pan_id)
	190	return 0;
	191
d77b4852 AA	192	ret = mac802154_wpan_update_llsec(wpan_dev->netdev);
	193	if (!ret)
	194	wpan_dev->pan_id = pan_id;
	195
	196	return ret;
702bf371 AA	197	}
702bf371 AA	198
656a999e AA	199	static int
	200	ieee802154_set_backoff_exponent(struct wpan_phy *wpan_phy,
	201	struct wpan_dev *wpan_dev,
6d5fb877	202	u8 min_be, u8 max_be)
656a999e	203	{
656a999e AA	204	ASSERT_RTNL();
656a999e AA	205
656a999e AA	206	wpan_dev->min_be = min_be;
	207	wpan_dev->max_be = max_be;
	208	return 0;
	209	}
	210
9830c62a AA	211	static int
9830c62a AA	212	ieee802154_set_short_addr(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
ee7b9053	213	__le16 short_addr)
9830c62a AA	214	{
	215	ASSERT_RTNL();
	216
ee7b9053	217	wpan_dev->short_addr = short_addr;
9830c62a AA	218	return 0;
	219	}
	220
6d5fb877 AA	221	static int
	222	ieee802154_set_max_csma_backoffs(struct wpan_phy *wpan_phy,
	223	struct wpan_dev *wpan_dev,
	224	u8 max_csma_backoffs)
a01ba765	225	{
a01ba765 AA	226	ASSERT_RTNL();
a01ba765 AA	227
a01ba765 AA	228	wpan_dev->csma_retries = max_csma_backoffs;
	229	return 0;
	230	}
	231
6d5fb877 AA	232	static int
	233	ieee802154_set_max_frame_retries(struct wpan_phy *wpan_phy,
	234	struct wpan_dev *wpan_dev,
	235	s8 max_frame_retries)
17a3a46b	236	{
17a3a46b AA	237	ASSERT_RTNL();
17a3a46b AA	238
17a3a46b AA	239	wpan_dev->frame_retries = max_frame_retries;
	240	return 0;
	241	}
	242
6d5fb877 AA	243	static int
	244	ieee802154_set_lbt_mode(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
	245	bool mode)
c8937a1d	246	{
c8937a1d AA	247	ASSERT_RTNL();
c8937a1d AA	248
c8937a1d AA	249	wpan_dev->lbt = mode;
	250	return 0;
	251	}
	252
c91208d8 AA	253	static int
	254	ieee802154_set_ackreq_default(struct wpan_phy *wpan_phy,
	255	struct wpan_dev *wpan_dev, bool ackreq)
	256	{
	257	ASSERT_RTNL();
	258
	259	wpan_dev->ackreq = ackreq;
	260	return 0;
	261	}
	262
a26c5fd7 AA	263	#ifdef CONFIG_IEEE802154_NL802154_EXPERIMENTAL
	264	static void
	265	ieee802154_get_llsec_table(struct wpan_phy *wpan_phy,
	266	struct wpan_dev *wpan_dev,
	267	struct ieee802154_llsec_table **table)
	268	{
	269	struct net_device *dev = wpan_dev->netdev;
	270	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	271
	272	*table = &sdata->sec.table;
	273	}
	274
	275	static void
	276	ieee802154_lock_llsec_table(struct wpan_phy *wpan_phy,
	277	struct wpan_dev *wpan_dev)
	278	{
	279	struct net_device *dev = wpan_dev->netdev;
	280	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	281
	282	mutex_lock(&sdata->sec_mtx);
	283	}
	284
	285	static void
	286	ieee802154_unlock_llsec_table(struct wpan_phy *wpan_phy,
	287	struct wpan_dev *wpan_dev)
	288	{
	289	struct net_device *dev = wpan_dev->netdev;
	290	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	291
	292	mutex_unlock(&sdata->sec_mtx);
	293	}
	294
	295	static int
	296	ieee802154_set_llsec_params(struct wpan_phy *wpan_phy,
	297	struct wpan_dev *wpan_dev,
	298	const struct ieee802154_llsec_params *params,
	299	int changed)
	300	{
	301	struct net_device *dev = wpan_dev->netdev;
	302	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	303	int res;
	304
	305	mutex_lock(&sdata->sec_mtx);
	306	res = mac802154_llsec_set_params(&sdata->sec, params, changed);
	307	mutex_unlock(&sdata->sec_mtx);
	308
	309	return res;
	310	}
	311
	312	static int
	313	ieee802154_get_llsec_params(struct wpan_phy *wpan_phy,
	314	struct wpan_dev *wpan_dev,
	315	struct ieee802154_llsec_params *params)
	316	{
	317	struct net_device *dev = wpan_dev->netdev;
	318	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
	319	int res;
	320
	321	mutex_lock(&sdata->sec_mtx);
	322	res = mac802154_llsec_get_params(&sdata->sec, params);
	323	mutex_unlock(&sdata->sec_mtx);
	324
	325	return res;
	326	}
327
328	static int
329	ieee802154_add_llsec_key(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
330	const struct ieee802154_llsec_key_id *id,
331	const struct ieee802154_llsec_key *key)
332	{
333	struct net_device *dev = wpan_dev->netdev;
334	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
335	int res;
336
337	mutex_lock(&sdata->sec_mtx);
338	res = mac802154_llsec_key_add(&sdata->sec, id, key);
339	mutex_unlock(&sdata->sec_mtx);
340
341	return res;
342	}
343
344	static int
345	ieee802154_del_llsec_key(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
346	const struct ieee802154_llsec_key_id *id)
347	{
348	struct net_device *dev = wpan_dev->netdev;
349	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
350	int res;
351
352	mutex_lock(&sdata->sec_mtx);
353	res = mac802154_llsec_key_del(&sdata->sec, id);
354	mutex_unlock(&sdata->sec_mtx);
355
356	return res;
357	}
358
359	static int
360	ieee802154_add_seclevel(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
361	const struct ieee802154_llsec_seclevel *sl)
362	{
363	struct net_device *dev = wpan_dev->netdev;
364	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
365	int res;
366
367	mutex_lock(&sdata->sec_mtx);
368	res = mac802154_llsec_seclevel_add(&sdata->sec, sl);
369	mutex_unlock(&sdata->sec_mtx);
370
371	return res;
372	}
373
374	static int
375	ieee802154_del_seclevel(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
376	const struct ieee802154_llsec_seclevel *sl)
377	{
378	struct net_device *dev = wpan_dev->netdev;
379	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
380	int res;
381
382	mutex_lock(&sdata->sec_mtx);
383	res = mac802154_llsec_seclevel_del(&sdata->sec, sl);
384	mutex_unlock(&sdata->sec_mtx);
385
386	return res;
387	}
388
389	static int
390	ieee802154_add_device(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
391	const struct ieee802154_llsec_device *dev_desc)
392	{
393	struct net_device *dev = wpan_dev->netdev;
394	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
395	int res;
396
397	mutex_lock(&sdata->sec_mtx);
398	res = mac802154_llsec_dev_add(&sdata->sec, dev_desc);
399	mutex_unlock(&sdata->sec_mtx);
400
401	return res;
402	}
403
404	static int
405	ieee802154_del_device(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
406	__le64 extended_addr)
407	{
408	struct net_device *dev = wpan_dev->netdev;
409	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
410	int res;
411
412	mutex_lock(&sdata->sec_mtx);
413	res = mac802154_llsec_dev_del(&sdata->sec, extended_addr);
414	mutex_unlock(&sdata->sec_mtx);
415
416	return res;
417	}
418
419	static int
420	ieee802154_add_devkey(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
421	__le64 extended_addr,
422	const struct ieee802154_llsec_device_key *key)
423	{
424	struct net_device *dev = wpan_dev->netdev;
425	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
426	int res;
427
428	mutex_lock(&sdata->sec_mtx);
429	res = mac802154_llsec_devkey_add(&sdata->sec, extended_addr, key);
430	mutex_unlock(&sdata->sec_mtx);
431
432	return res;
433	}
434
435	static int
436	ieee802154_del_devkey(struct wpan_phy wpan_phy, struct wpan_dev wpan_dev,
437	__le64 extended_addr,
438	const struct ieee802154_llsec_device_key *key)
439	{
440	struct net_device *dev = wpan_dev->netdev;
441	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
442	int res;
443
444	mutex_lock(&sdata->sec_mtx);
445	res = mac802154_llsec_devkey_del(&sdata->sec, extended_addr, key);
446	mutex_unlock(&sdata->sec_mtx);
447
448	return res;
449	}
450	#endif /* CONFIG_IEEE802154_NL802154_EXPERIMENTAL */
451
1201cd22	452	const struct cfg802154_ops mac802154_config_ops = {
4a9a816a AA	453	.add_virtual_intf_deprecated = ieee802154_add_iface_deprecated,
4a9a816a AA	454	.del_virtual_intf_deprecated = ieee802154_del_iface_deprecated,
3cf24cf8 AA	455	.suspend = ieee802154_suspend,
3cf24cf8 AA	456	.resume = ieee802154_resume,
f3ea5e44	457	.add_virtual_intf = ieee802154_add_iface,
b821ecd4	458	.del_virtual_intf = ieee802154_del_iface,
ab0bd561	459	.set_channel = ieee802154_set_channel,
ba2a9506	460	.set_cca_mode = ieee802154_set_cca_mode,
b69644c1	461	.set_cca_ed_level = ieee802154_set_cca_ed_level,
0f999b09	462	.set_tx_power = ieee802154_set_tx_power,
702bf371	463	.set_pan_id = ieee802154_set_pan_id,
9830c62a	464	.set_short_addr = ieee802154_set_short_addr,
656a999e	465	.set_backoff_exponent = ieee802154_set_backoff_exponent,
a01ba765	466	.set_max_csma_backoffs = ieee802154_set_max_csma_backoffs,
17a3a46b	467	.set_max_frame_retries = ieee802154_set_max_frame_retries,
c8937a1d	468	.set_lbt_mode = ieee802154_set_lbt_mode,
c91208d8	469	.set_ackreq_default = ieee802154_set_ackreq_default,
a26c5fd7 AA	470	#ifdef CONFIG_IEEE802154_NL802154_EXPERIMENTAL
	471	.get_llsec_table = ieee802154_get_llsec_table,
	472	.lock_llsec_table = ieee802154_lock_llsec_table,
	473	.unlock_llsec_table = ieee802154_unlock_llsec_table,
	474	/* TODO above */
	475	.set_llsec_params = ieee802154_set_llsec_params,
	476	.get_llsec_params = ieee802154_get_llsec_params,
	477	.add_llsec_key = ieee802154_add_llsec_key,
	478	.del_llsec_key = ieee802154_del_llsec_key,
	479	.add_seclevel = ieee802154_add_seclevel,
	480	.del_seclevel = ieee802154_del_seclevel,
	481	.add_device = ieee802154_add_device,
	482	.del_device = ieee802154_del_device,
	483	.add_devkey = ieee802154_add_devkey,
	484	.del_devkey = ieee802154_del_devkey,
	485	#endif /* CONFIG_IEEE802154_NL802154_EXPERIMENTAL */
1201cd22	486	};