?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / net / ncsi / ncsi-manage.c
blob091284760d21fa02dc0f9997a2c68ce7f1f618e6
1 /*
2 * Copyright Gavin Shan, IBM Corporation 2016.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/netdevice.h>
14 #include <linux/skbuff.h>
15
16 #include <net/ncsi.h>
17 #include <net/net_namespace.h>
18 #include <net/sock.h>
19 #include <net/addrconf.h>
20 #include <net/ipv6.h>
21 #include <net/if_inet6.h>
22
23 #include "internal.h"
24 #include "ncsi-pkt.h"
25 #include "ncsi-netlink.h"
26
27 LIST_HEAD(ncsi_dev_list);
28 DEFINE_SPINLOCK(ncsi_dev_lock);
29
30 static void ncsi_report_link(struct ncsi_dev_priv *ndp, bool force_down)
31 {
32 struct ncsi_dev *nd = &ndp->ndev;
33 struct ncsi_package *np;
34 struct ncsi_channel *nc;
35 unsigned long flags;
36
37 nd->state = ncsi_dev_state_functional;
38 if (force_down) {
39 nd->link_up = 0;
40 goto report;
41 }
42
43 nd->link_up = 0;
44 NCSI_FOR_EACH_PACKAGE(ndp, np) {
45 NCSI_FOR_EACH_CHANNEL(np, nc) {
46 spin_lock_irqsave(&nc->lock, flags);
47
48 if (!list_empty(&nc->link) ||
49 nc->state != NCSI_CHANNEL_ACTIVE) {
50 spin_unlock_irqrestore(&nc->lock, flags);
51 continue;
52 }
53
54 if (nc->modes[NCSI_MODE_LINK].data[2] & 0x1) {
55 spin_unlock_irqrestore(&nc->lock, flags);
56 nd->link_up = 1;
57 goto report;
58 }
59
60 spin_unlock_irqrestore(&nc->lock, flags);
61 }
62 }
63
64 report:
65 nd->handler(nd);
66 }
67
68 static void ncsi_channel_monitor(struct timer_list *t)
69 {
70 struct ncsi_channel *nc = from_timer(nc, t, monitor.timer);
71 struct ncsi_package *np = nc->package;
72 struct ncsi_dev_priv *ndp = np->ndp;
73 struct ncsi_channel_mode *ncm;
74 struct ncsi_cmd_arg nca;
75 bool enabled, chained;
76 unsigned int monitor_state;
77 unsigned long flags;
78 int state, ret;
79
80 spin_lock_irqsave(&nc->lock, flags);
81 state = nc->state;
82 chained = !list_empty(&nc->link);
83 enabled = nc->monitor.enabled;
84 monitor_state = nc->monitor.state;
85 spin_unlock_irqrestore(&nc->lock, flags);
86
87 if (!enabled || chained) {
88 ncsi_stop_channel_monitor(nc);
89 return;
90 }
91 if (state != NCSI_CHANNEL_INACTIVE &&
92 state != NCSI_CHANNEL_ACTIVE) {
93 ncsi_stop_channel_monitor(nc);
94 return;
95 }
96
97 switch (monitor_state) {
98 case NCSI_CHANNEL_MONITOR_START:
99 case NCSI_CHANNEL_MONITOR_RETRY:
100 nca.ndp = ndp;
101 nca.package = np->id;
102 nca.channel = nc->id;
103 nca.type = NCSI_PKT_CMD_GLS;
104 nca.req_flags = 0;
105 ret = ncsi_xmit_cmd(&nca);
106 if (ret)
107 netdev_err(ndp->ndev.dev, "Error %d sending GLS\n",
108 ret);
109 break;
110 case NCSI_CHANNEL_MONITOR_WAIT ... NCSI_CHANNEL_MONITOR_WAIT_MAX:
111 break;
112 default:
113 netdev_err(ndp->ndev.dev, "NCSI Channel %d timed out!\n",
114 nc->id);
115 if (!(ndp->flags & NCSI_DEV_HWA)) {
116 ncsi_report_link(ndp, true);
117 ndp->flags |= NCSI_DEV_RESHUFFLE;
118 }
119
120 ncsi_stop_channel_monitor(nc);
121
122 ncm = &nc->modes[NCSI_MODE_LINK];
123 spin_lock_irqsave(&nc->lock, flags);
124 nc->state = NCSI_CHANNEL_INVISIBLE;
125 ncm->data[2] &= ~0x1;
126 spin_unlock_irqrestore(&nc->lock, flags);
127
128 spin_lock_irqsave(&ndp->lock, flags);
129 nc->state = NCSI_CHANNEL_ACTIVE;
130 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
131 spin_unlock_irqrestore(&ndp->lock, flags);
132 ncsi_process_next_channel(ndp);
133 return;
134 }
135
136 spin_lock_irqsave(&nc->lock, flags);
137 nc->monitor.state++;
138 spin_unlock_irqrestore(&nc->lock, flags);
139 mod_timer(&nc->monitor.timer, jiffies + HZ);
140 }
141
142 void ncsi_start_channel_monitor(struct ncsi_channel *nc)
143 {
144 unsigned long flags;
145
146 spin_lock_irqsave(&nc->lock, flags);
147 WARN_ON_ONCE(nc->monitor.enabled);
148 nc->monitor.enabled = true;
149 nc->monitor.state = NCSI_CHANNEL_MONITOR_START;
150 spin_unlock_irqrestore(&nc->lock, flags);
151
152 mod_timer(&nc->monitor.timer, jiffies + HZ);
153 }
154
155 void ncsi_stop_channel_monitor(struct ncsi_channel *nc)
156 {
157 unsigned long flags;
158
159 spin_lock_irqsave(&nc->lock, flags);
160 if (!nc->monitor.enabled) {
161 spin_unlock_irqrestore(&nc->lock, flags);
162 return;
163 }
164 nc->monitor.enabled = false;
165 spin_unlock_irqrestore(&nc->lock, flags);
166
167 del_timer_sync(&nc->monitor.timer);
168 }
169
170 struct ncsi_channel *ncsi_find_channel(struct ncsi_package *np,
171 unsigned char id)
172 {
173 struct ncsi_channel *nc;
174
175 NCSI_FOR_EACH_CHANNEL(np, nc) {
176 if (nc->id == id)
177 return nc;
178 }
179
180 return NULL;
181 }
182
183 struct ncsi_channel *ncsi_add_channel(struct ncsi_package *np, unsigned char id)
184 {
185 struct ncsi_channel *nc, *tmp;
186 int index;
187 unsigned long flags;
188
189 nc = kzalloc(sizeof(*nc), GFP_ATOMIC);
190 if (!nc)
191 return NULL;
192
193 nc->id = id;
194 nc->package = np;
195 nc->state = NCSI_CHANNEL_INACTIVE;
196 nc->monitor.enabled = false;
197 timer_setup(&nc->monitor.timer, ncsi_channel_monitor, 0);
198 spin_lock_init(&nc->lock);
199 INIT_LIST_HEAD(&nc->link);
200 for (index = 0; index < NCSI_CAP_MAX; index++)
201 nc->caps[index].index = index;
202 for (index = 0; index < NCSI_MODE_MAX; index++)
203 nc->modes[index].index = index;
204
205 spin_lock_irqsave(&np->lock, flags);
206 tmp = ncsi_find_channel(np, id);
207 if (tmp) {
208 spin_unlock_irqrestore(&np->lock, flags);
209 kfree(nc);
210 return tmp;
211 }
212
213 list_add_tail_rcu(&nc->node, &np->channels);
214 np->channel_num++;
215 spin_unlock_irqrestore(&np->lock, flags);
216
217 return nc;
218 }
219
220 static void ncsi_remove_channel(struct ncsi_channel *nc)
221 {
222 struct ncsi_package *np = nc->package;
223 unsigned long flags;
224
225 spin_lock_irqsave(&nc->lock, flags);
226
227 /* Release filters */
228 kfree(nc->mac_filter.addrs);
229 kfree(nc->vlan_filter.vids);
230
231 nc->state = NCSI_CHANNEL_INACTIVE;
232 spin_unlock_irqrestore(&nc->lock, flags);
233 ncsi_stop_channel_monitor(nc);
234
235 /* Remove and free channel */
236 spin_lock_irqsave(&np->lock, flags);
237 list_del_rcu(&nc->node);
238 np->channel_num--;
239 spin_unlock_irqrestore(&np->lock, flags);
240
241 kfree(nc);
242 }
243
244 struct ncsi_package *ncsi_find_package(struct ncsi_dev_priv *ndp,
245 unsigned char id)
246 {
247 struct ncsi_package *np;
248
249 NCSI_FOR_EACH_PACKAGE(ndp, np) {
250 if (np->id == id)
251 return np;
252 }
253
254 return NULL;
255 }
256
257 struct ncsi_package *ncsi_add_package(struct ncsi_dev_priv *ndp,
258 unsigned char id)
259 {
260 struct ncsi_package *np, *tmp;
261 unsigned long flags;
262
263 np = kzalloc(sizeof(*np), GFP_ATOMIC);
264 if (!np)
265 return NULL;
266
267 np->id = id;
268 np->ndp = ndp;
269 spin_lock_init(&np->lock);
270 INIT_LIST_HEAD(&np->channels);
271
272 spin_lock_irqsave(&ndp->lock, flags);
273 tmp = ncsi_find_package(ndp, id);
274 if (tmp) {
275 spin_unlock_irqrestore(&ndp->lock, flags);
276 kfree(np);
277 return tmp;
278 }
279
280 list_add_tail_rcu(&np->node, &ndp->packages);
281 ndp->package_num++;
282 spin_unlock_irqrestore(&ndp->lock, flags);
283
284 return np;
285 }
286
287 void ncsi_remove_package(struct ncsi_package *np)
288 {
289 struct ncsi_dev_priv *ndp = np->ndp;
290 struct ncsi_channel *nc, *tmp;
291 unsigned long flags;
292
293 /* Release all child channels */
294 list_for_each_entry_safe(nc, tmp, &np->channels, node)
295 ncsi_remove_channel(nc);
296
297 /* Remove and free package */
298 spin_lock_irqsave(&ndp->lock, flags);
299 list_del_rcu(&np->node);
300 ndp->package_num--;
301 spin_unlock_irqrestore(&ndp->lock, flags);
302
303 kfree(np);
304 }
305
306 void ncsi_find_package_and_channel(struct ncsi_dev_priv *ndp,
307 unsigned char id,
308 struct ncsi_package **np,
309 struct ncsi_channel **nc)
310 {
311 struct ncsi_package *p;
312 struct ncsi_channel *c;
313
314 p = ncsi_find_package(ndp, NCSI_PACKAGE_INDEX(id));
315 c = p ? ncsi_find_channel(p, NCSI_CHANNEL_INDEX(id)) : NULL;
316
317 if (np)
318 *np = p;
319 if (nc)
320 *nc = c;
321 }
322
323 /* For two consecutive NCSI commands, the packet IDs shouldn't
324 * be same. Otherwise, the bogus response might be replied. So
325 * the available IDs are allocated in round-robin fashion.
326 */
327 struct ncsi_request *ncsi_alloc_request(struct ncsi_dev_priv *ndp,
328 unsigned int req_flags)
329 {
330 struct ncsi_request *nr = NULL;
331 int i, limit = ARRAY_SIZE(ndp->requests);
332 unsigned long flags;
333
334 /* Check if there is one available request until the ceiling */
335 spin_lock_irqsave(&ndp->lock, flags);
336 for (i = ndp->request_id; i < limit; i++) {
337 if (ndp->requests[i].used)
338 continue;
339
340 nr = &ndp->requests[i];
341 nr->used = true;
342 nr->flags = req_flags;
343 ndp->request_id = i + 1;
344 goto found;
345 }
346
347 /* Fail back to check from the starting cursor */
348 for (i = NCSI_REQ_START_IDX; i < ndp->request_id; i++) {
349 if (ndp->requests[i].used)
350 continue;
351
352 nr = &ndp->requests[i];
353 nr->used = true;
354 nr->flags = req_flags;
355 ndp->request_id = i + 1;
356 goto found;
357 }
358
359 found:
360 spin_unlock_irqrestore(&ndp->lock, flags);
361 return nr;
362 }
363
364 void ncsi_free_request(struct ncsi_request *nr)
365 {
366 struct ncsi_dev_priv *ndp = nr->ndp;
367 struct sk_buff *cmd, *rsp;
368 unsigned long flags;
369 bool driven;
370
371 if (nr->enabled) {
372 nr->enabled = false;
373 del_timer_sync(&nr->timer);
374 }
375
376 spin_lock_irqsave(&ndp->lock, flags);
377 cmd = nr->cmd;
378 rsp = nr->rsp;
379 nr->cmd = NULL;
380 nr->rsp = NULL;
381 nr->used = false;
382 driven = !!(nr->flags & NCSI_REQ_FLAG_EVENT_DRIVEN);
383 spin_unlock_irqrestore(&ndp->lock, flags);
384
385 if (driven && cmd && --ndp->pending_req_num == 0)
386 schedule_work(&ndp->work);
387
388 /* Release command and response */
389 consume_skb(cmd);
390 consume_skb(rsp);
391 }
392
393 struct ncsi_dev *ncsi_find_dev(struct net_device *dev)
394 {
395 struct ncsi_dev_priv *ndp;
396
397 NCSI_FOR_EACH_DEV(ndp) {
398 if (ndp->ndev.dev == dev)
399 return &ndp->ndev;
400 }
401
402 return NULL;
403 }
404
405 static void ncsi_request_timeout(struct timer_list *t)
406 {
407 struct ncsi_request *nr = from_timer(nr, t, timer);
408 struct ncsi_dev_priv *ndp = nr->ndp;
409 unsigned long flags;
410
411 /* If the request already had associated response,
412 * let the response handler to release it.
413 */
414 spin_lock_irqsave(&ndp->lock, flags);
415 nr->enabled = false;
416 if (nr->rsp || !nr->cmd) {
417 spin_unlock_irqrestore(&ndp->lock, flags);
418 return;
419 }
420 spin_unlock_irqrestore(&ndp->lock, flags);
421
422 /* Release the request */
423 ncsi_free_request(nr);
424 }
425
426 static void ncsi_suspend_channel(struct ncsi_dev_priv *ndp)
427 {
428 struct ncsi_dev *nd = &ndp->ndev;
429 struct ncsi_package *np = ndp->active_package;
430 struct ncsi_channel *nc = ndp->active_channel;
431 struct ncsi_cmd_arg nca;
432 unsigned long flags;
433 int ret;
434
435 nca.ndp = ndp;
436 nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
437 switch (nd->state) {
438 case ncsi_dev_state_suspend:
439 nd->state = ncsi_dev_state_suspend_select;
440 /* Fall through */
441 case ncsi_dev_state_suspend_select:
442 ndp->pending_req_num = 1;
443
444 nca.type = NCSI_PKT_CMD_SP;
445 nca.package = np->id;
446 nca.channel = NCSI_RESERVED_CHANNEL;
447 if (ndp->flags & NCSI_DEV_HWA)
448 nca.bytes[0] = 0;
449 else
450 nca.bytes[0] = 1;
451
452 /* To retrieve the last link states of channels in current
453 * package when current active channel needs fail over to
454 * another one. It means we will possibly select another
455 * channel as next active one. The link states of channels
456 * are most important factor of the selection. So we need
457 * accurate link states. Unfortunately, the link states on
458 * inactive channels can't be updated with LSC AEN in time.
459 */
460 if (ndp->flags & NCSI_DEV_RESHUFFLE)
461 nd->state = ncsi_dev_state_suspend_gls;
462 else
463 nd->state = ncsi_dev_state_suspend_dcnt;
464 ret = ncsi_xmit_cmd(&nca);
465 if (ret)
466 goto error;
467
468 break;
469 case ncsi_dev_state_suspend_gls:
470 ndp->pending_req_num = np->channel_num;
471
472 nca.type = NCSI_PKT_CMD_GLS;
473 nca.package = np->id;
474
475 nd->state = ncsi_dev_state_suspend_dcnt;
476 NCSI_FOR_EACH_CHANNEL(np, nc) {
477 nca.channel = nc->id;
478 ret = ncsi_xmit_cmd(&nca);
479 if (ret)
480 goto error;
481 }
482
483 break;
484 case ncsi_dev_state_suspend_dcnt:
485 ndp->pending_req_num = 1;
486
487 nca.type = NCSI_PKT_CMD_DCNT;
488 nca.package = np->id;
489 nca.channel = nc->id;
490
491 nd->state = ncsi_dev_state_suspend_dc;
492 ret = ncsi_xmit_cmd(&nca);
493 if (ret)
494 goto error;
495
496 break;
497 case ncsi_dev_state_suspend_dc:
498 ndp->pending_req_num = 1;
499
500 nca.type = NCSI_PKT_CMD_DC;
501 nca.package = np->id;
502 nca.channel = nc->id;
503 nca.bytes[0] = 1;
504
505 nd->state = ncsi_dev_state_suspend_deselect;
506 ret = ncsi_xmit_cmd(&nca);
507 if (ret)
508 goto error;
509
510 break;
511 case ncsi_dev_state_suspend_deselect:
512 ndp->pending_req_num = 1;
513
514 nca.type = NCSI_PKT_CMD_DP;
515 nca.package = np->id;
516 nca.channel = NCSI_RESERVED_CHANNEL;
517
518 nd->state = ncsi_dev_state_suspend_done;
519 ret = ncsi_xmit_cmd(&nca);
520 if (ret)
521 goto error;
522
523 break;
524 case ncsi_dev_state_suspend_done:
525 spin_lock_irqsave(&nc->lock, flags);
526 nc->state = NCSI_CHANNEL_INACTIVE;
527 spin_unlock_irqrestore(&nc->lock, flags);
528 ncsi_process_next_channel(ndp);
529
530 break;
531 default:
532 netdev_warn(nd->dev, "Wrong NCSI state 0x%x in suspend\n",
533 nd->state);
534 }
535
536 return;
537 error:
538 nd->state = ncsi_dev_state_functional;
539 }
540
541 /* Check the VLAN filter bitmap for a set filter, and construct a
542 * "Set VLAN Filter - Disable" packet if found.
543 */
544 static int clear_one_vid(struct ncsi_dev_priv *ndp, struct ncsi_channel *nc,
545 struct ncsi_cmd_arg *nca)
546 {
547 struct ncsi_channel_vlan_filter *ncf;
548 unsigned long flags;
549 void *bitmap;
550 int index;
551 u16 vid;
552
553 ncf = &nc->vlan_filter;
554 bitmap = &ncf->bitmap;
555
556 spin_lock_irqsave(&nc->lock, flags);
557 index = find_next_bit(bitmap, ncf->n_vids, 0);
558 if (index >= ncf->n_vids) {
559 spin_unlock_irqrestore(&nc->lock, flags);
560 return -1;
561 }
562 vid = ncf->vids[index];
563
564 clear_bit(index, bitmap);
565 ncf->vids[index] = 0;
566 spin_unlock_irqrestore(&nc->lock, flags);
567
568 nca->type = NCSI_PKT_CMD_SVF;
569 nca->words[1] = vid;
570 /* HW filter index starts at 1 */
571 nca->bytes[6] = index + 1;
572 nca->bytes[7] = 0x00;
573 return 0;
574 }
575
576 /* Find an outstanding VLAN tag and constuct a "Set VLAN Filter - Enable"
577 * packet.
578 */
579 static int set_one_vid(struct ncsi_dev_priv *ndp, struct ncsi_channel *nc,
580 struct ncsi_cmd_arg *nca)
581 {
582 struct ncsi_channel_vlan_filter *ncf;
583 struct vlan_vid *vlan = NULL;
584 unsigned long flags;
585 int i, index;
586 void *bitmap;
587 u16 vid;
588
589 if (list_empty(&ndp->vlan_vids))
590 return -1;
591
592 ncf = &nc->vlan_filter;
593 bitmap = &ncf->bitmap;
594
595 spin_lock_irqsave(&nc->lock, flags);
596
597 rcu_read_lock();
598 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
599 vid = vlan->vid;
600 for (i = 0; i < ncf->n_vids; i++)
601 if (ncf->vids[i] == vid) {
602 vid = 0;
603 break;
604 }
605 if (vid)
606 break;
607 }
608 rcu_read_unlock();
609
610 if (!vid) {
611 /* No VLAN ID is not set */
612 spin_unlock_irqrestore(&nc->lock, flags);
613 return -1;
614 }
615
616 index = find_next_zero_bit(bitmap, ncf->n_vids, 0);
617 if (index < 0 || index >= ncf->n_vids) {
618 netdev_err(ndp->ndev.dev,
619 "Channel %u already has all VLAN filters set\n",
620 nc->id);
621 spin_unlock_irqrestore(&nc->lock, flags);
622 return -1;
623 }
624
625 ncf->vids[index] = vid;
626 set_bit(index, bitmap);
627 spin_unlock_irqrestore(&nc->lock, flags);
628
629 nca->type = NCSI_PKT_CMD_SVF;
630 nca->words[1] = vid;
631 /* HW filter index starts at 1 */
632 nca->bytes[6] = index + 1;
633 nca->bytes[7] = 0x01;
634
635 return 0;
636 }
637
638 static void ncsi_configure_channel(struct ncsi_dev_priv *ndp)
639 {
640 struct ncsi_dev *nd = &ndp->ndev;
641 struct net_device *dev = nd->dev;
642 struct ncsi_package *np = ndp->active_package;
643 struct ncsi_channel *nc = ndp->active_channel;
644 struct ncsi_channel *hot_nc = NULL;
645 struct ncsi_cmd_arg nca;
646 unsigned char index;
647 unsigned long flags;
648 int ret;
649
650 nca.ndp = ndp;
651 nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
652 switch (nd->state) {
653 case ncsi_dev_state_config:
654 case ncsi_dev_state_config_sp:
655 ndp->pending_req_num = 1;
656
657 /* Select the specific package */
658 nca.type = NCSI_PKT_CMD_SP;
659 if (ndp->flags & NCSI_DEV_HWA)
660 nca.bytes[0] = 0;
661 else
662 nca.bytes[0] = 1;
663 nca.package = np->id;
664 nca.channel = NCSI_RESERVED_CHANNEL;
665 ret = ncsi_xmit_cmd(&nca);
666 if (ret) {
667 netdev_err(ndp->ndev.dev,
668 "NCSI: Failed to transmit CMD_SP\n");
669 goto error;
670 }
671
672 nd->state = ncsi_dev_state_config_cis;
673 break;
674 case ncsi_dev_state_config_cis:
675 ndp->pending_req_num = 1;
676
677 /* Clear initial state */
678 nca.type = NCSI_PKT_CMD_CIS;
679 nca.package = np->id;
680 nca.channel = nc->id;
681 ret = ncsi_xmit_cmd(&nca);
682 if (ret) {
683 netdev_err(ndp->ndev.dev,
684 "NCSI: Failed to transmit CMD_CIS\n");
685 goto error;
686 }
687
688 nd->state = ncsi_dev_state_config_clear_vids;
689 break;
690 case ncsi_dev_state_config_clear_vids:
691 case ncsi_dev_state_config_svf:
692 case ncsi_dev_state_config_ev:
693 case ncsi_dev_state_config_sma:
694 case ncsi_dev_state_config_ebf:
695 #if IS_ENABLED(CONFIG_IPV6)
696 case ncsi_dev_state_config_egmf:
697 #endif
698 case ncsi_dev_state_config_ecnt:
699 case ncsi_dev_state_config_ec:
700 case ncsi_dev_state_config_ae:
701 case ncsi_dev_state_config_gls:
702 ndp->pending_req_num = 1;
703
704 nca.package = np->id;
705 nca.channel = nc->id;
706
707 /* Clear any active filters on the channel before setting */
708 if (nd->state == ncsi_dev_state_config_clear_vids) {
709 ret = clear_one_vid(ndp, nc, &nca);
710 if (ret) {
711 nd->state = ncsi_dev_state_config_svf;
712 schedule_work(&ndp->work);
713 break;
714 }
715 /* Repeat */
716 nd->state = ncsi_dev_state_config_clear_vids;
717 /* Add known VLAN tags to the filter */
718 } else if (nd->state == ncsi_dev_state_config_svf) {
719 ret = set_one_vid(ndp, nc, &nca);
720 if (ret) {
721 nd->state = ncsi_dev_state_config_ev;
722 schedule_work(&ndp->work);
723 break;
724 }
725 /* Repeat */
726 nd->state = ncsi_dev_state_config_svf;
727 /* Enable/Disable the VLAN filter */
728 } else if (nd->state == ncsi_dev_state_config_ev) {
729 if (list_empty(&ndp->vlan_vids)) {
730 nca.type = NCSI_PKT_CMD_DV;
731 } else {
732 nca.type = NCSI_PKT_CMD_EV;
733 nca.bytes[3] = NCSI_CAP_VLAN_NO;
734 }
735 nd->state = ncsi_dev_state_config_sma;
736 } else if (nd->state == ncsi_dev_state_config_sma) {
737 /* Use first entry in unicast filter table. Note that
738 * the MAC filter table starts from entry 1 instead of
739 * 0.
740 */
741 nca.type = NCSI_PKT_CMD_SMA;
742 for (index = 0; index < 6; index++)
743 nca.bytes[index] = dev->dev_addr[index];
744 nca.bytes[6] = 0x1;
745 nca.bytes[7] = 0x1;
746 nd->state = ncsi_dev_state_config_ebf;
747 } else if (nd->state == ncsi_dev_state_config_ebf) {
748 nca.type = NCSI_PKT_CMD_EBF;
749 nca.dwords[0] = nc->caps[NCSI_CAP_BC].cap;
750 nd->state = ncsi_dev_state_config_ecnt;
751 #if IS_ENABLED(CONFIG_IPV6)
752 if (ndp->inet6_addr_num > 0 &&
753 (nc->caps[NCSI_CAP_GENERIC].cap &
754 NCSI_CAP_GENERIC_MC))
755 nd->state = ncsi_dev_state_config_egmf;
756 else
757 nd->state = ncsi_dev_state_config_ecnt;
758 } else if (nd->state == ncsi_dev_state_config_egmf) {
759 nca.type = NCSI_PKT_CMD_EGMF;
760 nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap;
761 nd->state = ncsi_dev_state_config_ecnt;
762 #endif /* CONFIG_IPV6 */
763 } else if (nd->state == ncsi_dev_state_config_ecnt) {
764 nca.type = NCSI_PKT_CMD_ECNT;
765 nd->state = ncsi_dev_state_config_ec;
766 } else if (nd->state == ncsi_dev_state_config_ec) {
767 /* Enable AEN if it's supported */
768 nca.type = NCSI_PKT_CMD_EC;
769 nd->state = ncsi_dev_state_config_ae;
770 if (!(nc->caps[NCSI_CAP_AEN].cap & NCSI_CAP_AEN_MASK))
771 nd->state = ncsi_dev_state_config_gls;
772 } else if (nd->state == ncsi_dev_state_config_ae) {
773 nca.type = NCSI_PKT_CMD_AE;
774 nca.bytes[0] = 0;
775 nca.dwords[1] = nc->caps[NCSI_CAP_AEN].cap;
776 nd->state = ncsi_dev_state_config_gls;
777 } else if (nd->state == ncsi_dev_state_config_gls) {
778 nca.type = NCSI_PKT_CMD_GLS;
779 nd->state = ncsi_dev_state_config_done;
780 }
781
782 ret = ncsi_xmit_cmd(&nca);
783 if (ret) {
784 netdev_err(ndp->ndev.dev,
785 "NCSI: Failed to transmit CMD %x\n",
786 nca.type);
787 goto error;
788 }
789 break;
790 case ncsi_dev_state_config_done:
791 netdev_dbg(ndp->ndev.dev, "NCSI: channel %u config done\n",
792 nc->id);
793 spin_lock_irqsave(&nc->lock, flags);
794 if (nc->reconfigure_needed) {
795 /* This channel's configuration has been updated
796 * part-way during the config state - start the
797 * channel configuration over
798 */
799 nc->reconfigure_needed = false;
800 nc->state = NCSI_CHANNEL_INACTIVE;
801 spin_unlock_irqrestore(&nc->lock, flags);
802
803 spin_lock_irqsave(&ndp->lock, flags);
804 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
805 spin_unlock_irqrestore(&ndp->lock, flags);
806
807 netdev_dbg(dev, "Dirty NCSI channel state reset\n");
808 ncsi_process_next_channel(ndp);
809 break;
810 }
811
812 if (nc->modes[NCSI_MODE_LINK].data[2] & 0x1) {
813 hot_nc = nc;
814 nc->state = NCSI_CHANNEL_ACTIVE;
815 } else {
816 hot_nc = NULL;
817 nc->state = NCSI_CHANNEL_INACTIVE;
818 netdev_dbg(ndp->ndev.dev,
819 "NCSI: channel %u link down after config\n",
820 nc->id);
821 }
822 spin_unlock_irqrestore(&nc->lock, flags);
823
824 /* Update the hot channel */
825 spin_lock_irqsave(&ndp->lock, flags);
826 ndp->hot_channel = hot_nc;
827 spin_unlock_irqrestore(&ndp->lock, flags);
828
829 ncsi_start_channel_monitor(nc);
830 ncsi_process_next_channel(ndp);
831 break;
832 default:
833 netdev_alert(dev, "Wrong NCSI state 0x%x in config\n",
834 nd->state);
835 }
836
837 return;
838
839 error:
840 ncsi_report_link(ndp, true);
841 }
842
843 static int ncsi_choose_active_channel(struct ncsi_dev_priv *ndp)
844 {
845 struct ncsi_package *np, *force_package;
846 struct ncsi_channel *nc, *found, *hot_nc, *force_channel;
847 struct ncsi_channel_mode *ncm;
848 unsigned long flags;
849
850 spin_lock_irqsave(&ndp->lock, flags);
851 hot_nc = ndp->hot_channel;
852 force_channel = ndp->force_channel;
853 force_package = ndp->force_package;
854 spin_unlock_irqrestore(&ndp->lock, flags);
855
856 /* Force a specific channel whether or not it has link if we have been
857 * configured to do so
858 */
859 if (force_package && force_channel) {
860 found = force_channel;
861 ncm = &found->modes[NCSI_MODE_LINK];
862 if (!(ncm->data[2] & 0x1))
863 netdev_info(ndp->ndev.dev,
864 "NCSI: Channel %u forced, but it is link down\n",
865 found->id);
866 goto out;
867 }
868
869 /* The search is done once an inactive channel with up
870 * link is found.
871 */
872 found = NULL;
873 NCSI_FOR_EACH_PACKAGE(ndp, np) {
874 if (ndp->force_package && np != ndp->force_package)
875 continue;
876 NCSI_FOR_EACH_CHANNEL(np, nc) {
877 spin_lock_irqsave(&nc->lock, flags);
878
879 if (!list_empty(&nc->link) ||
880 nc->state != NCSI_CHANNEL_INACTIVE) {
881 spin_unlock_irqrestore(&nc->lock, flags);
882 continue;
883 }
884
885 if (!found)
886 found = nc;
887
888 if (nc == hot_nc)
889 found = nc;
890
891 ncm = &nc->modes[NCSI_MODE_LINK];
892 if (ncm->data[2] & 0x1) {
893 spin_unlock_irqrestore(&nc->lock, flags);
894 found = nc;
895 goto out;
896 }
897
898 spin_unlock_irqrestore(&nc->lock, flags);
899 }
900 }
901
902 if (!found) {
903 netdev_warn(ndp->ndev.dev,
904 "NCSI: No channel found with link\n");
905 ncsi_report_link(ndp, true);
906 return -ENODEV;
907 }
908
909 ncm = &found->modes[NCSI_MODE_LINK];
910 netdev_dbg(ndp->ndev.dev,
911 "NCSI: Channel %u added to queue (link %s)\n",
912 found->id, ncm->data[2] & 0x1 ? "up" : "down");
913
914 out:
915 spin_lock_irqsave(&ndp->lock, flags);
916 list_add_tail_rcu(&found->link, &ndp->channel_queue);
917 spin_unlock_irqrestore(&ndp->lock, flags);
918
919 return ncsi_process_next_channel(ndp);
920 }
921
922 static bool ncsi_check_hwa(struct ncsi_dev_priv *ndp)
923 {
924 struct ncsi_package *np;
925 struct ncsi_channel *nc;
926 unsigned int cap;
927 bool has_channel = false;
928
929 /* The hardware arbitration is disabled if any one channel
930 * doesn't support explicitly.
931 */
932 NCSI_FOR_EACH_PACKAGE(ndp, np) {
933 NCSI_FOR_EACH_CHANNEL(np, nc) {
934 has_channel = true;
935
936 cap = nc->caps[NCSI_CAP_GENERIC].cap;
937 if (!(cap & NCSI_CAP_GENERIC_HWA) ||
938 (cap & NCSI_CAP_GENERIC_HWA_MASK) !=
939 NCSI_CAP_GENERIC_HWA_SUPPORT) {
940 ndp->flags &= ~NCSI_DEV_HWA;
941 return false;
942 }
943 }
944 }
945
946 if (has_channel) {
947 ndp->flags |= NCSI_DEV_HWA;
948 return true;
949 }
950
951 ndp->flags &= ~NCSI_DEV_HWA;
952 return false;
953 }
954
955 static int ncsi_enable_hwa(struct ncsi_dev_priv *ndp)
956 {
957 struct ncsi_package *np;
958 struct ncsi_channel *nc;
959 unsigned long flags;
960
961 /* Move all available channels to processing queue */
962 spin_lock_irqsave(&ndp->lock, flags);
963 NCSI_FOR_EACH_PACKAGE(ndp, np) {
964 NCSI_FOR_EACH_CHANNEL(np, nc) {
965 WARN_ON_ONCE(nc->state != NCSI_CHANNEL_INACTIVE ||
966 !list_empty(&nc->link));
967 ncsi_stop_channel_monitor(nc);
968 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
969 }
970 }
971 spin_unlock_irqrestore(&ndp->lock, flags);
972
973 /* We can have no channels in extremely case */
974 if (list_empty(&ndp->channel_queue)) {
975 netdev_err(ndp->ndev.dev,
976 "NCSI: No available channels for HWA\n");
977 ncsi_report_link(ndp, false);
978 return -ENOENT;
979 }
980
981 return ncsi_process_next_channel(ndp);
982 }
983
984 static void ncsi_probe_channel(struct ncsi_dev_priv *ndp)
985 {
986 struct ncsi_dev *nd = &ndp->ndev;
987 struct ncsi_package *np;
988 struct ncsi_channel *nc;
989 struct ncsi_cmd_arg nca;
990 unsigned char index;
991 int ret;
992
993 nca.ndp = ndp;
994 nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
995 switch (nd->state) {
996 case ncsi_dev_state_probe:
997 nd->state = ncsi_dev_state_probe_deselect;
998 /* Fall through */
999 case ncsi_dev_state_probe_deselect:
1000 ndp->pending_req_num = 8;
1001
1002 /* Deselect all possible packages */
1003 nca.type = NCSI_PKT_CMD_DP;
1004 nca.channel = NCSI_RESERVED_CHANNEL;
1005 for (index = 0; index < 8; index++) {
1006 nca.package = index;
1007 ret = ncsi_xmit_cmd(&nca);
1008 if (ret)
1009 goto error;
1010 }
1011
1012 nd->state = ncsi_dev_state_probe_package;
1013 break;
1014 case ncsi_dev_state_probe_package:
1015 ndp->pending_req_num = 16;
1016
1017 /* Select all possible packages */
1018 nca.type = NCSI_PKT_CMD_SP;
1019 nca.bytes[0] = 1;
1020 nca.channel = NCSI_RESERVED_CHANNEL;
1021 for (index = 0; index < 8; index++) {
1022 nca.package = index;
1023 ret = ncsi_xmit_cmd(&nca);
1024 if (ret)
1025 goto error;
1026 }
1027
1028 /* Disable all possible packages */
1029 nca.type = NCSI_PKT_CMD_DP;
1030 for (index = 0; index < 8; index++) {
1031 nca.package = index;
1032 ret = ncsi_xmit_cmd(&nca);
1033 if (ret)
1034 goto error;
1035 }
1036
1037 nd->state = ncsi_dev_state_probe_channel;
1038 break;
1039 case ncsi_dev_state_probe_channel:
1040 if (!ndp->active_package)
1041 ndp->active_package = list_first_or_null_rcu(
1042 &ndp->packages, struct ncsi_package, node);
1043 else if (list_is_last(&ndp->active_package->node,
1044 &ndp->packages))
1045 ndp->active_package = NULL;
1046 else
1047 ndp->active_package = list_next_entry(
1048 ndp->active_package, node);
1049
1050 /* All available packages and channels are enumerated. The
1051 * enumeration happens for once when the NCSI interface is
1052 * started. So we need continue to start the interface after
1053 * the enumeration.
1054 *
1055 * We have to choose an active channel before configuring it.
1056 * Note that we possibly don't have active channel in extreme
1057 * situation.
1058 */
1059 if (!ndp->active_package) {
1060 ndp->flags |= NCSI_DEV_PROBED;
1061 if (ncsi_check_hwa(ndp))
1062 ncsi_enable_hwa(ndp);
1063 else
1064 ncsi_choose_active_channel(ndp);
1065 return;
1066 }
1067
1068 /* Select the active package */
1069 ndp->pending_req_num = 1;
1070 nca.type = NCSI_PKT_CMD_SP;
1071 nca.bytes[0] = 1;
1072 nca.package = ndp->active_package->id;
1073 nca.channel = NCSI_RESERVED_CHANNEL;
1074 ret = ncsi_xmit_cmd(&nca);
1075 if (ret)
1076 goto error;
1077
1078 nd->state = ncsi_dev_state_probe_cis;
1079 break;
1080 case ncsi_dev_state_probe_cis:
1081 ndp->pending_req_num = NCSI_RESERVED_CHANNEL;
1082
1083 /* Clear initial state */
1084 nca.type = NCSI_PKT_CMD_CIS;
1085 nca.package = ndp->active_package->id;
1086 for (index = 0; index < NCSI_RESERVED_CHANNEL; index++) {
1087 nca.channel = index;
1088 ret = ncsi_xmit_cmd(&nca);
1089 if (ret)
1090 goto error;
1091 }
1092
1093 nd->state = ncsi_dev_state_probe_gvi;
1094 break;
1095 case ncsi_dev_state_probe_gvi:
1096 case ncsi_dev_state_probe_gc:
1097 case ncsi_dev_state_probe_gls:
1098 np = ndp->active_package;
1099 ndp->pending_req_num = np->channel_num;
1100
1101 /* Retrieve version, capability or link status */
1102 if (nd->state == ncsi_dev_state_probe_gvi)
1103 nca.type = NCSI_PKT_CMD_GVI;
1104 else if (nd->state == ncsi_dev_state_probe_gc)
1105 nca.type = NCSI_PKT_CMD_GC;
1106 else
1107 nca.type = NCSI_PKT_CMD_GLS;
1108
1109 nca.package = np->id;
1110 NCSI_FOR_EACH_CHANNEL(np, nc) {
1111 nca.channel = nc->id;
1112 ret = ncsi_xmit_cmd(&nca);
1113 if (ret)
1114 goto error;
1115 }
1116
1117 if (nd->state == ncsi_dev_state_probe_gvi)
1118 nd->state = ncsi_dev_state_probe_gc;
1119 else if (nd->state == ncsi_dev_state_probe_gc)
1120 nd->state = ncsi_dev_state_probe_gls;
1121 else
1122 nd->state = ncsi_dev_state_probe_dp;
1123 break;
1124 case ncsi_dev_state_probe_dp:
1125 ndp->pending_req_num = 1;
1126
1127 /* Deselect the active package */
1128 nca.type = NCSI_PKT_CMD_DP;
1129 nca.package = ndp->active_package->id;
1130 nca.channel = NCSI_RESERVED_CHANNEL;
1131 ret = ncsi_xmit_cmd(&nca);
1132 if (ret)
1133 goto error;
1134
1135 /* Scan channels in next package */
1136 nd->state = ncsi_dev_state_probe_channel;
1137 break;
1138 default:
1139 netdev_warn(nd->dev, "Wrong NCSI state 0x%0x in enumeration\n",
1140 nd->state);
1141 }
1142
1143 return;
1144 error:
1145 netdev_err(ndp->ndev.dev,
1146 "NCSI: Failed to transmit cmd 0x%x during probe\n",
1147 nca.type);
1148 ncsi_report_link(ndp, true);
1149 }
1150
1151 static void ncsi_dev_work(struct work_struct *work)
1152 {
1153 struct ncsi_dev_priv *ndp = container_of(work,
1154 struct ncsi_dev_priv, work);
1155 struct ncsi_dev *nd = &ndp->ndev;
1156
1157 switch (nd->state & ncsi_dev_state_major) {
1158 case ncsi_dev_state_probe:
1159 ncsi_probe_channel(ndp);
1160 break;
1161 case ncsi_dev_state_suspend:
1162 ncsi_suspend_channel(ndp);
1163 break;
1164 case ncsi_dev_state_config:
1165 ncsi_configure_channel(ndp);
1166 break;
1167 default:
1168 netdev_warn(nd->dev, "Wrong NCSI state 0x%x in workqueue\n",
1169 nd->state);
1170 }
1171 }
1172
1173 int ncsi_process_next_channel(struct ncsi_dev_priv *ndp)
1174 {
1175 struct ncsi_channel *nc;
1176 int old_state;
1177 unsigned long flags;
1178
1179 spin_lock_irqsave(&ndp->lock, flags);
1180 nc = list_first_or_null_rcu(&ndp->channel_queue,
1181 struct ncsi_channel, link);
1182 if (!nc) {
1183 spin_unlock_irqrestore(&ndp->lock, flags);
1184 goto out;
1185 }
1186
1187 list_del_init(&nc->link);
1188 spin_unlock_irqrestore(&ndp->lock, flags);
1189
1190 spin_lock_irqsave(&nc->lock, flags);
1191 old_state = nc->state;
1192 nc->state = NCSI_CHANNEL_INVISIBLE;
1193 spin_unlock_irqrestore(&nc->lock, flags);
1194
1195 ndp->active_channel = nc;
1196 ndp->active_package = nc->package;
1197
1198 switch (old_state) {
1199 case NCSI_CHANNEL_INACTIVE:
1200 ndp->ndev.state = ncsi_dev_state_config;
1201 netdev_dbg(ndp->ndev.dev, "NCSI: configuring channel %u\n",
1202 nc->id);
1203 ncsi_configure_channel(ndp);
1204 break;
1205 case NCSI_CHANNEL_ACTIVE:
1206 ndp->ndev.state = ncsi_dev_state_suspend;
1207 netdev_dbg(ndp->ndev.dev, "NCSI: suspending channel %u\n",
1208 nc->id);
1209 ncsi_suspend_channel(ndp);
1210 break;
1211 default:
1212 netdev_err(ndp->ndev.dev, "Invalid state 0x%x on %d:%d\n",
1213 old_state, nc->package->id, nc->id);
1214 ncsi_report_link(ndp, false);
1215 return -EINVAL;
1216 }
1217
1218 return 0;
1219
1220 out:
1221 ndp->active_channel = NULL;
1222 ndp->active_package = NULL;
1223 if (ndp->flags & NCSI_DEV_RESHUFFLE) {
1224 ndp->flags &= ~NCSI_DEV_RESHUFFLE;
1225 return ncsi_choose_active_channel(ndp);
1226 }
1227
1228 ncsi_report_link(ndp, false);
1229 return -ENODEV;
1230 }
1231
1232 #if IS_ENABLED(CONFIG_IPV6)
1233 static int ncsi_inet6addr_event(struct notifier_block *this,
1234 unsigned long event, void *data)
1235 {
1236 struct inet6_ifaddr *ifa = data;
1237 struct net_device *dev = ifa->idev->dev;
1238 struct ncsi_dev *nd = ncsi_find_dev(dev);
1239 struct ncsi_dev_priv *ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
1240 struct ncsi_package *np;
1241 struct ncsi_channel *nc;
1242 struct ncsi_cmd_arg nca;
1243 bool action;
1244 int ret;
1245
1246 if (!ndp || (ipv6_addr_type(&ifa->addr) &
1247 (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK)))
1248 return NOTIFY_OK;
1249
1250 switch (event) {
1251 case NETDEV_UP:
1252 action = (++ndp->inet6_addr_num) == 1;
1253 nca.type = NCSI_PKT_CMD_EGMF;
1254 break;
1255 case NETDEV_DOWN:
1256 action = (--ndp->inet6_addr_num == 0);
1257 nca.type = NCSI_PKT_CMD_DGMF;
1258 break;
1259 default:
1260 return NOTIFY_OK;
1261 }
1262
1263 /* We might not have active channel or packages. The IPv6
1264 * required multicast will be enabled when active channel
1265 * or packages are chosen.
1266 */
1267 np = ndp->active_package;
1268 nc = ndp->active_channel;
1269 if (!action || !np || !nc)
1270 return NOTIFY_OK;
1271
1272 /* We needn't enable or disable it if the function isn't supported */
1273 if (!(nc->caps[NCSI_CAP_GENERIC].cap & NCSI_CAP_GENERIC_MC))
1274 return NOTIFY_OK;
1275
1276 nca.ndp = ndp;
1277 nca.req_flags = 0;
1278 nca.package = np->id;
1279 nca.channel = nc->id;
1280 nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap;
1281 ret = ncsi_xmit_cmd(&nca);
1282 if (ret) {
1283 netdev_warn(dev, "Fail to %s global multicast filter (%d)\n",
1284 (event == NETDEV_UP) ? "enable" : "disable", ret);
1285 return NOTIFY_DONE;
1286 }
1287
1288 return NOTIFY_OK;
1289 }
1290
1291 static struct notifier_block ncsi_inet6addr_notifier = {
1292 .notifier_call = ncsi_inet6addr_event,
1293 };
1294 #endif /* CONFIG_IPV6 */
1295
1296 static int ncsi_kick_channels(struct ncsi_dev_priv *ndp)
1297 {
1298 struct ncsi_dev *nd = &ndp->ndev;
1299 struct ncsi_channel *nc;
1300 struct ncsi_package *np;
1301 unsigned long flags;
1302 unsigned int n = 0;
1303
1304 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1305 NCSI_FOR_EACH_CHANNEL(np, nc) {
1306 spin_lock_irqsave(&nc->lock, flags);
1307
1308 /* Channels may be busy, mark dirty instead of
1309 * kicking if;
1310 * a) not ACTIVE (configured)
1311 * b) in the channel_queue (to be configured)
1312 * c) it's ndev is in the config state
1313 */
1314 if (nc->state != NCSI_CHANNEL_ACTIVE) {
1315 if ((ndp->ndev.state & 0xff00) ==
1316 ncsi_dev_state_config ||
1317 !list_empty(&nc->link)) {
1318 netdev_dbg(nd->dev,
1319 "NCSI: channel %p marked dirty\n",
1320 nc);
1321 nc->reconfigure_needed = true;
1322 }
1323 spin_unlock_irqrestore(&nc->lock, flags);
1324 continue;
1325 }
1326
1327 spin_unlock_irqrestore(&nc->lock, flags);
1328
1329 ncsi_stop_channel_monitor(nc);
1330 spin_lock_irqsave(&nc->lock, flags);
1331 nc->state = NCSI_CHANNEL_INACTIVE;
1332 spin_unlock_irqrestore(&nc->lock, flags);
1333
1334 spin_lock_irqsave(&ndp->lock, flags);
1335 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1336 spin_unlock_irqrestore(&ndp->lock, flags);
1337
1338 netdev_dbg(nd->dev, "NCSI: kicked channel %p\n", nc);
1339 n++;
1340 }
1341 }
1342
1343 return n;
1344 }
1345
1346 int ncsi_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
1347 {
1348 struct ncsi_dev_priv *ndp;
1349 unsigned int n_vids = 0;
1350 struct vlan_vid *vlan;
1351 struct ncsi_dev *nd;
1352 bool found = false;
1353
1354 if (vid == 0)
1355 return 0;
1356
1357 nd = ncsi_find_dev(dev);
1358 if (!nd) {
1359 netdev_warn(dev, "NCSI: No net_device?\n");
1360 return 0;
1361 }
1362
1363 ndp = TO_NCSI_DEV_PRIV(nd);
1364
1365 /* Add the VLAN id to our internal list */
1366 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
1367 n_vids++;
1368 if (vlan->vid == vid) {
1369 netdev_dbg(dev, "NCSI: vid %u already registered\n",
1370 vid);
1371 return 0;
1372 }
1373 }
1374 if (n_vids >= NCSI_MAX_VLAN_VIDS) {
1375 netdev_warn(dev,
1376 "tried to add vlan id %u but NCSI max already registered (%u)\n",
1377 vid, NCSI_MAX_VLAN_VIDS);
1378 return -ENOSPC;
1379 }
1380
1381 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
1382 if (!vlan)
1383 return -ENOMEM;
1384
1385 vlan->proto = proto;
1386 vlan->vid = vid;
1387 list_add_rcu(&vlan->list, &ndp->vlan_vids);
1388
1389 netdev_dbg(dev, "NCSI: Added new vid %u\n", vid);
1390
1391 found = ncsi_kick_channels(ndp) != 0;
1392
1393 return found ? ncsi_process_next_channel(ndp) : 0;
1394 }
1395 EXPORT_SYMBOL_GPL(ncsi_vlan_rx_add_vid);
1396
1397 int ncsi_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid)
1398 {
1399 struct vlan_vid *vlan, *tmp;
1400 struct ncsi_dev_priv *ndp;
1401 struct ncsi_dev *nd;
1402 bool found = false;
1403
1404 if (vid == 0)
1405 return 0;
1406
1407 nd = ncsi_find_dev(dev);
1408 if (!nd) {
1409 netdev_warn(dev, "NCSI: no net_device?\n");
1410 return 0;
1411 }
1412
1413 ndp = TO_NCSI_DEV_PRIV(nd);
1414
1415 /* Remove the VLAN id from our internal list */
1416 list_for_each_entry_safe(vlan, tmp, &ndp->vlan_vids, list)
1417 if (vlan->vid == vid) {
1418 netdev_dbg(dev, "NCSI: vid %u found, removing\n", vid);
1419 list_del_rcu(&vlan->list);
1420 found = true;
1421 kfree(vlan);
1422 }
1423
1424 if (!found) {
1425 netdev_err(dev, "NCSI: vid %u wasn't registered!\n", vid);
1426 return -EINVAL;
1427 }
1428
1429 found = ncsi_kick_channels(ndp) != 0;
1430
1431 return found ? ncsi_process_next_channel(ndp) : 0;
1432 }
1433 EXPORT_SYMBOL_GPL(ncsi_vlan_rx_kill_vid);
1434
1435 struct ncsi_dev *ncsi_register_dev(struct net_device *dev,
1436 void (*handler)(struct ncsi_dev *ndev))
1437 {
1438 struct ncsi_dev_priv *ndp;
1439 struct ncsi_dev *nd;
1440 unsigned long flags;
1441 int i;
1442
1443 /* Check if the device has been registered or not */
1444 nd = ncsi_find_dev(dev);
1445 if (nd)
1446 return nd;
1447
1448 /* Create NCSI device */
1449 ndp = kzalloc(sizeof(*ndp), GFP_ATOMIC);
1450 if (!ndp)
1451 return NULL;
1452
1453 nd = &ndp->ndev;
1454 nd->state = ncsi_dev_state_registered;
1455 nd->dev = dev;
1456 nd->handler = handler;
1457 ndp->pending_req_num = 0;
1458 INIT_LIST_HEAD(&ndp->channel_queue);
1459 INIT_LIST_HEAD(&ndp->vlan_vids);
1460 INIT_WORK(&ndp->work, ncsi_dev_work);
1461
1462 /* Initialize private NCSI device */
1463 spin_lock_init(&ndp->lock);
1464 INIT_LIST_HEAD(&ndp->packages);
1465 ndp->request_id = NCSI_REQ_START_IDX;
1466 for (i = 0; i < ARRAY_SIZE(ndp->requests); i++) {
1467 ndp->requests[i].id = i;
1468 ndp->requests[i].ndp = ndp;
1469 timer_setup(&ndp->requests[i].timer, ncsi_request_timeout, 0);
1470 }
1471
1472 spin_lock_irqsave(&ncsi_dev_lock, flags);
1473 #if IS_ENABLED(CONFIG_IPV6)
1474 ndp->inet6_addr_num = 0;
1475 if (list_empty(&ncsi_dev_list))
1476 register_inet6addr_notifier(&ncsi_inet6addr_notifier);
1477 #endif
1478 list_add_tail_rcu(&ndp->node, &ncsi_dev_list);
1479 spin_unlock_irqrestore(&ncsi_dev_lock, flags);
1480
1481 /* Register NCSI packet Rx handler */
1482 ndp->ptype.type = cpu_to_be16(ETH_P_NCSI);
1483 ndp->ptype.func = ncsi_rcv_rsp;
1484 ndp->ptype.dev = dev;
1485 dev_add_pack(&ndp->ptype);
1486
1487 /* Set up generic netlink interface */
1488 ncsi_init_netlink(dev);
1489
1490 return nd;
1491 }
1492 EXPORT_SYMBOL_GPL(ncsi_register_dev);
1493
1494 int ncsi_start_dev(struct ncsi_dev *nd)
1495 {
1496 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1497 int ret;
1498
1499 if (nd->state != ncsi_dev_state_registered &&
1500 nd->state != ncsi_dev_state_functional)
1501 return -ENOTTY;
1502
1503 if (!(ndp->flags & NCSI_DEV_PROBED)) {
1504 nd->state = ncsi_dev_state_probe;
1505 schedule_work(&ndp->work);
1506 return 0;
1507 }
1508
1509 if (ndp->flags & NCSI_DEV_HWA) {
1510 netdev_info(ndp->ndev.dev, "NCSI: Enabling HWA mode\n");
1511 ret = ncsi_enable_hwa(ndp);
1512 } else {
1513 ret = ncsi_choose_active_channel(ndp);
1514 }
1515
1516 return ret;
1517 }
1518 EXPORT_SYMBOL_GPL(ncsi_start_dev);
1519
1520 void ncsi_stop_dev(struct ncsi_dev *nd)
1521 {
1522 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1523 struct ncsi_package *np;
1524 struct ncsi_channel *nc;
1525 bool chained;
1526 int old_state;
1527 unsigned long flags;
1528
1529 /* Stop the channel monitor and reset channel's state */
1530 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1531 NCSI_FOR_EACH_CHANNEL(np, nc) {
1532 ncsi_stop_channel_monitor(nc);
1533
1534 spin_lock_irqsave(&nc->lock, flags);
1535 chained = !list_empty(&nc->link);
1536 old_state = nc->state;
1537 nc->state = NCSI_CHANNEL_INACTIVE;
1538 spin_unlock_irqrestore(&nc->lock, flags);
1539
1540 WARN_ON_ONCE(chained ||
1541 old_state == NCSI_CHANNEL_INVISIBLE);
1542 }
1543 }
1544
1545 netdev_dbg(ndp->ndev.dev, "NCSI: Stopping device\n");
1546 ncsi_report_link(ndp, true);
1547 }
1548 EXPORT_SYMBOL_GPL(ncsi_stop_dev);
1549
1550 void ncsi_unregister_dev(struct ncsi_dev *nd)
1551 {
1552 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1553 struct ncsi_package *np, *tmp;
1554 unsigned long flags;
1555
1556 dev_remove_pack(&ndp->ptype);
1557
1558 list_for_each_entry_safe(np, tmp, &ndp->packages, node)
1559 ncsi_remove_package(np);
1560
1561 spin_lock_irqsave(&ncsi_dev_lock, flags);
1562 list_del_rcu(&ndp->node);
1563 #if IS_ENABLED(CONFIG_IPV6)
1564 if (list_empty(&ncsi_dev_list))
1565 unregister_inet6addr_notifier(&ncsi_inet6addr_notifier);
1566 #endif
1567 spin_unlock_irqrestore(&ncsi_dev_lock, flags);
1568
1569 ncsi_unregister_netlink(nd->dev);
1570
1571 kfree(ndp);
1572 }
1573 EXPORT_SYMBOL_GPL(ncsi_unregister_dev);
Linux with added FPC-III support