xref: /openbmc/linux/net/ieee802154/nl802154.c (revision d7a3d85e)
1 /* This program is free software; you can redistribute it and/or modify
2  * it under the terms of the GNU General Public License version 2
3  * as published by the Free Software Foundation.
4  *
5  * This program is distributed in the hope that it will be useful,
6  * but WITHOUT ANY WARRANTY; without even the implied warranty of
7  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
8  * GNU General Public License for more details.
9  *
10  * Authors:
11  * Alexander Aring <aar@pengutronix.de>
12  *
13  * Based on: net/wireless/nl80211.c
14  */
15 
16 #include <linux/rtnetlink.h>
17 
18 #include <net/cfg802154.h>
19 #include <net/genetlink.h>
20 #include <net/mac802154.h>
21 #include <net/netlink.h>
22 #include <net/nl802154.h>
23 #include <net/sock.h>
24 
25 #include "nl802154.h"
26 #include "rdev-ops.h"
27 #include "core.h"
28 
29 static int nl802154_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
30 			     struct genl_info *info);
31 
32 static void nl802154_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
33 			       struct genl_info *info);
34 
35 /* the netlink family */
36 static struct genl_family nl802154_fam = {
37 	.id = GENL_ID_GENERATE,		/* don't bother with a hardcoded ID */
38 	.name = NL802154_GENL_NAME,	/* have users key off the name instead */
39 	.hdrsize = 0,			/* no private header */
40 	.version = 1,			/* no particular meaning now */
41 	.maxattr = NL802154_ATTR_MAX,
42 	.netnsok = true,
43 	.pre_doit = nl802154_pre_doit,
44 	.post_doit = nl802154_post_doit,
45 };
46 
47 /* multicast groups */
48 enum nl802154_multicast_groups {
49 	NL802154_MCGRP_CONFIG,
50 };
51 
52 static const struct genl_multicast_group nl802154_mcgrps[] = {
53 	[NL802154_MCGRP_CONFIG] = { .name = "config", },
54 };
55 
56 /* returns ERR_PTR values */
57 static struct wpan_dev *
58 __cfg802154_wpan_dev_from_attrs(struct net *netns, struct nlattr **attrs)
59 {
60 	struct cfg802154_registered_device *rdev;
61 	struct wpan_dev *result = NULL;
62 	bool have_ifidx = attrs[NL802154_ATTR_IFINDEX];
63 	bool have_wpan_dev_id = attrs[NL802154_ATTR_WPAN_DEV];
64 	u64 wpan_dev_id;
65 	int wpan_phy_idx = -1;
66 	int ifidx = -1;
67 
68 	ASSERT_RTNL();
69 
70 	if (!have_ifidx && !have_wpan_dev_id)
71 		return ERR_PTR(-EINVAL);
72 
73 	if (have_ifidx)
74 		ifidx = nla_get_u32(attrs[NL802154_ATTR_IFINDEX]);
75 	if (have_wpan_dev_id) {
76 		wpan_dev_id = nla_get_u64(attrs[NL802154_ATTR_WPAN_DEV]);
77 		wpan_phy_idx = wpan_dev_id >> 32;
78 	}
79 
80 	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
81 		struct wpan_dev *wpan_dev;
82 
83 		/* TODO netns compare */
84 
85 		if (have_wpan_dev_id && rdev->wpan_phy_idx != wpan_phy_idx)
86 			continue;
87 
88 		list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
89 			if (have_ifidx && wpan_dev->netdev &&
90 			    wpan_dev->netdev->ifindex == ifidx) {
91 				result = wpan_dev;
92 				break;
93 			}
94 			if (have_wpan_dev_id &&
95 			    wpan_dev->identifier == (u32)wpan_dev_id) {
96 				result = wpan_dev;
97 				break;
98 			}
99 		}
100 
101 		if (result)
102 			break;
103 	}
104 
105 	if (result)
106 		return result;
107 
108 	return ERR_PTR(-ENODEV);
109 }
110 
111 static struct cfg802154_registered_device *
112 __cfg802154_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
113 {
114 	struct cfg802154_registered_device *rdev = NULL, *tmp;
115 	struct net_device *netdev;
116 
117 	ASSERT_RTNL();
118 
119 	if (!attrs[NL802154_ATTR_WPAN_PHY] &&
120 	    !attrs[NL802154_ATTR_IFINDEX] &&
121 	    !attrs[NL802154_ATTR_WPAN_DEV])
122 		return ERR_PTR(-EINVAL);
123 
124 	if (attrs[NL802154_ATTR_WPAN_PHY])
125 		rdev = cfg802154_rdev_by_wpan_phy_idx(
126 				nla_get_u32(attrs[NL802154_ATTR_WPAN_PHY]));
127 
128 	if (attrs[NL802154_ATTR_WPAN_DEV]) {
129 		u64 wpan_dev_id = nla_get_u64(attrs[NL802154_ATTR_WPAN_DEV]);
130 		struct wpan_dev *wpan_dev;
131 		bool found = false;
132 
133 		tmp = cfg802154_rdev_by_wpan_phy_idx(wpan_dev_id >> 32);
134 		if (tmp) {
135 			/* make sure wpan_dev exists */
136 			list_for_each_entry(wpan_dev, &tmp->wpan_dev_list, list) {
137 				if (wpan_dev->identifier != (u32)wpan_dev_id)
138 					continue;
139 				found = true;
140 				break;
141 			}
142 
143 			if (!found)
144 				tmp = NULL;
145 
146 			if (rdev && tmp != rdev)
147 				return ERR_PTR(-EINVAL);
148 			rdev = tmp;
149 		}
150 	}
151 
152 	if (attrs[NL802154_ATTR_IFINDEX]) {
153 		int ifindex = nla_get_u32(attrs[NL802154_ATTR_IFINDEX]);
154 
155 		netdev = __dev_get_by_index(netns, ifindex);
156 		if (netdev) {
157 			if (netdev->ieee802154_ptr)
158 				tmp = wpan_phy_to_rdev(
159 						netdev->ieee802154_ptr->wpan_phy);
160 			else
161 				tmp = NULL;
162 
163 			/* not wireless device -- return error */
164 			if (!tmp)
165 				return ERR_PTR(-EINVAL);
166 
167 			/* mismatch -- return error */
168 			if (rdev && tmp != rdev)
169 				return ERR_PTR(-EINVAL);
170 
171 			rdev = tmp;
172 		}
173 	}
174 
175 	if (!rdev)
176 		return ERR_PTR(-ENODEV);
177 
178 	/* TODO netns compare */
179 
180 	return rdev;
181 }
182 
183 /* This function returns a pointer to the driver
184  * that the genl_info item that is passed refers to.
185  *
186  * The result of this can be a PTR_ERR and hence must
187  * be checked with IS_ERR() for errors.
188  */
189 static struct cfg802154_registered_device *
190 cfg802154_get_dev_from_info(struct net *netns, struct genl_info *info)
191 {
192 	return __cfg802154_rdev_from_attrs(netns, info->attrs);
193 }
194 
195 /* policy for the attributes */
196 static const struct nla_policy nl802154_policy[NL802154_ATTR_MAX+1] = {
197 	[NL802154_ATTR_WPAN_PHY] = { .type = NLA_U32 },
198 	[NL802154_ATTR_WPAN_PHY_NAME] = { .type = NLA_NUL_STRING,
199 					  .len = 20-1 },
200 
201 	[NL802154_ATTR_IFINDEX] = { .type = NLA_U32 },
202 	[NL802154_ATTR_IFTYPE] = { .type = NLA_U32 },
203 	[NL802154_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
204 
205 	[NL802154_ATTR_WPAN_DEV] = { .type = NLA_U64 },
206 
207 	[NL802154_ATTR_PAGE] = { .type = NLA_U8, },
208 	[NL802154_ATTR_CHANNEL] = { .type = NLA_U8, },
209 
210 	[NL802154_ATTR_TX_POWER] = { .type = NLA_S8, },
211 
212 	[NL802154_ATTR_CCA_MODE] = { .type = NLA_U32, },
213 	[NL802154_ATTR_CCA_OPT] = { .type = NLA_U32, },
214 
215 	[NL802154_ATTR_SUPPORTED_CHANNEL] = { .type = NLA_U32, },
216 
217 	[NL802154_ATTR_PAN_ID] = { .type = NLA_U16, },
218 	[NL802154_ATTR_EXTENDED_ADDR] = { .type = NLA_U64 },
219 	[NL802154_ATTR_SHORT_ADDR] = { .type = NLA_U16, },
220 
221 	[NL802154_ATTR_MIN_BE] = { .type = NLA_U8, },
222 	[NL802154_ATTR_MAX_BE] = { .type = NLA_U8, },
223 	[NL802154_ATTR_MAX_CSMA_BACKOFFS] = { .type = NLA_U8, },
224 
225 	[NL802154_ATTR_MAX_FRAME_RETRIES] = { .type = NLA_S8, },
226 
227 	[NL802154_ATTR_LBT_MODE] = { .type = NLA_U8, },
228 };
229 
230 /* message building helper */
231 static inline void *nl802154hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
232 				    int flags, u8 cmd)
233 {
234 	/* since there is no private header just add the generic one */
235 	return genlmsg_put(skb, portid, seq, &nl802154_fam, flags, cmd);
236 }
237 
238 static int
239 nl802154_send_wpan_phy_channels(struct cfg802154_registered_device *rdev,
240 				struct sk_buff *msg)
241 {
242 	struct nlattr *nl_page;
243 	unsigned long page;
244 
245 	nl_page = nla_nest_start(msg, NL802154_ATTR_CHANNELS_SUPPORTED);
246 	if (!nl_page)
247 		return -ENOBUFS;
248 
249 	for (page = 0; page <= IEEE802154_MAX_PAGE; page++) {
250 		if (nla_put_u32(msg, NL802154_ATTR_SUPPORTED_CHANNEL,
251 				rdev->wpan_phy.channels_supported[page]))
252 			return -ENOBUFS;
253 	}
254 	nla_nest_end(msg, nl_page);
255 
256 	return 0;
257 }
258 
259 static int nl802154_send_wpan_phy(struct cfg802154_registered_device *rdev,
260 				  enum nl802154_commands cmd,
261 				  struct sk_buff *msg, u32 portid, u32 seq,
262 				  int flags)
263 {
264 	void *hdr;
265 
266 	hdr = nl802154hdr_put(msg, portid, seq, flags, cmd);
267 	if (!hdr)
268 		return -ENOBUFS;
269 
270 	if (nla_put_u32(msg, NL802154_ATTR_WPAN_PHY, rdev->wpan_phy_idx) ||
271 	    nla_put_string(msg, NL802154_ATTR_WPAN_PHY_NAME,
272 			   wpan_phy_name(&rdev->wpan_phy)) ||
273 	    nla_put_u32(msg, NL802154_ATTR_GENERATION,
274 			cfg802154_rdev_list_generation))
275 		goto nla_put_failure;
276 
277 	if (cmd != NL802154_CMD_NEW_WPAN_PHY)
278 		goto finish;
279 
280 	/* DUMP PHY PIB */
281 
282 	/* current channel settings */
283 	if (nla_put_u8(msg, NL802154_ATTR_PAGE,
284 		       rdev->wpan_phy.current_page) ||
285 	    nla_put_u8(msg, NL802154_ATTR_CHANNEL,
286 		       rdev->wpan_phy.current_channel))
287 		goto nla_put_failure;
288 
289 	/* supported channels array */
290 	if (nl802154_send_wpan_phy_channels(rdev, msg))
291 		goto nla_put_failure;
292 
293 	/* cca mode */
294 	if (nla_put_u32(msg, NL802154_ATTR_CCA_MODE,
295 			rdev->wpan_phy.cca.mode))
296 		goto nla_put_failure;
297 
298 	if (rdev->wpan_phy.cca.mode == NL802154_CCA_ENERGY_CARRIER) {
299 		if (nla_put_u32(msg, NL802154_ATTR_CCA_OPT,
300 				rdev->wpan_phy.cca.opt))
301 			goto nla_put_failure;
302 	}
303 
304 	if (nla_put_s8(msg, NL802154_ATTR_TX_POWER,
305 		       rdev->wpan_phy.transmit_power))
306 		goto nla_put_failure;
307 
308 finish:
309 	genlmsg_end(msg, hdr);
310 	return 0;
311 
312 nla_put_failure:
313 	genlmsg_cancel(msg, hdr);
314 	return -EMSGSIZE;
315 }
316 
317 struct nl802154_dump_wpan_phy_state {
318 	s64 filter_wpan_phy;
319 	long start;
320 
321 };
322 
323 static int nl802154_dump_wpan_phy_parse(struct sk_buff *skb,
324 					struct netlink_callback *cb,
325 					struct nl802154_dump_wpan_phy_state *state)
326 {
327 	struct nlattr **tb = nl802154_fam.attrbuf;
328 	int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl802154_fam.hdrsize,
329 			      tb, nl802154_fam.maxattr, nl802154_policy);
330 
331 	/* TODO check if we can handle error here,
332 	 * we have no backward compatibility
333 	 */
334 	if (ret)
335 		return 0;
336 
337 	if (tb[NL802154_ATTR_WPAN_PHY])
338 		state->filter_wpan_phy = nla_get_u32(tb[NL802154_ATTR_WPAN_PHY]);
339 	if (tb[NL802154_ATTR_WPAN_DEV])
340 		state->filter_wpan_phy = nla_get_u64(tb[NL802154_ATTR_WPAN_DEV]) >> 32;
341 	if (tb[NL802154_ATTR_IFINDEX]) {
342 		struct net_device *netdev;
343 		struct cfg802154_registered_device *rdev;
344 		int ifidx = nla_get_u32(tb[NL802154_ATTR_IFINDEX]);
345 
346 		/* TODO netns */
347 		netdev = __dev_get_by_index(&init_net, ifidx);
348 		if (!netdev)
349 			return -ENODEV;
350 		if (netdev->ieee802154_ptr) {
351 			rdev = wpan_phy_to_rdev(
352 					netdev->ieee802154_ptr->wpan_phy);
353 			state->filter_wpan_phy = rdev->wpan_phy_idx;
354 		}
355 	}
356 
357 	return 0;
358 }
359 
360 static int
361 nl802154_dump_wpan_phy(struct sk_buff *skb, struct netlink_callback *cb)
362 {
363 	int idx = 0, ret;
364 	struct nl802154_dump_wpan_phy_state *state = (void *)cb->args[0];
365 	struct cfg802154_registered_device *rdev;
366 
367 	rtnl_lock();
368 	if (!state) {
369 		state = kzalloc(sizeof(*state), GFP_KERNEL);
370 		if (!state) {
371 			rtnl_unlock();
372 			return -ENOMEM;
373 		}
374 		state->filter_wpan_phy = -1;
375 		ret = nl802154_dump_wpan_phy_parse(skb, cb, state);
376 		if (ret) {
377 			kfree(state);
378 			rtnl_unlock();
379 			return ret;
380 		}
381 		cb->args[0] = (long)state;
382 	}
383 
384 	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
385 		/* TODO net ns compare */
386 		if (++idx <= state->start)
387 			continue;
388 		if (state->filter_wpan_phy != -1 &&
389 		    state->filter_wpan_phy != rdev->wpan_phy_idx)
390 			continue;
391 		/* attempt to fit multiple wpan_phy data chunks into the skb */
392 		ret = nl802154_send_wpan_phy(rdev,
393 					     NL802154_CMD_NEW_WPAN_PHY,
394 					     skb,
395 					     NETLINK_CB(cb->skb).portid,
396 					     cb->nlh->nlmsg_seq, NLM_F_MULTI);
397 		if (ret < 0) {
398 			if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
399 			    !skb->len && cb->min_dump_alloc < 4096) {
400 				cb->min_dump_alloc = 4096;
401 				rtnl_unlock();
402 				return 1;
403 			}
404 			idx--;
405 			break;
406 		}
407 		break;
408 	}
409 	rtnl_unlock();
410 
411 	state->start = idx;
412 
413 	return skb->len;
414 }
415 
416 static int nl802154_dump_wpan_phy_done(struct netlink_callback *cb)
417 {
418 	kfree((void *)cb->args[0]);
419 	return 0;
420 }
421 
422 static int nl802154_get_wpan_phy(struct sk_buff *skb, struct genl_info *info)
423 {
424 	struct sk_buff *msg;
425 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
426 
427 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
428 	if (!msg)
429 		return -ENOMEM;
430 
431 	if (nl802154_send_wpan_phy(rdev, NL802154_CMD_NEW_WPAN_PHY, msg,
432 				   info->snd_portid, info->snd_seq, 0) < 0) {
433 		nlmsg_free(msg);
434 		return -ENOBUFS;
435 	}
436 
437 	return genlmsg_reply(msg, info);
438 }
439 
440 static inline u64 wpan_dev_id(struct wpan_dev *wpan_dev)
441 {
442 	return (u64)wpan_dev->identifier |
443 	       ((u64)wpan_phy_to_rdev(wpan_dev->wpan_phy)->wpan_phy_idx << 32);
444 }
445 
446 static int
447 nl802154_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
448 		    struct cfg802154_registered_device *rdev,
449 		    struct wpan_dev *wpan_dev)
450 {
451 	struct net_device *dev = wpan_dev->netdev;
452 	void *hdr;
453 
454 	hdr = nl802154hdr_put(msg, portid, seq, flags,
455 			      NL802154_CMD_NEW_INTERFACE);
456 	if (!hdr)
457 		return -1;
458 
459 	if (dev &&
460 	    (nla_put_u32(msg, NL802154_ATTR_IFINDEX, dev->ifindex) ||
461 	     nla_put_string(msg, NL802154_ATTR_IFNAME, dev->name)))
462 		goto nla_put_failure;
463 
464 	if (nla_put_u32(msg, NL802154_ATTR_WPAN_PHY, rdev->wpan_phy_idx) ||
465 	    nla_put_u32(msg, NL802154_ATTR_IFTYPE, wpan_dev->iftype) ||
466 	    nla_put_u64(msg, NL802154_ATTR_WPAN_DEV, wpan_dev_id(wpan_dev)) ||
467 	    nla_put_u32(msg, NL802154_ATTR_GENERATION,
468 			rdev->devlist_generation ^
469 			(cfg802154_rdev_list_generation << 2)))
470 		goto nla_put_failure;
471 
472 	/* address settings */
473 	if (nla_put_le64(msg, NL802154_ATTR_EXTENDED_ADDR,
474 			 wpan_dev->extended_addr) ||
475 	    nla_put_le16(msg, NL802154_ATTR_SHORT_ADDR,
476 			 wpan_dev->short_addr) ||
477 	    nla_put_le16(msg, NL802154_ATTR_PAN_ID, wpan_dev->pan_id))
478 		goto nla_put_failure;
479 
480 	/* ARET handling */
481 	if (nla_put_s8(msg, NL802154_ATTR_MAX_FRAME_RETRIES,
482 		       wpan_dev->frame_retries) ||
483 	    nla_put_u8(msg, NL802154_ATTR_MAX_BE, wpan_dev->max_be) ||
484 	    nla_put_u8(msg, NL802154_ATTR_MAX_CSMA_BACKOFFS,
485 		       wpan_dev->csma_retries) ||
486 	    nla_put_u8(msg, NL802154_ATTR_MIN_BE, wpan_dev->min_be))
487 		goto nla_put_failure;
488 
489 	/* listen before transmit */
490 	if (nla_put_u8(msg, NL802154_ATTR_LBT_MODE, wpan_dev->lbt))
491 		goto nla_put_failure;
492 
493 	genlmsg_end(msg, hdr);
494 	return 0;
495 
496 nla_put_failure:
497 	genlmsg_cancel(msg, hdr);
498 	return -EMSGSIZE;
499 }
500 
501 static int
502 nl802154_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
503 {
504 	int wp_idx = 0;
505 	int if_idx = 0;
506 	int wp_start = cb->args[0];
507 	int if_start = cb->args[1];
508 	struct cfg802154_registered_device *rdev;
509 	struct wpan_dev *wpan_dev;
510 
511 	rtnl_lock();
512 	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
513 		/* TODO netns compare */
514 		if (wp_idx < wp_start) {
515 			wp_idx++;
516 			continue;
517 		}
518 		if_idx = 0;
519 
520 		list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
521 			if (if_idx < if_start) {
522 				if_idx++;
523 				continue;
524 			}
525 			if (nl802154_send_iface(skb, NETLINK_CB(cb->skb).portid,
526 						cb->nlh->nlmsg_seq, NLM_F_MULTI,
527 						rdev, wpan_dev) < 0) {
528 				goto out;
529 			}
530 			if_idx++;
531 		}
532 
533 		wp_idx++;
534 	}
535 out:
536 	rtnl_unlock();
537 
538 	cb->args[0] = wp_idx;
539 	cb->args[1] = if_idx;
540 
541 	return skb->len;
542 }
543 
544 static int nl802154_get_interface(struct sk_buff *skb, struct genl_info *info)
545 {
546 	struct sk_buff *msg;
547 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
548 	struct wpan_dev *wdev = info->user_ptr[1];
549 
550 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
551 	if (!msg)
552 		return -ENOMEM;
553 
554 	if (nl802154_send_iface(msg, info->snd_portid, info->snd_seq, 0,
555 				rdev, wdev) < 0) {
556 		nlmsg_free(msg);
557 		return -ENOBUFS;
558 	}
559 
560 	return genlmsg_reply(msg, info);
561 }
562 
563 static int nl802154_new_interface(struct sk_buff *skb, struct genl_info *info)
564 {
565 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
566 	enum nl802154_iftype type = NL802154_IFTYPE_UNSPEC;
567 	__le64 extended_addr = cpu_to_le64(0x0000000000000000ULL);
568 
569 	/* TODO avoid failing a new interface
570 	 * creation due to pending removal?
571 	 */
572 
573 	if (!info->attrs[NL802154_ATTR_IFNAME])
574 		return -EINVAL;
575 
576 	if (info->attrs[NL802154_ATTR_IFTYPE]) {
577 		type = nla_get_u32(info->attrs[NL802154_ATTR_IFTYPE]);
578 		if (type > NL802154_IFTYPE_MAX)
579 			return -EINVAL;
580 	}
581 
582 	/* TODO add nla_get_le64 to netlink */
583 	if (info->attrs[NL802154_ATTR_EXTENDED_ADDR])
584 		extended_addr = (__force __le64)nla_get_u64(
585 				info->attrs[NL802154_ATTR_EXTENDED_ADDR]);
586 
587 	if (!rdev->ops->add_virtual_intf)
588 		return -EOPNOTSUPP;
589 
590 	return rdev_add_virtual_intf(rdev,
591 				     nla_data(info->attrs[NL802154_ATTR_IFNAME]),
592 				     NET_NAME_USER, type, extended_addr);
593 }
594 
595 static int nl802154_del_interface(struct sk_buff *skb, struct genl_info *info)
596 {
597 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
598 	struct wpan_dev *wpan_dev = info->user_ptr[1];
599 
600 	if (!rdev->ops->del_virtual_intf)
601 		return -EOPNOTSUPP;
602 
603 	/* If we remove a wpan device without a netdev then clear
604 	 * user_ptr[1] so that nl802154_post_doit won't dereference it
605 	 * to check if it needs to do dev_put(). Otherwise it crashes
606 	 * since the wpan_dev has been freed, unlike with a netdev where
607 	 * we need the dev_put() for the netdev to really be freed.
608 	 */
609 	if (!wpan_dev->netdev)
610 		info->user_ptr[1] = NULL;
611 
612 	return rdev_del_virtual_intf(rdev, wpan_dev);
613 }
614 
615 static int nl802154_set_channel(struct sk_buff *skb, struct genl_info *info)
616 {
617 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
618 	u8 channel, page;
619 
620 	if (!info->attrs[NL802154_ATTR_PAGE] ||
621 	    !info->attrs[NL802154_ATTR_CHANNEL])
622 		return -EINVAL;
623 
624 	page = nla_get_u8(info->attrs[NL802154_ATTR_PAGE]);
625 	channel = nla_get_u8(info->attrs[NL802154_ATTR_CHANNEL]);
626 
627 	/* check 802.15.4 constraints */
628 	if (page > IEEE802154_MAX_PAGE || channel > IEEE802154_MAX_CHANNEL)
629 		return -EINVAL;
630 
631 	return rdev_set_channel(rdev, page, channel);
632 }
633 
634 static int nl802154_set_cca_mode(struct sk_buff *skb, struct genl_info *info)
635 {
636 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
637 	struct wpan_phy_cca cca;
638 
639 	if (!info->attrs[NL802154_ATTR_CCA_MODE])
640 		return -EINVAL;
641 
642 	cca.mode = nla_get_u32(info->attrs[NL802154_ATTR_CCA_MODE]);
643 	/* checking 802.15.4 constraints */
644 	if (cca.mode < NL802154_CCA_ENERGY || cca.mode > NL802154_CCA_ATTR_MAX)
645 		return -EINVAL;
646 
647 	if (cca.mode == NL802154_CCA_ENERGY_CARRIER) {
648 		if (!info->attrs[NL802154_ATTR_CCA_OPT])
649 			return -EINVAL;
650 
651 		cca.opt = nla_get_u32(info->attrs[NL802154_ATTR_CCA_OPT]);
652 		if (cca.opt > NL802154_CCA_OPT_ATTR_MAX)
653 			return -EINVAL;
654 	}
655 
656 	return rdev_set_cca_mode(rdev, &cca);
657 }
658 
659 static int nl802154_set_pan_id(struct sk_buff *skb, struct genl_info *info)
660 {
661 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
662 	struct net_device *dev = info->user_ptr[1];
663 	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
664 	__le16 pan_id;
665 
666 	/* conflict here while tx/rx calls */
667 	if (netif_running(dev))
668 		return -EBUSY;
669 
670 	/* don't change address fields on monitor */
671 	if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR)
672 		return -EINVAL;
673 
674 	if (!info->attrs[NL802154_ATTR_PAN_ID])
675 		return -EINVAL;
676 
677 	pan_id = nla_get_le16(info->attrs[NL802154_ATTR_PAN_ID]);
678 
679 	return rdev_set_pan_id(rdev, wpan_dev, pan_id);
680 }
681 
682 static int nl802154_set_short_addr(struct sk_buff *skb, struct genl_info *info)
683 {
684 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
685 	struct net_device *dev = info->user_ptr[1];
686 	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
687 	__le16 short_addr;
688 
689 	/* conflict here while tx/rx calls */
690 	if (netif_running(dev))
691 		return -EBUSY;
692 
693 	/* don't change address fields on monitor */
694 	if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR)
695 		return -EINVAL;
696 
697 	if (!info->attrs[NL802154_ATTR_SHORT_ADDR])
698 		return -EINVAL;
699 
700 	short_addr = nla_get_le16(info->attrs[NL802154_ATTR_SHORT_ADDR]);
701 
702 	return rdev_set_short_addr(rdev, wpan_dev, short_addr);
703 }
704 
705 static int
706 nl802154_set_backoff_exponent(struct sk_buff *skb, struct genl_info *info)
707 {
708 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
709 	struct net_device *dev = info->user_ptr[1];
710 	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
711 	u8 min_be, max_be;
712 
713 	/* should be set on netif open inside phy settings */
714 	if (netif_running(dev))
715 		return -EBUSY;
716 
717 	if (!info->attrs[NL802154_ATTR_MIN_BE] ||
718 	    !info->attrs[NL802154_ATTR_MAX_BE])
719 		return -EINVAL;
720 
721 	min_be = nla_get_u8(info->attrs[NL802154_ATTR_MIN_BE]);
722 	max_be = nla_get_u8(info->attrs[NL802154_ATTR_MAX_BE]);
723 
724 	/* check 802.15.4 constraints */
725 	if (max_be < 3 || max_be > 8 || min_be > max_be)
726 		return -EINVAL;
727 
728 	return rdev_set_backoff_exponent(rdev, wpan_dev, min_be, max_be);
729 }
730 
731 static int
732 nl802154_set_max_csma_backoffs(struct sk_buff *skb, struct genl_info *info)
733 {
734 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
735 	struct net_device *dev = info->user_ptr[1];
736 	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
737 	u8 max_csma_backoffs;
738 
739 	/* conflict here while other running iface settings */
740 	if (netif_running(dev))
741 		return -EBUSY;
742 
743 	if (!info->attrs[NL802154_ATTR_MAX_CSMA_BACKOFFS])
744 		return -EINVAL;
745 
746 	max_csma_backoffs = nla_get_u8(
747 			info->attrs[NL802154_ATTR_MAX_CSMA_BACKOFFS]);
748 
749 	/* check 802.15.4 constraints */
750 	if (max_csma_backoffs > 5)
751 		return -EINVAL;
752 
753 	return rdev_set_max_csma_backoffs(rdev, wpan_dev, max_csma_backoffs);
754 }
755 
756 static int
757 nl802154_set_max_frame_retries(struct sk_buff *skb, struct genl_info *info)
758 {
759 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
760 	struct net_device *dev = info->user_ptr[1];
761 	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
762 	s8 max_frame_retries;
763 
764 	if (netif_running(dev))
765 		return -EBUSY;
766 
767 	if (!info->attrs[NL802154_ATTR_MAX_FRAME_RETRIES])
768 		return -EINVAL;
769 
770 	max_frame_retries = nla_get_s8(
771 			info->attrs[NL802154_ATTR_MAX_FRAME_RETRIES]);
772 
773 	/* check 802.15.4 constraints */
774 	if (max_frame_retries < -1 || max_frame_retries > 7)
775 		return -EINVAL;
776 
777 	return rdev_set_max_frame_retries(rdev, wpan_dev, max_frame_retries);
778 }
779 
780 static int nl802154_set_lbt_mode(struct sk_buff *skb, struct genl_info *info)
781 {
782 	struct cfg802154_registered_device *rdev = info->user_ptr[0];
783 	struct net_device *dev = info->user_ptr[1];
784 	struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
785 	bool mode;
786 
787 	if (netif_running(dev))
788 		return -EBUSY;
789 
790 	if (!info->attrs[NL802154_ATTR_LBT_MODE])
791 		return -EINVAL;
792 
793 	mode = !!nla_get_u8(info->attrs[NL802154_ATTR_LBT_MODE]);
794 	return rdev_set_lbt_mode(rdev, wpan_dev, mode);
795 }
796 
797 #define NL802154_FLAG_NEED_WPAN_PHY	0x01
798 #define NL802154_FLAG_NEED_NETDEV	0x02
799 #define NL802154_FLAG_NEED_RTNL		0x04
800 #define NL802154_FLAG_CHECK_NETDEV_UP	0x08
801 #define NL802154_FLAG_NEED_NETDEV_UP	(NL802154_FLAG_NEED_NETDEV |\
802 					 NL802154_FLAG_CHECK_NETDEV_UP)
803 #define NL802154_FLAG_NEED_WPAN_DEV	0x10
804 #define NL802154_FLAG_NEED_WPAN_DEV_UP	(NL802154_FLAG_NEED_WPAN_DEV |\
805 					 NL802154_FLAG_CHECK_NETDEV_UP)
806 
807 static int nl802154_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
808 			     struct genl_info *info)
809 {
810 	struct cfg802154_registered_device *rdev;
811 	struct wpan_dev *wpan_dev;
812 	struct net_device *dev;
813 	bool rtnl = ops->internal_flags & NL802154_FLAG_NEED_RTNL;
814 
815 	if (rtnl)
816 		rtnl_lock();
817 
818 	if (ops->internal_flags & NL802154_FLAG_NEED_WPAN_PHY) {
819 		rdev = cfg802154_get_dev_from_info(genl_info_net(info), info);
820 		if (IS_ERR(rdev)) {
821 			if (rtnl)
822 				rtnl_unlock();
823 			return PTR_ERR(rdev);
824 		}
825 		info->user_ptr[0] = rdev;
826 	} else if (ops->internal_flags & NL802154_FLAG_NEED_NETDEV ||
827 		   ops->internal_flags & NL802154_FLAG_NEED_WPAN_DEV) {
828 		ASSERT_RTNL();
829 		wpan_dev = __cfg802154_wpan_dev_from_attrs(genl_info_net(info),
830 							   info->attrs);
831 		if (IS_ERR(wpan_dev)) {
832 			if (rtnl)
833 				rtnl_unlock();
834 			return PTR_ERR(wpan_dev);
835 		}
836 
837 		dev = wpan_dev->netdev;
838 		rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);
839 
840 		if (ops->internal_flags & NL802154_FLAG_NEED_NETDEV) {
841 			if (!dev) {
842 				if (rtnl)
843 					rtnl_unlock();
844 				return -EINVAL;
845 			}
846 
847 			info->user_ptr[1] = dev;
848 		} else {
849 			info->user_ptr[1] = wpan_dev;
850 		}
851 
852 		if (dev) {
853 			if (ops->internal_flags & NL802154_FLAG_CHECK_NETDEV_UP &&
854 			    !netif_running(dev)) {
855 				if (rtnl)
856 					rtnl_unlock();
857 				return -ENETDOWN;
858 			}
859 
860 			dev_hold(dev);
861 		}
862 
863 		info->user_ptr[0] = rdev;
864 	}
865 
866 	return 0;
867 }
868 
869 static void nl802154_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
870 			       struct genl_info *info)
871 {
872 	if (info->user_ptr[1]) {
873 		if (ops->internal_flags & NL802154_FLAG_NEED_WPAN_DEV) {
874 			struct wpan_dev *wpan_dev = info->user_ptr[1];
875 
876 			if (wpan_dev->netdev)
877 				dev_put(wpan_dev->netdev);
878 		} else {
879 			dev_put(info->user_ptr[1]);
880 		}
881 	}
882 
883 	if (ops->internal_flags & NL802154_FLAG_NEED_RTNL)
884 		rtnl_unlock();
885 }
886 
887 static const struct genl_ops nl802154_ops[] = {
888 	{
889 		.cmd = NL802154_CMD_GET_WPAN_PHY,
890 		.doit = nl802154_get_wpan_phy,
891 		.dumpit = nl802154_dump_wpan_phy,
892 		.done = nl802154_dump_wpan_phy_done,
893 		.policy = nl802154_policy,
894 		/* can be retrieved by unprivileged users */
895 		.internal_flags = NL802154_FLAG_NEED_WPAN_PHY |
896 				  NL802154_FLAG_NEED_RTNL,
897 	},
898 	{
899 		.cmd = NL802154_CMD_GET_INTERFACE,
900 		.doit = nl802154_get_interface,
901 		.dumpit = nl802154_dump_interface,
902 		.policy = nl802154_policy,
903 		/* can be retrieved by unprivileged users */
904 		.internal_flags = NL802154_FLAG_NEED_WPAN_DEV |
905 				  NL802154_FLAG_NEED_RTNL,
906 	},
907 	{
908 		.cmd = NL802154_CMD_NEW_INTERFACE,
909 		.doit = nl802154_new_interface,
910 		.policy = nl802154_policy,
911 		.flags = GENL_ADMIN_PERM,
912 		.internal_flags = NL802154_FLAG_NEED_WPAN_PHY |
913 				  NL802154_FLAG_NEED_RTNL,
914 	},
915 	{
916 		.cmd = NL802154_CMD_DEL_INTERFACE,
917 		.doit = nl802154_del_interface,
918 		.policy = nl802154_policy,
919 		.flags = GENL_ADMIN_PERM,
920 		.internal_flags = NL802154_FLAG_NEED_WPAN_DEV |
921 				  NL802154_FLAG_NEED_RTNL,
922 	},
923 	{
924 		.cmd = NL802154_CMD_SET_CHANNEL,
925 		.doit = nl802154_set_channel,
926 		.policy = nl802154_policy,
927 		.flags = GENL_ADMIN_PERM,
928 		.internal_flags = NL802154_FLAG_NEED_WPAN_PHY |
929 				  NL802154_FLAG_NEED_RTNL,
930 	},
931 	{
932 		.cmd = NL802154_CMD_SET_CCA_MODE,
933 		.doit = nl802154_set_cca_mode,
934 		.policy = nl802154_policy,
935 		.flags = GENL_ADMIN_PERM,
936 		.internal_flags = NL802154_FLAG_NEED_WPAN_PHY |
937 				  NL802154_FLAG_NEED_RTNL,
938 	},
939 	{
940 		.cmd = NL802154_CMD_SET_PAN_ID,
941 		.doit = nl802154_set_pan_id,
942 		.policy = nl802154_policy,
943 		.flags = GENL_ADMIN_PERM,
944 		.internal_flags = NL802154_FLAG_NEED_NETDEV |
945 				  NL802154_FLAG_NEED_RTNL,
946 	},
947 	{
948 		.cmd = NL802154_CMD_SET_SHORT_ADDR,
949 		.doit = nl802154_set_short_addr,
950 		.policy = nl802154_policy,
951 		.flags = GENL_ADMIN_PERM,
952 		.internal_flags = NL802154_FLAG_NEED_NETDEV |
953 				  NL802154_FLAG_NEED_RTNL,
954 	},
955 	{
956 		.cmd = NL802154_CMD_SET_BACKOFF_EXPONENT,
957 		.doit = nl802154_set_backoff_exponent,
958 		.policy = nl802154_policy,
959 		.flags = GENL_ADMIN_PERM,
960 		.internal_flags = NL802154_FLAG_NEED_NETDEV |
961 				  NL802154_FLAG_NEED_RTNL,
962 	},
963 	{
964 		.cmd = NL802154_CMD_SET_MAX_CSMA_BACKOFFS,
965 		.doit = nl802154_set_max_csma_backoffs,
966 		.policy = nl802154_policy,
967 		.flags = GENL_ADMIN_PERM,
968 		.internal_flags = NL802154_FLAG_NEED_NETDEV |
969 				  NL802154_FLAG_NEED_RTNL,
970 	},
971 	{
972 		.cmd = NL802154_CMD_SET_MAX_FRAME_RETRIES,
973 		.doit = nl802154_set_max_frame_retries,
974 		.policy = nl802154_policy,
975 		.flags = GENL_ADMIN_PERM,
976 		.internal_flags = NL802154_FLAG_NEED_NETDEV |
977 				  NL802154_FLAG_NEED_RTNL,
978 	},
979 	{
980 		.cmd = NL802154_CMD_SET_LBT_MODE,
981 		.doit = nl802154_set_lbt_mode,
982 		.policy = nl802154_policy,
983 		.flags = GENL_ADMIN_PERM,
984 		.internal_flags = NL802154_FLAG_NEED_NETDEV |
985 				  NL802154_FLAG_NEED_RTNL,
986 	},
987 };
988 
989 /* initialisation/exit functions */
990 int nl802154_init(void)
991 {
992 	return genl_register_family_with_ops_groups(&nl802154_fam, nl802154_ops,
993 						    nl802154_mcgrps);
994 }
995 
996 void nl802154_exit(void)
997 {
998 	genl_unregister_family(&nl802154_fam);
999 }
1000