This source file includes following definitions.
- ndp_from_ifindex
- ncsi_write_channel_info
- ncsi_write_package_info
- ncsi_pkg_info_nl
- ncsi_pkg_info_all_nl
- ncsi_set_interface_nl
- ncsi_clear_interface_nl
- ncsi_send_cmd_nl
- ncsi_send_netlink_rsp
- ncsi_send_netlink_timeout
- ncsi_send_netlink_err
- ncsi_set_package_mask_nl
- ncsi_set_channel_mask_nl
- ncsi_init_netlink
- ncsi_unregister_netlink
1
2
3
4
5
6 #include <linux/module.h>
7 #include <linux/kernel.h>
8 #include <linux/if_arp.h>
9 #include <linux/rtnetlink.h>
10 #include <linux/etherdevice.h>
11 #include <net/genetlink.h>
12 #include <net/ncsi.h>
13 #include <linux/skbuff.h>
14 #include <net/sock.h>
15 #include <uapi/linux/ncsi.h>
16
17 #include "internal.h"
18 #include "ncsi-pkt.h"
19 #include "ncsi-netlink.h"
20
21 static struct genl_family ncsi_genl_family;
22
23 static const struct nla_policy ncsi_genl_policy[NCSI_ATTR_MAX + 1] = {
24 [NCSI_ATTR_IFINDEX] = { .type = NLA_U32 },
25 [NCSI_ATTR_PACKAGE_LIST] = { .type = NLA_NESTED },
26 [NCSI_ATTR_PACKAGE_ID] = { .type = NLA_U32 },
27 [NCSI_ATTR_CHANNEL_ID] = { .type = NLA_U32 },
28 [NCSI_ATTR_DATA] = { .type = NLA_BINARY, .len = 2048 },
29 [NCSI_ATTR_MULTI_FLAG] = { .type = NLA_FLAG },
30 [NCSI_ATTR_PACKAGE_MASK] = { .type = NLA_U32 },
31 [NCSI_ATTR_CHANNEL_MASK] = { .type = NLA_U32 },
32 };
33
34 static struct ncsi_dev_priv *ndp_from_ifindex(struct net *net, u32 ifindex)
35 {
36 struct ncsi_dev_priv *ndp;
37 struct net_device *dev;
38 struct ncsi_dev *nd;
39 struct ncsi_dev;
40
41 if (!net)
42 return NULL;
43
44 dev = dev_get_by_index(net, ifindex);
45 if (!dev) {
46 pr_err("NCSI netlink: No device for ifindex %u\n", ifindex);
47 return NULL;
48 }
49
50 nd = ncsi_find_dev(dev);
51 ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
52
53 dev_put(dev);
54 return ndp;
55 }
56
57 static int ncsi_write_channel_info(struct sk_buff *skb,
58 struct ncsi_dev_priv *ndp,
59 struct ncsi_channel *nc)
60 {
61 struct ncsi_channel_vlan_filter *ncf;
62 struct ncsi_channel_mode *m;
63 struct nlattr *vid_nest;
64 int i;
65
66 nla_put_u32(skb, NCSI_CHANNEL_ATTR_ID, nc->id);
67 m = &nc->modes[NCSI_MODE_LINK];
68 nla_put_u32(skb, NCSI_CHANNEL_ATTR_LINK_STATE, m->data[2]);
69 if (nc->state == NCSI_CHANNEL_ACTIVE)
70 nla_put_flag(skb, NCSI_CHANNEL_ATTR_ACTIVE);
71 if (nc == nc->package->preferred_channel)
72 nla_put_flag(skb, NCSI_CHANNEL_ATTR_FORCED);
73
74 nla_put_u32(skb, NCSI_CHANNEL_ATTR_VERSION_MAJOR, nc->version.version);
75 nla_put_u32(skb, NCSI_CHANNEL_ATTR_VERSION_MINOR, nc->version.alpha2);
76 nla_put_string(skb, NCSI_CHANNEL_ATTR_VERSION_STR, nc->version.fw_name);
77
78 vid_nest = nla_nest_start_noflag(skb, NCSI_CHANNEL_ATTR_VLAN_LIST);
79 if (!vid_nest)
80 return -ENOMEM;
81 ncf = &nc->vlan_filter;
82 i = -1;
83 while ((i = find_next_bit((void *)&ncf->bitmap, ncf->n_vids,
84 i + 1)) < ncf->n_vids) {
85 if (ncf->vids[i])
86 nla_put_u16(skb, NCSI_CHANNEL_ATTR_VLAN_ID,
87 ncf->vids[i]);
88 }
89 nla_nest_end(skb, vid_nest);
90
91 return 0;
92 }
93
94 static int ncsi_write_package_info(struct sk_buff *skb,
95 struct ncsi_dev_priv *ndp, unsigned int id)
96 {
97 struct nlattr *pnest, *cnest, *nest;
98 struct ncsi_package *np;
99 struct ncsi_channel *nc;
100 bool found;
101 int rc;
102
103 if (id > ndp->package_num - 1) {
104 netdev_info(ndp->ndev.dev, "NCSI: No package with id %u\n", id);
105 return -ENODEV;
106 }
107
108 found = false;
109 NCSI_FOR_EACH_PACKAGE(ndp, np) {
110 if (np->id != id)
111 continue;
112 pnest = nla_nest_start_noflag(skb, NCSI_PKG_ATTR);
113 if (!pnest)
114 return -ENOMEM;
115 nla_put_u32(skb, NCSI_PKG_ATTR_ID, np->id);
116 if ((0x1 << np->id) == ndp->package_whitelist)
117 nla_put_flag(skb, NCSI_PKG_ATTR_FORCED);
118 cnest = nla_nest_start_noflag(skb, NCSI_PKG_ATTR_CHANNEL_LIST);
119 if (!cnest) {
120 nla_nest_cancel(skb, pnest);
121 return -ENOMEM;
122 }
123 NCSI_FOR_EACH_CHANNEL(np, nc) {
124 nest = nla_nest_start_noflag(skb, NCSI_CHANNEL_ATTR);
125 if (!nest) {
126 nla_nest_cancel(skb, cnest);
127 nla_nest_cancel(skb, pnest);
128 return -ENOMEM;
129 }
130 rc = ncsi_write_channel_info(skb, ndp, nc);
131 if (rc) {
132 nla_nest_cancel(skb, nest);
133 nla_nest_cancel(skb, cnest);
134 nla_nest_cancel(skb, pnest);
135 return rc;
136 }
137 nla_nest_end(skb, nest);
138 }
139 nla_nest_end(skb, cnest);
140 nla_nest_end(skb, pnest);
141 found = true;
142 }
143
144 if (!found)
145 return -ENODEV;
146
147 return 0;
148 }
149
150 static int ncsi_pkg_info_nl(struct sk_buff *msg, struct genl_info *info)
151 {
152 struct ncsi_dev_priv *ndp;
153 unsigned int package_id;
154 struct sk_buff *skb;
155 struct nlattr *attr;
156 void *hdr;
157 int rc;
158
159 if (!info || !info->attrs)
160 return -EINVAL;
161
162 if (!info->attrs[NCSI_ATTR_IFINDEX])
163 return -EINVAL;
164
165 if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
166 return -EINVAL;
167
168 ndp = ndp_from_ifindex(genl_info_net(info),
169 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
170 if (!ndp)
171 return -ENODEV;
172
173 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
174 if (!skb)
175 return -ENOMEM;
176
177 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
178 &ncsi_genl_family, 0, NCSI_CMD_PKG_INFO);
179 if (!hdr) {
180 kfree_skb(skb);
181 return -EMSGSIZE;
182 }
183
184 package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
185
186 attr = nla_nest_start_noflag(skb, NCSI_ATTR_PACKAGE_LIST);
187 if (!attr) {
188 kfree_skb(skb);
189 return -EMSGSIZE;
190 }
191 rc = ncsi_write_package_info(skb, ndp, package_id);
192
193 if (rc) {
194 nla_nest_cancel(skb, attr);
195 goto err;
196 }
197
198 nla_nest_end(skb, attr);
199
200 genlmsg_end(skb, hdr);
201 return genlmsg_reply(skb, info);
202
203 err:
204 kfree_skb(skb);
205 return rc;
206 }
207
208 static int ncsi_pkg_info_all_nl(struct sk_buff *skb,
209 struct netlink_callback *cb)
210 {
211 struct nlattr *attrs[NCSI_ATTR_MAX + 1];
212 struct ncsi_package *np, *package;
213 struct ncsi_dev_priv *ndp;
214 unsigned int package_id;
215 struct nlattr *attr;
216 void *hdr;
217 int rc;
218
219 rc = genlmsg_parse_deprecated(cb->nlh, &ncsi_genl_family, attrs, NCSI_ATTR_MAX,
220 ncsi_genl_policy, NULL);
221 if (rc)
222 return rc;
223
224 if (!attrs[NCSI_ATTR_IFINDEX])
225 return -EINVAL;
226
227 ndp = ndp_from_ifindex(get_net(sock_net(skb->sk)),
228 nla_get_u32(attrs[NCSI_ATTR_IFINDEX]));
229
230 if (!ndp)
231 return -ENODEV;
232
233 package_id = cb->args[0];
234 package = NULL;
235 NCSI_FOR_EACH_PACKAGE(ndp, np)
236 if (np->id == package_id)
237 package = np;
238
239 if (!package)
240 return 0;
241
242 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
243 &ncsi_genl_family, NLM_F_MULTI, NCSI_CMD_PKG_INFO);
244 if (!hdr) {
245 rc = -EMSGSIZE;
246 goto err;
247 }
248
249 attr = nla_nest_start_noflag(skb, NCSI_ATTR_PACKAGE_LIST);
250 if (!attr) {
251 rc = -EMSGSIZE;
252 goto err;
253 }
254 rc = ncsi_write_package_info(skb, ndp, package->id);
255 if (rc) {
256 nla_nest_cancel(skb, attr);
257 goto err;
258 }
259
260 nla_nest_end(skb, attr);
261 genlmsg_end(skb, hdr);
262
263 cb->args[0] = package_id + 1;
264
265 return skb->len;
266 err:
267 genlmsg_cancel(skb, hdr);
268 return rc;
269 }
270
271 static int ncsi_set_interface_nl(struct sk_buff *msg, struct genl_info *info)
272 {
273 struct ncsi_package *np, *package;
274 struct ncsi_channel *nc, *channel;
275 u32 package_id, channel_id;
276 struct ncsi_dev_priv *ndp;
277 unsigned long flags;
278
279 if (!info || !info->attrs)
280 return -EINVAL;
281
282 if (!info->attrs[NCSI_ATTR_IFINDEX])
283 return -EINVAL;
284
285 if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
286 return -EINVAL;
287
288 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
289 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
290 if (!ndp)
291 return -ENODEV;
292
293 package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
294 package = NULL;
295
296 NCSI_FOR_EACH_PACKAGE(ndp, np)
297 if (np->id == package_id)
298 package = np;
299 if (!package) {
300
301 return -ERANGE;
302 }
303
304 channel = NULL;
305 if (info->attrs[NCSI_ATTR_CHANNEL_ID]) {
306 channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
307 NCSI_FOR_EACH_CHANNEL(package, nc)
308 if (nc->id == channel_id) {
309 channel = nc;
310 break;
311 }
312 if (!channel) {
313 netdev_info(ndp->ndev.dev,
314 "NCSI: Channel %u does not exist!\n",
315 channel_id);
316 return -ERANGE;
317 }
318 }
319
320 spin_lock_irqsave(&ndp->lock, flags);
321 ndp->package_whitelist = 0x1 << package->id;
322 ndp->multi_package = false;
323 spin_unlock_irqrestore(&ndp->lock, flags);
324
325 spin_lock_irqsave(&package->lock, flags);
326 package->multi_channel = false;
327 if (channel) {
328 package->channel_whitelist = 0x1 << channel->id;
329 package->preferred_channel = channel;
330 } else {
331
332 package->channel_whitelist = UINT_MAX;
333 package->preferred_channel = NULL;
334 }
335 spin_unlock_irqrestore(&package->lock, flags);
336
337 if (channel)
338 netdev_info(ndp->ndev.dev,
339 "Set package 0x%x, channel 0x%x as preferred\n",
340 package_id, channel_id);
341 else
342 netdev_info(ndp->ndev.dev, "Set package 0x%x as preferred\n",
343 package_id);
344
345
346 if (!(ndp->flags & NCSI_DEV_RESET))
347 ncsi_reset_dev(&ndp->ndev);
348
349 return 0;
350 }
351
352 static int ncsi_clear_interface_nl(struct sk_buff *msg, struct genl_info *info)
353 {
354 struct ncsi_dev_priv *ndp;
355 struct ncsi_package *np;
356 unsigned long flags;
357
358 if (!info || !info->attrs)
359 return -EINVAL;
360
361 if (!info->attrs[NCSI_ATTR_IFINDEX])
362 return -EINVAL;
363
364 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
365 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
366 if (!ndp)
367 return -ENODEV;
368
369
370 spin_lock_irqsave(&ndp->lock, flags);
371 ndp->package_whitelist = UINT_MAX;
372 ndp->multi_package = false;
373 spin_unlock_irqrestore(&ndp->lock, flags);
374
375 NCSI_FOR_EACH_PACKAGE(ndp, np) {
376 spin_lock_irqsave(&np->lock, flags);
377 np->multi_channel = false;
378 np->channel_whitelist = UINT_MAX;
379 np->preferred_channel = NULL;
380 spin_unlock_irqrestore(&np->lock, flags);
381 }
382 netdev_info(ndp->ndev.dev, "NCSI: Cleared preferred package/channel\n");
383
384
385 if (!(ndp->flags & NCSI_DEV_RESET))
386 ncsi_reset_dev(&ndp->ndev);
387
388 return 0;
389 }
390
391 static int ncsi_send_cmd_nl(struct sk_buff *msg, struct genl_info *info)
392 {
393 struct ncsi_dev_priv *ndp;
394 struct ncsi_pkt_hdr *hdr;
395 struct ncsi_cmd_arg nca;
396 unsigned char *data;
397 u32 package_id;
398 u32 channel_id;
399 int len, ret;
400
401 if (!info || !info->attrs) {
402 ret = -EINVAL;
403 goto out;
404 }
405
406 if (!info->attrs[NCSI_ATTR_IFINDEX]) {
407 ret = -EINVAL;
408 goto out;
409 }
410
411 if (!info->attrs[NCSI_ATTR_PACKAGE_ID]) {
412 ret = -EINVAL;
413 goto out;
414 }
415
416 if (!info->attrs[NCSI_ATTR_CHANNEL_ID]) {
417 ret = -EINVAL;
418 goto out;
419 }
420
421 if (!info->attrs[NCSI_ATTR_DATA]) {
422 ret = -EINVAL;
423 goto out;
424 }
425
426 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
427 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
428 if (!ndp) {
429 ret = -ENODEV;
430 goto out;
431 }
432
433 package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
434 channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
435
436 if (package_id >= NCSI_MAX_PACKAGE || channel_id >= NCSI_MAX_CHANNEL) {
437 ret = -ERANGE;
438 goto out_netlink;
439 }
440
441 len = nla_len(info->attrs[NCSI_ATTR_DATA]);
442 if (len < sizeof(struct ncsi_pkt_hdr)) {
443 netdev_info(ndp->ndev.dev, "NCSI: no command to send %u\n",
444 package_id);
445 ret = -EINVAL;
446 goto out_netlink;
447 } else {
448 data = (unsigned char *)nla_data(info->attrs[NCSI_ATTR_DATA]);
449 }
450
451 hdr = (struct ncsi_pkt_hdr *)data;
452
453 nca.ndp = ndp;
454 nca.package = (unsigned char)package_id;
455 nca.channel = (unsigned char)channel_id;
456 nca.type = hdr->type;
457 nca.req_flags = NCSI_REQ_FLAG_NETLINK_DRIVEN;
458 nca.info = info;
459 nca.payload = ntohs(hdr->length);
460 nca.data = data + sizeof(*hdr);
461
462 ret = ncsi_xmit_cmd(&nca);
463 out_netlink:
464 if (ret != 0) {
465 netdev_err(ndp->ndev.dev,
466 "NCSI: Error %d sending command\n",
467 ret);
468 ncsi_send_netlink_err(ndp->ndev.dev,
469 info->snd_seq,
470 info->snd_portid,
471 info->nlhdr,
472 ret);
473 }
474 out:
475 return ret;
476 }
477
478 int ncsi_send_netlink_rsp(struct ncsi_request *nr,
479 struct ncsi_package *np,
480 struct ncsi_channel *nc)
481 {
482 struct sk_buff *skb;
483 struct net *net;
484 void *hdr;
485 int rc;
486
487 net = dev_net(nr->rsp->dev);
488
489 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
490 if (!skb)
491 return -ENOMEM;
492
493 hdr = genlmsg_put(skb, nr->snd_portid, nr->snd_seq,
494 &ncsi_genl_family, 0, NCSI_CMD_SEND_CMD);
495 if (!hdr) {
496 kfree_skb(skb);
497 return -EMSGSIZE;
498 }
499
500 nla_put_u32(skb, NCSI_ATTR_IFINDEX, nr->rsp->dev->ifindex);
501 if (np)
502 nla_put_u32(skb, NCSI_ATTR_PACKAGE_ID, np->id);
503 if (nc)
504 nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, nc->id);
505 else
506 nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, NCSI_RESERVED_CHANNEL);
507
508 rc = nla_put(skb, NCSI_ATTR_DATA, nr->rsp->len, (void *)nr->rsp->data);
509 if (rc)
510 goto err;
511
512 genlmsg_end(skb, hdr);
513 return genlmsg_unicast(net, skb, nr->snd_portid);
514
515 err:
516 kfree_skb(skb);
517 return rc;
518 }
519
520 int ncsi_send_netlink_timeout(struct ncsi_request *nr,
521 struct ncsi_package *np,
522 struct ncsi_channel *nc)
523 {
524 struct sk_buff *skb;
525 struct net *net;
526 void *hdr;
527
528 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
529 if (!skb)
530 return -ENOMEM;
531
532 hdr = genlmsg_put(skb, nr->snd_portid, nr->snd_seq,
533 &ncsi_genl_family, 0, NCSI_CMD_SEND_CMD);
534 if (!hdr) {
535 kfree_skb(skb);
536 return -EMSGSIZE;
537 }
538
539 net = dev_net(nr->cmd->dev);
540
541 nla_put_u32(skb, NCSI_ATTR_IFINDEX, nr->cmd->dev->ifindex);
542
543 if (np)
544 nla_put_u32(skb, NCSI_ATTR_PACKAGE_ID, np->id);
545 else
546 nla_put_u32(skb, NCSI_ATTR_PACKAGE_ID,
547 NCSI_PACKAGE_INDEX((((struct ncsi_pkt_hdr *)
548 nr->cmd->data)->channel)));
549
550 if (nc)
551 nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, nc->id);
552 else
553 nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, NCSI_RESERVED_CHANNEL);
554
555 genlmsg_end(skb, hdr);
556 return genlmsg_unicast(net, skb, nr->snd_portid);
557 }
558
559 int ncsi_send_netlink_err(struct net_device *dev,
560 u32 snd_seq,
561 u32 snd_portid,
562 struct nlmsghdr *nlhdr,
563 int err)
564 {
565 struct nlmsghdr *nlh;
566 struct nlmsgerr *nle;
567 struct sk_buff *skb;
568 struct net *net;
569
570 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
571 if (!skb)
572 return -ENOMEM;
573
574 net = dev_net(dev);
575
576 nlh = nlmsg_put(skb, snd_portid, snd_seq,
577 NLMSG_ERROR, sizeof(*nle), 0);
578 nle = (struct nlmsgerr *)nlmsg_data(nlh);
579 nle->error = err;
580 memcpy(&nle->msg, nlhdr, sizeof(*nlh));
581
582 nlmsg_end(skb, nlh);
583
584 return nlmsg_unicast(net->genl_sock, skb, snd_portid);
585 }
586
587 static int ncsi_set_package_mask_nl(struct sk_buff *msg,
588 struct genl_info *info)
589 {
590 struct ncsi_dev_priv *ndp;
591 unsigned long flags;
592 int rc;
593
594 if (!info || !info->attrs)
595 return -EINVAL;
596
597 if (!info->attrs[NCSI_ATTR_IFINDEX])
598 return -EINVAL;
599
600 if (!info->attrs[NCSI_ATTR_PACKAGE_MASK])
601 return -EINVAL;
602
603 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
604 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
605 if (!ndp)
606 return -ENODEV;
607
608 spin_lock_irqsave(&ndp->lock, flags);
609 if (nla_get_flag(info->attrs[NCSI_ATTR_MULTI_FLAG])) {
610 if (ndp->flags & NCSI_DEV_HWA) {
611 ndp->multi_package = true;
612 rc = 0;
613 } else {
614 netdev_err(ndp->ndev.dev,
615 "NCSI: Can't use multiple packages without HWA\n");
616 rc = -EPERM;
617 }
618 } else {
619 ndp->multi_package = false;
620 rc = 0;
621 }
622
623 if (!rc)
624 ndp->package_whitelist =
625 nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_MASK]);
626 spin_unlock_irqrestore(&ndp->lock, flags);
627
628 if (!rc) {
629
630 if (!(ndp->flags & NCSI_DEV_RESET))
631 ncsi_reset_dev(&ndp->ndev);
632 }
633
634 return rc;
635 }
636
637 static int ncsi_set_channel_mask_nl(struct sk_buff *msg,
638 struct genl_info *info)
639 {
640 struct ncsi_package *np, *package;
641 struct ncsi_channel *nc, *channel;
642 u32 package_id, channel_id;
643 struct ncsi_dev_priv *ndp;
644 unsigned long flags;
645
646 if (!info || !info->attrs)
647 return -EINVAL;
648
649 if (!info->attrs[NCSI_ATTR_IFINDEX])
650 return -EINVAL;
651
652 if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
653 return -EINVAL;
654
655 if (!info->attrs[NCSI_ATTR_CHANNEL_MASK])
656 return -EINVAL;
657
658 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
659 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
660 if (!ndp)
661 return -ENODEV;
662
663 package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
664 package = NULL;
665 NCSI_FOR_EACH_PACKAGE(ndp, np)
666 if (np->id == package_id) {
667 package = np;
668 break;
669 }
670 if (!package)
671 return -ERANGE;
672
673 spin_lock_irqsave(&package->lock, flags);
674
675 channel = NULL;
676 if (info->attrs[NCSI_ATTR_CHANNEL_ID]) {
677 channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
678 NCSI_FOR_EACH_CHANNEL(np, nc)
679 if (nc->id == channel_id) {
680 channel = nc;
681 break;
682 }
683 if (!channel) {
684 spin_unlock_irqrestore(&package->lock, flags);
685 return -ERANGE;
686 }
687 netdev_dbg(ndp->ndev.dev,
688 "NCSI: Channel %u set as preferred channel\n",
689 channel->id);
690 }
691
692 package->channel_whitelist =
693 nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_MASK]);
694 if (package->channel_whitelist == 0)
695 netdev_dbg(ndp->ndev.dev,
696 "NCSI: Package %u set to all channels disabled\n",
697 package->id);
698
699 package->preferred_channel = channel;
700
701 if (nla_get_flag(info->attrs[NCSI_ATTR_MULTI_FLAG])) {
702 package->multi_channel = true;
703 netdev_info(ndp->ndev.dev,
704 "NCSI: Multi-channel enabled on package %u\n",
705 package_id);
706 } else {
707 package->multi_channel = false;
708 }
709
710 spin_unlock_irqrestore(&package->lock, flags);
711
712
713 if (!(ndp->flags & NCSI_DEV_RESET))
714 ncsi_reset_dev(&ndp->ndev);
715
716 return 0;
717 }
718
719 static const struct genl_ops ncsi_ops[] = {
720 {
721 .cmd = NCSI_CMD_PKG_INFO,
722 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
723 .doit = ncsi_pkg_info_nl,
724 .dumpit = ncsi_pkg_info_all_nl,
725 .flags = 0,
726 },
727 {
728 .cmd = NCSI_CMD_SET_INTERFACE,
729 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
730 .doit = ncsi_set_interface_nl,
731 .flags = GENL_ADMIN_PERM,
732 },
733 {
734 .cmd = NCSI_CMD_CLEAR_INTERFACE,
735 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
736 .doit = ncsi_clear_interface_nl,
737 .flags = GENL_ADMIN_PERM,
738 },
739 {
740 .cmd = NCSI_CMD_SEND_CMD,
741 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
742 .doit = ncsi_send_cmd_nl,
743 .flags = GENL_ADMIN_PERM,
744 },
745 {
746 .cmd = NCSI_CMD_SET_PACKAGE_MASK,
747 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
748 .doit = ncsi_set_package_mask_nl,
749 .flags = GENL_ADMIN_PERM,
750 },
751 {
752 .cmd = NCSI_CMD_SET_CHANNEL_MASK,
753 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
754 .doit = ncsi_set_channel_mask_nl,
755 .flags = GENL_ADMIN_PERM,
756 },
757 };
758
759 static struct genl_family ncsi_genl_family __ro_after_init = {
760 .name = "NCSI",
761 .version = 0,
762 .maxattr = NCSI_ATTR_MAX,
763 .policy = ncsi_genl_policy,
764 .module = THIS_MODULE,
765 .ops = ncsi_ops,
766 .n_ops = ARRAY_SIZE(ncsi_ops),
767 };
768
769 int ncsi_init_netlink(struct net_device *dev)
770 {
771 int rc;
772
773 rc = genl_register_family(&ncsi_genl_family);
774 if (rc)
775 netdev_err(dev, "ncsi: failed to register netlink family\n");
776
777 return rc;
778 }
779
780 int ncsi_unregister_netlink(struct net_device *dev)
781 {
782 int rc;
783
784 rc = genl_unregister_family(&ncsi_genl_family);
785 if (rc)
786 netdev_err(dev, "ncsi: failed to unregister netlink family\n");
787
788 return rc;
789 }