1
2
3
4
5
6#include <linux/module.h>
7#include <linux/kernel.h>
8#include <linux/init.h>
9#include <linux/netdevice.h>
10#include <linux/skbuff.h>
11
12#include <net/ncsi.h>
13#include <net/net_namespace.h>
14#include <net/sock.h>
15#include <net/addrconf.h>
16#include <net/ipv6.h>
17#include <net/if_inet6.h>
18#include <net/genetlink.h>
19
20#include "internal.h"
21#include "ncsi-pkt.h"
22#include "ncsi-netlink.h"
23
24LIST_HEAD(ncsi_dev_list);
25DEFINE_SPINLOCK(ncsi_dev_lock);
26
27bool ncsi_channel_has_link(struct ncsi_channel *channel)
28{
29 return !!(channel->modes[NCSI_MODE_LINK].data[2] & 0x1);
30}
31
32bool ncsi_channel_is_last(struct ncsi_dev_priv *ndp,
33 struct ncsi_channel *channel)
34{
35 struct ncsi_package *np;
36 struct ncsi_channel *nc;
37
38 NCSI_FOR_EACH_PACKAGE(ndp, np)
39 NCSI_FOR_EACH_CHANNEL(np, nc) {
40 if (nc == channel)
41 continue;
42 if (nc->state == NCSI_CHANNEL_ACTIVE &&
43 ncsi_channel_has_link(nc))
44 return false;
45 }
46
47 return true;
48}
49
50static void ncsi_report_link(struct ncsi_dev_priv *ndp, bool force_down)
51{
52 struct ncsi_dev *nd = &ndp->ndev;
53 struct ncsi_package *np;
54 struct ncsi_channel *nc;
55 unsigned long flags;
56
57 nd->state = ncsi_dev_state_functional;
58 if (force_down) {
59 nd->link_up = 0;
60 goto report;
61 }
62
63 nd->link_up = 0;
64 NCSI_FOR_EACH_PACKAGE(ndp, np) {
65 NCSI_FOR_EACH_CHANNEL(np, nc) {
66 spin_lock_irqsave(&nc->lock, flags);
67
68 if (!list_empty(&nc->link) ||
69 nc->state != NCSI_CHANNEL_ACTIVE) {
70 spin_unlock_irqrestore(&nc->lock, flags);
71 continue;
72 }
73
74 if (ncsi_channel_has_link(nc)) {
75 spin_unlock_irqrestore(&nc->lock, flags);
76 nd->link_up = 1;
77 goto report;
78 }
79
80 spin_unlock_irqrestore(&nc->lock, flags);
81 }
82 }
83
84report:
85 nd->handler(nd);
86}
87
88static void ncsi_channel_monitor(struct timer_list *t)
89{
90 struct ncsi_channel *nc = from_timer(nc, t, monitor.timer);
91 struct ncsi_package *np = nc->package;
92 struct ncsi_dev_priv *ndp = np->ndp;
93 struct ncsi_channel_mode *ncm;
94 struct ncsi_cmd_arg nca;
95 bool enabled, chained;
96 unsigned int monitor_state;
97 unsigned long flags;
98 int state, ret;
99
100 spin_lock_irqsave(&nc->lock, flags);
101 state = nc->state;
102 chained = !list_empty(&nc->link);
103 enabled = nc->monitor.enabled;
104 monitor_state = nc->monitor.state;
105 spin_unlock_irqrestore(&nc->lock, flags);
106
107 if (!enabled || chained) {
108 ncsi_stop_channel_monitor(nc);
109 return;
110 }
111 if (state != NCSI_CHANNEL_INACTIVE &&
112 state != NCSI_CHANNEL_ACTIVE) {
113 ncsi_stop_channel_monitor(nc);
114 return;
115 }
116
117 switch (monitor_state) {
118 case NCSI_CHANNEL_MONITOR_START:
119 case NCSI_CHANNEL_MONITOR_RETRY:
120 nca.ndp = ndp;
121 nca.package = np->id;
122 nca.channel = nc->id;
123 nca.type = NCSI_PKT_CMD_GLS;
124 nca.req_flags = 0;
125 ret = ncsi_xmit_cmd(&nca);
126 if (ret)
127 netdev_err(ndp->ndev.dev, "Error %d sending GLS\n",
128 ret);
129 break;
130 case NCSI_CHANNEL_MONITOR_WAIT ... NCSI_CHANNEL_MONITOR_WAIT_MAX:
131 break;
132 default:
133 netdev_err(ndp->ndev.dev, "NCSI Channel %d timed out!\n",
134 nc->id);
135 ncsi_report_link(ndp, true);
136 ndp->flags |= NCSI_DEV_RESHUFFLE;
137
138 ncsi_stop_channel_monitor(nc);
139
140 ncm = &nc->modes[NCSI_MODE_LINK];
141 spin_lock_irqsave(&nc->lock, flags);
142 nc->state = NCSI_CHANNEL_INVISIBLE;
143 ncm->data[2] &= ~0x1;
144 spin_unlock_irqrestore(&nc->lock, flags);
145
146 spin_lock_irqsave(&ndp->lock, flags);
147 nc->state = NCSI_CHANNEL_ACTIVE;
148 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
149 spin_unlock_irqrestore(&ndp->lock, flags);
150 ncsi_process_next_channel(ndp);
151 return;
152 }
153
154 spin_lock_irqsave(&nc->lock, flags);
155 nc->monitor.state++;
156 spin_unlock_irqrestore(&nc->lock, flags);
157 mod_timer(&nc->monitor.timer, jiffies + HZ);
158}
159
160void ncsi_start_channel_monitor(struct ncsi_channel *nc)
161{
162 unsigned long flags;
163
164 spin_lock_irqsave(&nc->lock, flags);
165 WARN_ON_ONCE(nc->monitor.enabled);
166 nc->monitor.enabled = true;
167 nc->monitor.state = NCSI_CHANNEL_MONITOR_START;
168 spin_unlock_irqrestore(&nc->lock, flags);
169
170 mod_timer(&nc->monitor.timer, jiffies + HZ);
171}
172
173void ncsi_stop_channel_monitor(struct ncsi_channel *nc)
174{
175 unsigned long flags;
176
177 spin_lock_irqsave(&nc->lock, flags);
178 if (!nc->monitor.enabled) {
179 spin_unlock_irqrestore(&nc->lock, flags);
180 return;
181 }
182 nc->monitor.enabled = false;
183 spin_unlock_irqrestore(&nc->lock, flags);
184
185 del_timer_sync(&nc->monitor.timer);
186}
187
188struct ncsi_channel *ncsi_find_channel(struct ncsi_package *np,
189 unsigned char id)
190{
191 struct ncsi_channel *nc;
192
193 NCSI_FOR_EACH_CHANNEL(np, nc) {
194 if (nc->id == id)
195 return nc;
196 }
197
198 return NULL;
199}
200
201struct ncsi_channel *ncsi_add_channel(struct ncsi_package *np, unsigned char id)
202{
203 struct ncsi_channel *nc, *tmp;
204 int index;
205 unsigned long flags;
206
207 nc = kzalloc(sizeof(*nc), GFP_ATOMIC);
208 if (!nc)
209 return NULL;
210
211 nc->id = id;
212 nc->package = np;
213 nc->state = NCSI_CHANNEL_INACTIVE;
214 nc->monitor.enabled = false;
215 timer_setup(&nc->monitor.timer, ncsi_channel_monitor, 0);
216 spin_lock_init(&nc->lock);
217 INIT_LIST_HEAD(&nc->link);
218 for (index = 0; index < NCSI_CAP_MAX; index++)
219 nc->caps[index].index = index;
220 for (index = 0; index < NCSI_MODE_MAX; index++)
221 nc->modes[index].index = index;
222
223 spin_lock_irqsave(&np->lock, flags);
224 tmp = ncsi_find_channel(np, id);
225 if (tmp) {
226 spin_unlock_irqrestore(&np->lock, flags);
227 kfree(nc);
228 return tmp;
229 }
230
231 list_add_tail_rcu(&nc->node, &np->channels);
232 np->channel_num++;
233 spin_unlock_irqrestore(&np->lock, flags);
234
235 return nc;
236}
237
238static void ncsi_remove_channel(struct ncsi_channel *nc)
239{
240 struct ncsi_package *np = nc->package;
241 unsigned long flags;
242
243 spin_lock_irqsave(&nc->lock, flags);
244
245
246 kfree(nc->mac_filter.addrs);
247 kfree(nc->vlan_filter.vids);
248
249 nc->state = NCSI_CHANNEL_INACTIVE;
250 spin_unlock_irqrestore(&nc->lock, flags);
251 ncsi_stop_channel_monitor(nc);
252
253
254 spin_lock_irqsave(&np->lock, flags);
255 list_del_rcu(&nc->node);
256 np->channel_num--;
257 spin_unlock_irqrestore(&np->lock, flags);
258
259 kfree(nc);
260}
261
262struct ncsi_package *ncsi_find_package(struct ncsi_dev_priv *ndp,
263 unsigned char id)
264{
265 struct ncsi_package *np;
266
267 NCSI_FOR_EACH_PACKAGE(ndp, np) {
268 if (np->id == id)
269 return np;
270 }
271
272 return NULL;
273}
274
275struct ncsi_package *ncsi_add_package(struct ncsi_dev_priv *ndp,
276 unsigned char id)
277{
278 struct ncsi_package *np, *tmp;
279 unsigned long flags;
280
281 np = kzalloc(sizeof(*np), GFP_ATOMIC);
282 if (!np)
283 return NULL;
284
285 np->id = id;
286 np->ndp = ndp;
287 spin_lock_init(&np->lock);
288 INIT_LIST_HEAD(&np->channels);
289 np->channel_whitelist = UINT_MAX;
290
291 spin_lock_irqsave(&ndp->lock, flags);
292 tmp = ncsi_find_package(ndp, id);
293 if (tmp) {
294 spin_unlock_irqrestore(&ndp->lock, flags);
295 kfree(np);
296 return tmp;
297 }
298
299 list_add_tail_rcu(&np->node, &ndp->packages);
300 ndp->package_num++;
301 spin_unlock_irqrestore(&ndp->lock, flags);
302
303 return np;
304}
305
306void ncsi_remove_package(struct ncsi_package *np)
307{
308 struct ncsi_dev_priv *ndp = np->ndp;
309 struct ncsi_channel *nc, *tmp;
310 unsigned long flags;
311
312
313 list_for_each_entry_safe(nc, tmp, &np->channels, node)
314 ncsi_remove_channel(nc);
315
316
317 spin_lock_irqsave(&ndp->lock, flags);
318 list_del_rcu(&np->node);
319 ndp->package_num--;
320 spin_unlock_irqrestore(&ndp->lock, flags);
321
322 kfree(np);
323}
324
325void ncsi_find_package_and_channel(struct ncsi_dev_priv *ndp,
326 unsigned char id,
327 struct ncsi_package **np,
328 struct ncsi_channel **nc)
329{
330 struct ncsi_package *p;
331 struct ncsi_channel *c;
332
333 p = ncsi_find_package(ndp, NCSI_PACKAGE_INDEX(id));
334 c = p ? ncsi_find_channel(p, NCSI_CHANNEL_INDEX(id)) : NULL;
335
336 if (np)
337 *np = p;
338 if (nc)
339 *nc = c;
340}
341
342
343
344
345
346struct ncsi_request *ncsi_alloc_request(struct ncsi_dev_priv *ndp,
347 unsigned int req_flags)
348{
349 struct ncsi_request *nr = NULL;
350 int i, limit = ARRAY_SIZE(ndp->requests);
351 unsigned long flags;
352
353
354 spin_lock_irqsave(&ndp->lock, flags);
355 for (i = ndp->request_id; i < limit; i++) {
356 if (ndp->requests[i].used)
357 continue;
358
359 nr = &ndp->requests[i];
360 nr->used = true;
361 nr->flags = req_flags;
362 ndp->request_id = i + 1;
363 goto found;
364 }
365
366
367 for (i = NCSI_REQ_START_IDX; i < ndp->request_id; i++) {
368 if (ndp->requests[i].used)
369 continue;
370
371 nr = &ndp->requests[i];
372 nr->used = true;
373 nr->flags = req_flags;
374 ndp->request_id = i + 1;
375 goto found;
376 }
377
378found:
379 spin_unlock_irqrestore(&ndp->lock, flags);
380 return nr;
381}
382
383void ncsi_free_request(struct ncsi_request *nr)
384{
385 struct ncsi_dev_priv *ndp = nr->ndp;
386 struct sk_buff *cmd, *rsp;
387 unsigned long flags;
388 bool driven;
389
390 if (nr->enabled) {
391 nr->enabled = false;
392 del_timer_sync(&nr->timer);
393 }
394
395 spin_lock_irqsave(&ndp->lock, flags);
396 cmd = nr->cmd;
397 rsp = nr->rsp;
398 nr->cmd = NULL;
399 nr->rsp = NULL;
400 nr->used = false;
401 driven = !!(nr->flags & NCSI_REQ_FLAG_EVENT_DRIVEN);
402 spin_unlock_irqrestore(&ndp->lock, flags);
403
404 if (driven && cmd && --ndp->pending_req_num == 0)
405 schedule_work(&ndp->work);
406
407
408 consume_skb(cmd);
409 consume_skb(rsp);
410}
411
412struct ncsi_dev *ncsi_find_dev(struct net_device *dev)
413{
414 struct ncsi_dev_priv *ndp;
415
416 NCSI_FOR_EACH_DEV(ndp) {
417 if (ndp->ndev.dev == dev)
418 return &ndp->ndev;
419 }
420
421 return NULL;
422}
423
424static void ncsi_request_timeout(struct timer_list *t)
425{
426 struct ncsi_request *nr = from_timer(nr, t, timer);
427 struct ncsi_dev_priv *ndp = nr->ndp;
428 struct ncsi_cmd_pkt *cmd;
429 struct ncsi_package *np;
430 struct ncsi_channel *nc;
431 unsigned long flags;
432
433
434
435
436 spin_lock_irqsave(&ndp->lock, flags);
437 nr->enabled = false;
438 if (nr->rsp || !nr->cmd) {
439 spin_unlock_irqrestore(&ndp->lock, flags);
440 return;
441 }
442 spin_unlock_irqrestore(&ndp->lock, flags);
443
444 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) {
445 if (nr->cmd) {
446
447 cmd = (struct ncsi_cmd_pkt *)
448 skb_network_header(nr->cmd);
449 ncsi_find_package_and_channel(ndp,
450 cmd->cmd.common.channel,
451 &np, &nc);
452 ncsi_send_netlink_timeout(nr, np, nc);
453 }
454 }
455
456
457 ncsi_free_request(nr);
458}
459
460static void ncsi_suspend_channel(struct ncsi_dev_priv *ndp)
461{
462 struct ncsi_dev *nd = &ndp->ndev;
463 struct ncsi_package *np;
464 struct ncsi_channel *nc, *tmp;
465 struct ncsi_cmd_arg nca;
466 unsigned long flags;
467 int ret;
468
469 np = ndp->active_package;
470 nc = ndp->active_channel;
471 nca.ndp = ndp;
472 nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
473 switch (nd->state) {
474 case ncsi_dev_state_suspend:
475 nd->state = ncsi_dev_state_suspend_select;
476
477 case ncsi_dev_state_suspend_select:
478 ndp->pending_req_num = 1;
479
480 nca.type = NCSI_PKT_CMD_SP;
481 nca.package = np->id;
482 nca.channel = NCSI_RESERVED_CHANNEL;
483 if (ndp->flags & NCSI_DEV_HWA)
484 nca.bytes[0] = 0;
485 else
486 nca.bytes[0] = 1;
487
488
489
490
491
492
493
494
495
496 if (ndp->flags & NCSI_DEV_RESHUFFLE)
497 nd->state = ncsi_dev_state_suspend_gls;
498 else
499 nd->state = ncsi_dev_state_suspend_dcnt;
500 ret = ncsi_xmit_cmd(&nca);
501 if (ret)
502 goto error;
503
504 break;
505 case ncsi_dev_state_suspend_gls:
506 ndp->pending_req_num = np->channel_num;
507
508 nca.type = NCSI_PKT_CMD_GLS;
509 nca.package = np->id;
510
511 nd->state = ncsi_dev_state_suspend_dcnt;
512 NCSI_FOR_EACH_CHANNEL(np, nc) {
513 nca.channel = nc->id;
514 ret = ncsi_xmit_cmd(&nca);
515 if (ret)
516 goto error;
517 }
518
519 break;
520 case ncsi_dev_state_suspend_dcnt:
521 ndp->pending_req_num = 1;
522
523 nca.type = NCSI_PKT_CMD_DCNT;
524 nca.package = np->id;
525 nca.channel = nc->id;
526
527 nd->state = ncsi_dev_state_suspend_dc;
528 ret = ncsi_xmit_cmd(&nca);
529 if (ret)
530 goto error;
531
532 break;
533 case ncsi_dev_state_suspend_dc:
534 ndp->pending_req_num = 1;
535
536 nca.type = NCSI_PKT_CMD_DC;
537 nca.package = np->id;
538 nca.channel = nc->id;
539 nca.bytes[0] = 1;
540
541 nd->state = ncsi_dev_state_suspend_deselect;
542 ret = ncsi_xmit_cmd(&nca);
543 if (ret)
544 goto error;
545
546 NCSI_FOR_EACH_CHANNEL(np, tmp) {
547
548
549
550 if (tmp != nc && tmp->state == NCSI_CHANNEL_ACTIVE) {
551 nd->state = ncsi_dev_state_suspend_done;
552 break;
553 }
554 }
555 break;
556 case ncsi_dev_state_suspend_deselect:
557 ndp->pending_req_num = 1;
558
559 nca.type = NCSI_PKT_CMD_DP;
560 nca.package = np->id;
561 nca.channel = NCSI_RESERVED_CHANNEL;
562
563 nd->state = ncsi_dev_state_suspend_done;
564 ret = ncsi_xmit_cmd(&nca);
565 if (ret)
566 goto error;
567
568 break;
569 case ncsi_dev_state_suspend_done:
570 spin_lock_irqsave(&nc->lock, flags);
571 nc->state = NCSI_CHANNEL_INACTIVE;
572 spin_unlock_irqrestore(&nc->lock, flags);
573 if (ndp->flags & NCSI_DEV_RESET)
574 ncsi_reset_dev(nd);
575 else
576 ncsi_process_next_channel(ndp);
577 break;
578 default:
579 netdev_warn(nd->dev, "Wrong NCSI state 0x%x in suspend\n",
580 nd->state);
581 }
582
583 return;
584error:
585 nd->state = ncsi_dev_state_functional;
586}
587
588
589
590
591static int clear_one_vid(struct ncsi_dev_priv *ndp, struct ncsi_channel *nc,
592 struct ncsi_cmd_arg *nca)
593{
594 struct ncsi_channel_vlan_filter *ncf;
595 unsigned long flags;
596 void *bitmap;
597 int index;
598 u16 vid;
599
600 ncf = &nc->vlan_filter;
601 bitmap = &ncf->bitmap;
602
603 spin_lock_irqsave(&nc->lock, flags);
604 index = find_next_bit(bitmap, ncf->n_vids, 0);
605 if (index >= ncf->n_vids) {
606 spin_unlock_irqrestore(&nc->lock, flags);
607 return -1;
608 }
609 vid = ncf->vids[index];
610
611 clear_bit(index, bitmap);
612 ncf->vids[index] = 0;
613 spin_unlock_irqrestore(&nc->lock, flags);
614
615 nca->type = NCSI_PKT_CMD_SVF;
616 nca->words[1] = vid;
617
618 nca->bytes[6] = index + 1;
619 nca->bytes[7] = 0x00;
620 return 0;
621}
622
623
624
625
626static int set_one_vid(struct ncsi_dev_priv *ndp, struct ncsi_channel *nc,
627 struct ncsi_cmd_arg *nca)
628{
629 struct ncsi_channel_vlan_filter *ncf;
630 struct vlan_vid *vlan = NULL;
631 unsigned long flags;
632 int i, index;
633 void *bitmap;
634 u16 vid;
635
636 if (list_empty(&ndp->vlan_vids))
637 return -1;
638
639 ncf = &nc->vlan_filter;
640 bitmap = &ncf->bitmap;
641
642 spin_lock_irqsave(&nc->lock, flags);
643
644 rcu_read_lock();
645 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
646 vid = vlan->vid;
647 for (i = 0; i < ncf->n_vids; i++)
648 if (ncf->vids[i] == vid) {
649 vid = 0;
650 break;
651 }
652 if (vid)
653 break;
654 }
655 rcu_read_unlock();
656
657 if (!vid) {
658
659 spin_unlock_irqrestore(&nc->lock, flags);
660 return -1;
661 }
662
663 index = find_next_zero_bit(bitmap, ncf->n_vids, 0);
664 if (index < 0 || index >= ncf->n_vids) {
665 netdev_err(ndp->ndev.dev,
666 "Channel %u already has all VLAN filters set\n",
667 nc->id);
668 spin_unlock_irqrestore(&nc->lock, flags);
669 return -1;
670 }
671
672 ncf->vids[index] = vid;
673 set_bit(index, bitmap);
674 spin_unlock_irqrestore(&nc->lock, flags);
675
676 nca->type = NCSI_PKT_CMD_SVF;
677 nca->words[1] = vid;
678
679 nca->bytes[6] = index + 1;
680 nca->bytes[7] = 0x01;
681
682 return 0;
683}
684
685#if IS_ENABLED(CONFIG_NCSI_OEM_CMD_GET_MAC)
686
687
688static int ncsi_oem_gma_handler_bcm(struct ncsi_cmd_arg *nca)
689{
690 unsigned char data[NCSI_OEM_BCM_CMD_GMA_LEN];
691 int ret = 0;
692
693 nca->payload = NCSI_OEM_BCM_CMD_GMA_LEN;
694
695 memset(data, 0, NCSI_OEM_BCM_CMD_GMA_LEN);
696 *(unsigned int *)data = ntohl(NCSI_OEM_MFR_BCM_ID);
697 data[5] = NCSI_OEM_BCM_CMD_GMA;
698
699 nca->data = data;
700
701 ret = ncsi_xmit_cmd(nca);
702 if (ret)
703 netdev_err(nca->ndp->ndev.dev,
704 "NCSI: Failed to transmit cmd 0x%x during configure\n",
705 nca->type);
706 return ret;
707}
708
709static int ncsi_oem_gma_handler_mlx(struct ncsi_cmd_arg *nca)
710{
711 union {
712 u8 data_u8[NCSI_OEM_MLX_CMD_GMA_LEN];
713 u32 data_u32[NCSI_OEM_MLX_CMD_GMA_LEN / sizeof(u32)];
714 } u;
715 int ret = 0;
716
717 nca->payload = NCSI_OEM_MLX_CMD_GMA_LEN;
718
719 memset(&u, 0, sizeof(u));
720 u.data_u32[0] = ntohl(NCSI_OEM_MFR_MLX_ID);
721 u.data_u8[5] = NCSI_OEM_MLX_CMD_GMA;
722 u.data_u8[6] = NCSI_OEM_MLX_CMD_GMA_PARAM;
723
724 nca->data = u.data_u8;
725
726 ret = ncsi_xmit_cmd(nca);
727 if (ret)
728 netdev_err(nca->ndp->ndev.dev,
729 "NCSI: Failed to transmit cmd 0x%x during configure\n",
730 nca->type);
731 return ret;
732}
733
734
735static struct ncsi_oem_gma_handler {
736 unsigned int mfr_id;
737 int (*handler)(struct ncsi_cmd_arg *nca);
738} ncsi_oem_gma_handlers[] = {
739 { NCSI_OEM_MFR_BCM_ID, ncsi_oem_gma_handler_bcm },
740 { NCSI_OEM_MFR_MLX_ID, ncsi_oem_gma_handler_mlx }
741};
742
743static int ncsi_gma_handler(struct ncsi_cmd_arg *nca, unsigned int mf_id)
744{
745 struct ncsi_oem_gma_handler *nch = NULL;
746 int i;
747
748
749 if (nca->ndp->gma_flag == 1)
750 return -1;
751
752
753 for (i = 0; i < ARRAY_SIZE(ncsi_oem_gma_handlers); i++) {
754 if (ncsi_oem_gma_handlers[i].mfr_id == mf_id) {
755 if (ncsi_oem_gma_handlers[i].handler)
756 nch = &ncsi_oem_gma_handlers[i];
757 break;
758 }
759 }
760
761 if (!nch) {
762 netdev_err(nca->ndp->ndev.dev,
763 "NCSI: No GMA handler available for MFR-ID (0x%x)\n",
764 mf_id);
765 return -1;
766 }
767
768
769 nca->ndp->gma_flag = 1;
770
771
772 return nch->handler(nca);
773}
774
775#endif
776
777
778static bool ncsi_channel_is_tx(struct ncsi_dev_priv *ndp,
779 struct ncsi_channel *nc)
780{
781 struct ncsi_channel_mode *ncm;
782 struct ncsi_channel *channel;
783 struct ncsi_package *np;
784
785
786
787
788 NCSI_FOR_EACH_PACKAGE(ndp, np) {
789 if (!ndp->multi_package && np != nc->package)
790 continue;
791 NCSI_FOR_EACH_CHANNEL(np, channel) {
792 ncm = &channel->modes[NCSI_MODE_TX_ENABLE];
793 if (ncm->enable)
794 return false;
795 }
796 }
797
798
799 list_for_each_entry_rcu(channel, &ndp->channel_queue, link) {
800 np = channel->package;
801 if (np->preferred_channel &&
802 ncsi_channel_has_link(np->preferred_channel)) {
803 return np->preferred_channel == nc;
804 }
805 }
806
807
808 if (ncsi_channel_has_link(nc))
809 return true;
810
811 list_for_each_entry_rcu(channel, &ndp->channel_queue, link)
812 if (ncsi_channel_has_link(channel))
813 return false;
814
815
816 return true;
817}
818
819
820int ncsi_update_tx_channel(struct ncsi_dev_priv *ndp,
821 struct ncsi_package *package,
822 struct ncsi_channel *disable,
823 struct ncsi_channel *enable)
824{
825 struct ncsi_cmd_arg nca;
826 struct ncsi_channel *nc;
827 struct ncsi_package *np;
828 int ret = 0;
829
830 if (!package->multi_channel && !ndp->multi_package)
831 netdev_warn(ndp->ndev.dev,
832 "NCSI: Trying to update Tx channel in single-channel mode\n");
833 nca.ndp = ndp;
834 nca.req_flags = 0;
835
836
837 NCSI_FOR_EACH_PACKAGE(ndp, np) {
838 if (disable)
839 break;
840 if (!ndp->multi_package && np != package)
841 continue;
842
843 NCSI_FOR_EACH_CHANNEL(np, nc)
844 if (nc->modes[NCSI_MODE_TX_ENABLE].enable) {
845 disable = nc;
846 break;
847 }
848 }
849
850
851 NCSI_FOR_EACH_PACKAGE(ndp, np) {
852 if (enable)
853 break;
854 if (!ndp->multi_package && np != package)
855 continue;
856 if (!(ndp->package_whitelist & (0x1 << np->id)))
857 continue;
858
859 if (np->preferred_channel &&
860 ncsi_channel_has_link(np->preferred_channel)) {
861 enable = np->preferred_channel;
862 break;
863 }
864
865 NCSI_FOR_EACH_CHANNEL(np, nc) {
866 if (!(np->channel_whitelist & 0x1 << nc->id))
867 continue;
868 if (nc->state != NCSI_CHANNEL_ACTIVE)
869 continue;
870 if (ncsi_channel_has_link(nc)) {
871 enable = nc;
872 break;
873 }
874 }
875 }
876
877 if (disable == enable)
878 return -1;
879
880 if (!enable)
881 return -1;
882
883 if (disable) {
884 nca.channel = disable->id;
885 nca.package = disable->package->id;
886 nca.type = NCSI_PKT_CMD_DCNT;
887 ret = ncsi_xmit_cmd(&nca);
888 if (ret)
889 netdev_err(ndp->ndev.dev,
890 "Error %d sending DCNT\n",
891 ret);
892 }
893
894 netdev_info(ndp->ndev.dev, "NCSI: channel %u enables Tx\n", enable->id);
895
896 nca.channel = enable->id;
897 nca.package = enable->package->id;
898 nca.type = NCSI_PKT_CMD_ECNT;
899 ret = ncsi_xmit_cmd(&nca);
900 if (ret)
901 netdev_err(ndp->ndev.dev,
902 "Error %d sending ECNT\n",
903 ret);
904
905 return ret;
906}
907
908static void ncsi_configure_channel(struct ncsi_dev_priv *ndp)
909{
910 struct ncsi_package *np = ndp->active_package;
911 struct ncsi_channel *nc = ndp->active_channel;
912 struct ncsi_channel *hot_nc = NULL;
913 struct ncsi_dev *nd = &ndp->ndev;
914 struct net_device *dev = nd->dev;
915 struct ncsi_cmd_arg nca;
916 unsigned char index;
917 unsigned long flags;
918 int ret;
919
920 nca.ndp = ndp;
921 nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
922 switch (nd->state) {
923 case ncsi_dev_state_config:
924 case ncsi_dev_state_config_sp:
925 ndp->pending_req_num = 1;
926
927
928 nca.type = NCSI_PKT_CMD_SP;
929 if (ndp->flags & NCSI_DEV_HWA)
930 nca.bytes[0] = 0;
931 else
932 nca.bytes[0] = 1;
933 nca.package = np->id;
934 nca.channel = NCSI_RESERVED_CHANNEL;
935 ret = ncsi_xmit_cmd(&nca);
936 if (ret) {
937 netdev_err(ndp->ndev.dev,
938 "NCSI: Failed to transmit CMD_SP\n");
939 goto error;
940 }
941
942 nd->state = ncsi_dev_state_config_cis;
943 break;
944 case ncsi_dev_state_config_cis:
945 ndp->pending_req_num = 1;
946
947
948 nca.type = NCSI_PKT_CMD_CIS;
949 nca.package = np->id;
950 nca.channel = nc->id;
951 ret = ncsi_xmit_cmd(&nca);
952 if (ret) {
953 netdev_err(ndp->ndev.dev,
954 "NCSI: Failed to transmit CMD_CIS\n");
955 goto error;
956 }
957
958 nd->state = ncsi_dev_state_config_oem_gma;
959 break;
960 case ncsi_dev_state_config_oem_gma:
961 nd->state = ncsi_dev_state_config_clear_vids;
962 ret = -1;
963
964#if IS_ENABLED(CONFIG_NCSI_OEM_CMD_GET_MAC)
965 nca.type = NCSI_PKT_CMD_OEM;
966 nca.package = np->id;
967 nca.channel = nc->id;
968 ndp->pending_req_num = 1;
969 ret = ncsi_gma_handler(&nca, nc->version.mf_id);
970#endif
971
972 if (ret < 0)
973 schedule_work(&ndp->work);
974
975 break;
976 case ncsi_dev_state_config_clear_vids:
977 case ncsi_dev_state_config_svf:
978 case ncsi_dev_state_config_ev:
979 case ncsi_dev_state_config_sma:
980 case ncsi_dev_state_config_ebf:
981#if IS_ENABLED(CONFIG_IPV6)
982 case ncsi_dev_state_config_egmf:
983#endif
984 case ncsi_dev_state_config_ecnt:
985 case ncsi_dev_state_config_ec:
986 case ncsi_dev_state_config_ae:
987 case ncsi_dev_state_config_gls:
988 ndp->pending_req_num = 1;
989
990 nca.package = np->id;
991 nca.channel = nc->id;
992
993
994 if (nd->state == ncsi_dev_state_config_clear_vids) {
995 ret = clear_one_vid(ndp, nc, &nca);
996 if (ret) {
997 nd->state = ncsi_dev_state_config_svf;
998 schedule_work(&ndp->work);
999 break;
1000 }
1001
1002 nd->state = ncsi_dev_state_config_clear_vids;
1003
1004 } else if (nd->state == ncsi_dev_state_config_svf) {
1005 ret = set_one_vid(ndp, nc, &nca);
1006 if (ret) {
1007 nd->state = ncsi_dev_state_config_ev;
1008 schedule_work(&ndp->work);
1009 break;
1010 }
1011
1012 nd->state = ncsi_dev_state_config_svf;
1013
1014 } else if (nd->state == ncsi_dev_state_config_ev) {
1015 if (list_empty(&ndp->vlan_vids)) {
1016 nca.type = NCSI_PKT_CMD_DV;
1017 } else {
1018 nca.type = NCSI_PKT_CMD_EV;
1019 nca.bytes[3] = NCSI_CAP_VLAN_NO;
1020 }
1021 nd->state = ncsi_dev_state_config_sma;
1022 } else if (nd->state == ncsi_dev_state_config_sma) {
1023
1024
1025
1026
1027 nca.type = NCSI_PKT_CMD_SMA;
1028 for (index = 0; index < 6; index++)
1029 nca.bytes[index] = dev->dev_addr[index];
1030 nca.bytes[6] = 0x1;
1031 nca.bytes[7] = 0x1;
1032 nd->state = ncsi_dev_state_config_ebf;
1033 } else if (nd->state == ncsi_dev_state_config_ebf) {
1034 nca.type = NCSI_PKT_CMD_EBF;
1035 nca.dwords[0] = nc->caps[NCSI_CAP_BC].cap;
1036 if (ncsi_channel_is_tx(ndp, nc))
1037 nd->state = ncsi_dev_state_config_ecnt;
1038 else
1039 nd->state = ncsi_dev_state_config_ec;
1040#if IS_ENABLED(CONFIG_IPV6)
1041 if (ndp->inet6_addr_num > 0 &&
1042 (nc->caps[NCSI_CAP_GENERIC].cap &
1043 NCSI_CAP_GENERIC_MC))
1044 nd->state = ncsi_dev_state_config_egmf;
1045 } else if (nd->state == ncsi_dev_state_config_egmf) {
1046 nca.type = NCSI_PKT_CMD_EGMF;
1047 nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap;
1048 if (ncsi_channel_is_tx(ndp, nc))
1049 nd->state = ncsi_dev_state_config_ecnt;
1050 else
1051 nd->state = ncsi_dev_state_config_ec;
1052#endif
1053 } else if (nd->state == ncsi_dev_state_config_ecnt) {
1054 if (np->preferred_channel &&
1055 nc != np->preferred_channel)
1056 netdev_info(ndp->ndev.dev,
1057 "NCSI: Tx failed over to channel %u\n",
1058 nc->id);
1059 nca.type = NCSI_PKT_CMD_ECNT;
1060 nd->state = ncsi_dev_state_config_ec;
1061 } else if (nd->state == ncsi_dev_state_config_ec) {
1062
1063 nca.type = NCSI_PKT_CMD_EC;
1064 nd->state = ncsi_dev_state_config_ae;
1065 if (!(nc->caps[NCSI_CAP_AEN].cap & NCSI_CAP_AEN_MASK))
1066 nd->state = ncsi_dev_state_config_gls;
1067 } else if (nd->state == ncsi_dev_state_config_ae) {
1068 nca.type = NCSI_PKT_CMD_AE;
1069 nca.bytes[0] = 0;
1070 nca.dwords[1] = nc->caps[NCSI_CAP_AEN].cap;
1071 nd->state = ncsi_dev_state_config_gls;
1072 } else if (nd->state == ncsi_dev_state_config_gls) {
1073 nca.type = NCSI_PKT_CMD_GLS;
1074 nd->state = ncsi_dev_state_config_done;
1075 }
1076
1077 ret = ncsi_xmit_cmd(&nca);
1078 if (ret) {
1079 netdev_err(ndp->ndev.dev,
1080 "NCSI: Failed to transmit CMD %x\n",
1081 nca.type);
1082 goto error;
1083 }
1084 break;
1085 case ncsi_dev_state_config_done:
1086 netdev_dbg(ndp->ndev.dev, "NCSI: channel %u config done\n",
1087 nc->id);
1088 spin_lock_irqsave(&nc->lock, flags);
1089 nc->state = NCSI_CHANNEL_ACTIVE;
1090
1091 if (ndp->flags & NCSI_DEV_RESET) {
1092
1093 nc->reconfigure_needed = false;
1094 spin_unlock_irqrestore(&nc->lock, flags);
1095 ncsi_reset_dev(nd);
1096 break;
1097 }
1098
1099 if (nc->reconfigure_needed) {
1100
1101
1102
1103
1104 nc->reconfigure_needed = false;
1105 nc->state = NCSI_CHANNEL_INACTIVE;
1106 spin_unlock_irqrestore(&nc->lock, flags);
1107
1108 spin_lock_irqsave(&ndp->lock, flags);
1109 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1110 spin_unlock_irqrestore(&ndp->lock, flags);
1111
1112 netdev_dbg(dev, "Dirty NCSI channel state reset\n");
1113 ncsi_process_next_channel(ndp);
1114 break;
1115 }
1116
1117 if (nc->modes[NCSI_MODE_LINK].data[2] & 0x1) {
1118 hot_nc = nc;
1119 } else {
1120 hot_nc = NULL;
1121 netdev_dbg(ndp->ndev.dev,
1122 "NCSI: channel %u link down after config\n",
1123 nc->id);
1124 }
1125 spin_unlock_irqrestore(&nc->lock, flags);
1126
1127
1128 spin_lock_irqsave(&ndp->lock, flags);
1129 ndp->hot_channel = hot_nc;
1130 spin_unlock_irqrestore(&ndp->lock, flags);
1131
1132 ncsi_start_channel_monitor(nc);
1133 ncsi_process_next_channel(ndp);
1134 break;
1135 default:
1136 netdev_alert(dev, "Wrong NCSI state 0x%x in config\n",
1137 nd->state);
1138 }
1139
1140 return;
1141
1142error:
1143 ncsi_report_link(ndp, true);
1144}
1145
1146static int ncsi_choose_active_channel(struct ncsi_dev_priv *ndp)
1147{
1148 struct ncsi_channel *nc, *found, *hot_nc;
1149 struct ncsi_channel_mode *ncm;
1150 unsigned long flags, cflags;
1151 struct ncsi_package *np;
1152 bool with_link;
1153
1154 spin_lock_irqsave(&ndp->lock, flags);
1155 hot_nc = ndp->hot_channel;
1156 spin_unlock_irqrestore(&ndp->lock, flags);
1157
1158
1159
1160
1161
1162
1163 found = NULL;
1164 with_link = false;
1165 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1166 if (!(ndp->package_whitelist & (0x1 << np->id)))
1167 continue;
1168 NCSI_FOR_EACH_CHANNEL(np, nc) {
1169 if (!(np->channel_whitelist & (0x1 << nc->id)))
1170 continue;
1171
1172 spin_lock_irqsave(&nc->lock, cflags);
1173
1174 if (!list_empty(&nc->link) ||
1175 nc->state != NCSI_CHANNEL_INACTIVE) {
1176 spin_unlock_irqrestore(&nc->lock, cflags);
1177 continue;
1178 }
1179
1180 if (!found)
1181 found = nc;
1182
1183 if (nc == hot_nc)
1184 found = nc;
1185
1186 ncm = &nc->modes[NCSI_MODE_LINK];
1187 if (ncm->data[2] & 0x1) {
1188 found = nc;
1189 with_link = true;
1190 }
1191
1192
1193
1194
1195
1196 if (with_link || np->multi_channel) {
1197 spin_lock_irqsave(&ndp->lock, flags);
1198 list_add_tail_rcu(&nc->link,
1199 &ndp->channel_queue);
1200 spin_unlock_irqrestore(&ndp->lock, flags);
1201
1202 netdev_dbg(ndp->ndev.dev,
1203 "NCSI: Channel %u added to queue (link %s)\n",
1204 nc->id,
1205 ncm->data[2] & 0x1 ? "up" : "down");
1206 }
1207
1208 spin_unlock_irqrestore(&nc->lock, cflags);
1209
1210 if (with_link && !np->multi_channel)
1211 break;
1212 }
1213 if (with_link && !ndp->multi_package)
1214 break;
1215 }
1216
1217 if (list_empty(&ndp->channel_queue) && found) {
1218 netdev_info(ndp->ndev.dev,
1219 "NCSI: No channel with link found, configuring channel %u\n",
1220 found->id);
1221 spin_lock_irqsave(&ndp->lock, flags);
1222 list_add_tail_rcu(&found->link, &ndp->channel_queue);
1223 spin_unlock_irqrestore(&ndp->lock, flags);
1224 } else if (!found) {
1225 netdev_warn(ndp->ndev.dev,
1226 "NCSI: No channel found to configure!\n");
1227 ncsi_report_link(ndp, true);
1228 return -ENODEV;
1229 }
1230
1231 return ncsi_process_next_channel(ndp);
1232}
1233
1234static bool ncsi_check_hwa(struct ncsi_dev_priv *ndp)
1235{
1236 struct ncsi_package *np;
1237 struct ncsi_channel *nc;
1238 unsigned int cap;
1239 bool has_channel = false;
1240
1241
1242
1243
1244 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1245 NCSI_FOR_EACH_CHANNEL(np, nc) {
1246 has_channel = true;
1247
1248 cap = nc->caps[NCSI_CAP_GENERIC].cap;
1249 if (!(cap & NCSI_CAP_GENERIC_HWA) ||
1250 (cap & NCSI_CAP_GENERIC_HWA_MASK) !=
1251 NCSI_CAP_GENERIC_HWA_SUPPORT) {
1252 ndp->flags &= ~NCSI_DEV_HWA;
1253 return false;
1254 }
1255 }
1256 }
1257
1258 if (has_channel) {
1259 ndp->flags |= NCSI_DEV_HWA;
1260 return true;
1261 }
1262
1263 ndp->flags &= ~NCSI_DEV_HWA;
1264 return false;
1265}
1266
1267static void ncsi_probe_channel(struct ncsi_dev_priv *ndp)
1268{
1269 struct ncsi_dev *nd = &ndp->ndev;
1270 struct ncsi_package *np;
1271 struct ncsi_channel *nc;
1272 struct ncsi_cmd_arg nca;
1273 unsigned char index;
1274 int ret;
1275
1276 nca.ndp = ndp;
1277 nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
1278 switch (nd->state) {
1279 case ncsi_dev_state_probe:
1280 nd->state = ncsi_dev_state_probe_deselect;
1281
1282 case ncsi_dev_state_probe_deselect:
1283 ndp->pending_req_num = 8;
1284
1285
1286 nca.type = NCSI_PKT_CMD_DP;
1287 nca.channel = NCSI_RESERVED_CHANNEL;
1288 for (index = 0; index < 8; index++) {
1289 nca.package = index;
1290 ret = ncsi_xmit_cmd(&nca);
1291 if (ret)
1292 goto error;
1293 }
1294
1295 nd->state = ncsi_dev_state_probe_package;
1296 break;
1297 case ncsi_dev_state_probe_package:
1298 ndp->pending_req_num = 1;
1299
1300 nca.type = NCSI_PKT_CMD_SP;
1301 nca.bytes[0] = 1;
1302 nca.package = ndp->package_probe_id;
1303 nca.channel = NCSI_RESERVED_CHANNEL;
1304 ret = ncsi_xmit_cmd(&nca);
1305 if (ret)
1306 goto error;
1307 nd->state = ncsi_dev_state_probe_channel;
1308 break;
1309 case ncsi_dev_state_probe_channel:
1310 ndp->active_package = ncsi_find_package(ndp,
1311 ndp->package_probe_id);
1312 if (!ndp->active_package) {
1313
1314 nd->state = ncsi_dev_state_probe_dp;
1315 schedule_work(&ndp->work);
1316 break;
1317 }
1318 nd->state = ncsi_dev_state_probe_cis;
1319 schedule_work(&ndp->work);
1320 break;
1321 case ncsi_dev_state_probe_cis:
1322 ndp->pending_req_num = NCSI_RESERVED_CHANNEL;
1323
1324
1325 nca.type = NCSI_PKT_CMD_CIS;
1326 nca.package = ndp->active_package->id;
1327 for (index = 0; index < NCSI_RESERVED_CHANNEL; index++) {
1328 nca.channel = index;
1329 ret = ncsi_xmit_cmd(&nca);
1330 if (ret)
1331 goto error;
1332 }
1333
1334 nd->state = ncsi_dev_state_probe_gvi;
1335 break;
1336 case ncsi_dev_state_probe_gvi:
1337 case ncsi_dev_state_probe_gc:
1338 case ncsi_dev_state_probe_gls:
1339 np = ndp->active_package;
1340 ndp->pending_req_num = np->channel_num;
1341
1342
1343 if (nd->state == ncsi_dev_state_probe_gvi)
1344 nca.type = NCSI_PKT_CMD_GVI;
1345 else if (nd->state == ncsi_dev_state_probe_gc)
1346 nca.type = NCSI_PKT_CMD_GC;
1347 else
1348 nca.type = NCSI_PKT_CMD_GLS;
1349
1350 nca.package = np->id;
1351 NCSI_FOR_EACH_CHANNEL(np, nc) {
1352 nca.channel = nc->id;
1353 ret = ncsi_xmit_cmd(&nca);
1354 if (ret)
1355 goto error;
1356 }
1357
1358 if (nd->state == ncsi_dev_state_probe_gvi)
1359 nd->state = ncsi_dev_state_probe_gc;
1360 else if (nd->state == ncsi_dev_state_probe_gc)
1361 nd->state = ncsi_dev_state_probe_gls;
1362 else
1363 nd->state = ncsi_dev_state_probe_dp;
1364 break;
1365 case ncsi_dev_state_probe_dp:
1366 ndp->pending_req_num = 1;
1367
1368
1369 nca.type = NCSI_PKT_CMD_DP;
1370 nca.package = ndp->package_probe_id;
1371 nca.channel = NCSI_RESERVED_CHANNEL;
1372 ret = ncsi_xmit_cmd(&nca);
1373 if (ret)
1374 goto error;
1375
1376
1377 ndp->package_probe_id++;
1378 if (ndp->package_probe_id >= 8) {
1379
1380 ndp->flags |= NCSI_DEV_PROBED;
1381 break;
1382 }
1383 nd->state = ncsi_dev_state_probe_package;
1384 ndp->active_package = NULL;
1385 break;
1386 default:
1387 netdev_warn(nd->dev, "Wrong NCSI state 0x%0x in enumeration\n",
1388 nd->state);
1389 }
1390
1391 if (ndp->flags & NCSI_DEV_PROBED) {
1392
1393 ncsi_check_hwa(ndp);
1394 ncsi_choose_active_channel(ndp);
1395 }
1396
1397 return;
1398error:
1399 netdev_err(ndp->ndev.dev,
1400 "NCSI: Failed to transmit cmd 0x%x during probe\n",
1401 nca.type);
1402 ncsi_report_link(ndp, true);
1403}
1404
1405static void ncsi_dev_work(struct work_struct *work)
1406{
1407 struct ncsi_dev_priv *ndp = container_of(work,
1408 struct ncsi_dev_priv, work);
1409 struct ncsi_dev *nd = &ndp->ndev;
1410
1411 switch (nd->state & ncsi_dev_state_major) {
1412 case ncsi_dev_state_probe:
1413 ncsi_probe_channel(ndp);
1414 break;
1415 case ncsi_dev_state_suspend:
1416 ncsi_suspend_channel(ndp);
1417 break;
1418 case ncsi_dev_state_config:
1419 ncsi_configure_channel(ndp);
1420 break;
1421 default:
1422 netdev_warn(nd->dev, "Wrong NCSI state 0x%x in workqueue\n",
1423 nd->state);
1424 }
1425}
1426
1427int ncsi_process_next_channel(struct ncsi_dev_priv *ndp)
1428{
1429 struct ncsi_channel *nc;
1430 int old_state;
1431 unsigned long flags;
1432
1433 spin_lock_irqsave(&ndp->lock, flags);
1434 nc = list_first_or_null_rcu(&ndp->channel_queue,
1435 struct ncsi_channel, link);
1436 if (!nc) {
1437 spin_unlock_irqrestore(&ndp->lock, flags);
1438 goto out;
1439 }
1440
1441 list_del_init(&nc->link);
1442 spin_unlock_irqrestore(&ndp->lock, flags);
1443
1444 spin_lock_irqsave(&nc->lock, flags);
1445 old_state = nc->state;
1446 nc->state = NCSI_CHANNEL_INVISIBLE;
1447 spin_unlock_irqrestore(&nc->lock, flags);
1448
1449 ndp->active_channel = nc;
1450 ndp->active_package = nc->package;
1451
1452 switch (old_state) {
1453 case NCSI_CHANNEL_INACTIVE:
1454 ndp->ndev.state = ncsi_dev_state_config;
1455 netdev_dbg(ndp->ndev.dev, "NCSI: configuring channel %u\n",
1456 nc->id);
1457 ncsi_configure_channel(ndp);
1458 break;
1459 case NCSI_CHANNEL_ACTIVE:
1460 ndp->ndev.state = ncsi_dev_state_suspend;
1461 netdev_dbg(ndp->ndev.dev, "NCSI: suspending channel %u\n",
1462 nc->id);
1463 ncsi_suspend_channel(ndp);
1464 break;
1465 default:
1466 netdev_err(ndp->ndev.dev, "Invalid state 0x%x on %d:%d\n",
1467 old_state, nc->package->id, nc->id);
1468 ncsi_report_link(ndp, false);
1469 return -EINVAL;
1470 }
1471
1472 return 0;
1473
1474out:
1475 ndp->active_channel = NULL;
1476 ndp->active_package = NULL;
1477 if (ndp->flags & NCSI_DEV_RESHUFFLE) {
1478 ndp->flags &= ~NCSI_DEV_RESHUFFLE;
1479 return ncsi_choose_active_channel(ndp);
1480 }
1481
1482 ncsi_report_link(ndp, false);
1483 return -ENODEV;
1484}
1485
1486#if IS_ENABLED(CONFIG_IPV6)
1487static int ncsi_inet6addr_event(struct notifier_block *this,
1488 unsigned long event, void *data)
1489{
1490 struct inet6_ifaddr *ifa = data;
1491 struct net_device *dev = ifa->idev->dev;
1492 struct ncsi_dev *nd = ncsi_find_dev(dev);
1493 struct ncsi_dev_priv *ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
1494 struct ncsi_package *np;
1495 struct ncsi_channel *nc;
1496 struct ncsi_cmd_arg nca;
1497 bool action;
1498 int ret;
1499
1500 if (!ndp || (ipv6_addr_type(&ifa->addr) &
1501 (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK)))
1502 return NOTIFY_OK;
1503
1504 switch (event) {
1505 case NETDEV_UP:
1506 action = (++ndp->inet6_addr_num) == 1;
1507 nca.type = NCSI_PKT_CMD_EGMF;
1508 break;
1509 case NETDEV_DOWN:
1510 action = (--ndp->inet6_addr_num == 0);
1511 nca.type = NCSI_PKT_CMD_DGMF;
1512 break;
1513 default:
1514 return NOTIFY_OK;
1515 }
1516
1517
1518
1519
1520
1521 np = ndp->active_package;
1522 nc = ndp->active_channel;
1523 if (!action || !np || !nc)
1524 return NOTIFY_OK;
1525
1526
1527 if (!(nc->caps[NCSI_CAP_GENERIC].cap & NCSI_CAP_GENERIC_MC))
1528 return NOTIFY_OK;
1529
1530 nca.ndp = ndp;
1531 nca.req_flags = 0;
1532 nca.package = np->id;
1533 nca.channel = nc->id;
1534 nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap;
1535 ret = ncsi_xmit_cmd(&nca);
1536 if (ret) {
1537 netdev_warn(dev, "Fail to %s global multicast filter (%d)\n",
1538 (event == NETDEV_UP) ? "enable" : "disable", ret);
1539 return NOTIFY_DONE;
1540 }
1541
1542 return NOTIFY_OK;
1543}
1544
1545static struct notifier_block ncsi_inet6addr_notifier = {
1546 .notifier_call = ncsi_inet6addr_event,
1547};
1548#endif
1549
1550static int ncsi_kick_channels(struct ncsi_dev_priv *ndp)
1551{
1552 struct ncsi_dev *nd = &ndp->ndev;
1553 struct ncsi_channel *nc;
1554 struct ncsi_package *np;
1555 unsigned long flags;
1556 unsigned int n = 0;
1557
1558 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1559 NCSI_FOR_EACH_CHANNEL(np, nc) {
1560 spin_lock_irqsave(&nc->lock, flags);
1561
1562
1563
1564
1565
1566
1567
1568 if (nc->state != NCSI_CHANNEL_ACTIVE) {
1569 if ((ndp->ndev.state & 0xff00) ==
1570 ncsi_dev_state_config ||
1571 !list_empty(&nc->link)) {
1572 netdev_dbg(nd->dev,
1573 "NCSI: channel %p marked dirty\n",
1574 nc);
1575 nc->reconfigure_needed = true;
1576 }
1577 spin_unlock_irqrestore(&nc->lock, flags);
1578 continue;
1579 }
1580
1581 spin_unlock_irqrestore(&nc->lock, flags);
1582
1583 ncsi_stop_channel_monitor(nc);
1584 spin_lock_irqsave(&nc->lock, flags);
1585 nc->state = NCSI_CHANNEL_INACTIVE;
1586 spin_unlock_irqrestore(&nc->lock, flags);
1587
1588 spin_lock_irqsave(&ndp->lock, flags);
1589 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1590 spin_unlock_irqrestore(&ndp->lock, flags);
1591
1592 netdev_dbg(nd->dev, "NCSI: kicked channel %p\n", nc);
1593 n++;
1594 }
1595 }
1596
1597 return n;
1598}
1599
1600int ncsi_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
1601{
1602 struct ncsi_dev_priv *ndp;
1603 unsigned int n_vids = 0;
1604 struct vlan_vid *vlan;
1605 struct ncsi_dev *nd;
1606 bool found = false;
1607
1608 if (vid == 0)
1609 return 0;
1610
1611 nd = ncsi_find_dev(dev);
1612 if (!nd) {
1613 netdev_warn(dev, "NCSI: No net_device?\n");
1614 return 0;
1615 }
1616
1617 ndp = TO_NCSI_DEV_PRIV(nd);
1618
1619
1620 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
1621 n_vids++;
1622 if (vlan->vid == vid) {
1623 netdev_dbg(dev, "NCSI: vid %u already registered\n",
1624 vid);
1625 return 0;
1626 }
1627 }
1628 if (n_vids >= NCSI_MAX_VLAN_VIDS) {
1629 netdev_warn(dev,
1630 "tried to add vlan id %u but NCSI max already registered (%u)\n",
1631 vid, NCSI_MAX_VLAN_VIDS);
1632 return -ENOSPC;
1633 }
1634
1635 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
1636 if (!vlan)
1637 return -ENOMEM;
1638
1639 vlan->proto = proto;
1640 vlan->vid = vid;
1641 list_add_rcu(&vlan->list, &ndp->vlan_vids);
1642
1643 netdev_dbg(dev, "NCSI: Added new vid %u\n", vid);
1644
1645 found = ncsi_kick_channels(ndp) != 0;
1646
1647 return found ? ncsi_process_next_channel(ndp) : 0;
1648}
1649EXPORT_SYMBOL_GPL(ncsi_vlan_rx_add_vid);
1650
1651int ncsi_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid)
1652{
1653 struct vlan_vid *vlan, *tmp;
1654 struct ncsi_dev_priv *ndp;
1655 struct ncsi_dev *nd;
1656 bool found = false;
1657
1658 if (vid == 0)
1659 return 0;
1660
1661 nd = ncsi_find_dev(dev);
1662 if (!nd) {
1663 netdev_warn(dev, "NCSI: no net_device?\n");
1664 return 0;
1665 }
1666
1667 ndp = TO_NCSI_DEV_PRIV(nd);
1668
1669
1670 list_for_each_entry_safe(vlan, tmp, &ndp->vlan_vids, list)
1671 if (vlan->vid == vid) {
1672 netdev_dbg(dev, "NCSI: vid %u found, removing\n", vid);
1673 list_del_rcu(&vlan->list);
1674 found = true;
1675 kfree(vlan);
1676 }
1677
1678 if (!found) {
1679 netdev_err(dev, "NCSI: vid %u wasn't registered!\n", vid);
1680 return -EINVAL;
1681 }
1682
1683 found = ncsi_kick_channels(ndp) != 0;
1684
1685 return found ? ncsi_process_next_channel(ndp) : 0;
1686}
1687EXPORT_SYMBOL_GPL(ncsi_vlan_rx_kill_vid);
1688
1689struct ncsi_dev *ncsi_register_dev(struct net_device *dev,
1690 void (*handler)(struct ncsi_dev *ndev))
1691{
1692 struct ncsi_dev_priv *ndp;
1693 struct ncsi_dev *nd;
1694 unsigned long flags;
1695 int i;
1696
1697
1698 nd = ncsi_find_dev(dev);
1699 if (nd)
1700 return nd;
1701
1702
1703 ndp = kzalloc(sizeof(*ndp), GFP_ATOMIC);
1704 if (!ndp)
1705 return NULL;
1706
1707 nd = &ndp->ndev;
1708 nd->state = ncsi_dev_state_registered;
1709 nd->dev = dev;
1710 nd->handler = handler;
1711 ndp->pending_req_num = 0;
1712 INIT_LIST_HEAD(&ndp->channel_queue);
1713 INIT_LIST_HEAD(&ndp->vlan_vids);
1714 INIT_WORK(&ndp->work, ncsi_dev_work);
1715 ndp->package_whitelist = UINT_MAX;
1716
1717
1718 spin_lock_init(&ndp->lock);
1719 INIT_LIST_HEAD(&ndp->packages);
1720 ndp->request_id = NCSI_REQ_START_IDX;
1721 for (i = 0; i < ARRAY_SIZE(ndp->requests); i++) {
1722 ndp->requests[i].id = i;
1723 ndp->requests[i].ndp = ndp;
1724 timer_setup(&ndp->requests[i].timer, ncsi_request_timeout, 0);
1725 }
1726
1727 spin_lock_irqsave(&ncsi_dev_lock, flags);
1728#if IS_ENABLED(CONFIG_IPV6)
1729 ndp->inet6_addr_num = 0;
1730 if (list_empty(&ncsi_dev_list))
1731 register_inet6addr_notifier(&ncsi_inet6addr_notifier);
1732#endif
1733 list_add_tail_rcu(&ndp->node, &ncsi_dev_list);
1734 spin_unlock_irqrestore(&ncsi_dev_lock, flags);
1735
1736
1737 ndp->ptype.type = cpu_to_be16(ETH_P_NCSI);
1738 ndp->ptype.func = ncsi_rcv_rsp;
1739 ndp->ptype.dev = dev;
1740 dev_add_pack(&ndp->ptype);
1741
1742
1743 ncsi_init_netlink(dev);
1744
1745 return nd;
1746}
1747EXPORT_SYMBOL_GPL(ncsi_register_dev);
1748
1749int ncsi_start_dev(struct ncsi_dev *nd)
1750{
1751 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1752
1753 if (nd->state != ncsi_dev_state_registered &&
1754 nd->state != ncsi_dev_state_functional)
1755 return -ENOTTY;
1756
1757 if (!(ndp->flags & NCSI_DEV_PROBED)) {
1758 ndp->package_probe_id = 0;
1759 nd->state = ncsi_dev_state_probe;
1760 schedule_work(&ndp->work);
1761 return 0;
1762 }
1763
1764 return ncsi_reset_dev(nd);
1765}
1766EXPORT_SYMBOL_GPL(ncsi_start_dev);
1767
1768void ncsi_stop_dev(struct ncsi_dev *nd)
1769{
1770 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1771 struct ncsi_package *np;
1772 struct ncsi_channel *nc;
1773 bool chained;
1774 int old_state;
1775 unsigned long flags;
1776
1777
1778
1779
1780
1781 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1782 NCSI_FOR_EACH_CHANNEL(np, nc) {
1783 ncsi_stop_channel_monitor(nc);
1784
1785 spin_lock_irqsave(&nc->lock, flags);
1786 chained = !list_empty(&nc->link);
1787 old_state = nc->state;
1788 spin_unlock_irqrestore(&nc->lock, flags);
1789
1790 WARN_ON_ONCE(chained ||
1791 old_state == NCSI_CHANNEL_INVISIBLE);
1792 }
1793 }
1794
1795 netdev_dbg(ndp->ndev.dev, "NCSI: Stopping device\n");
1796 ncsi_report_link(ndp, true);
1797}
1798EXPORT_SYMBOL_GPL(ncsi_stop_dev);
1799
1800int ncsi_reset_dev(struct ncsi_dev *nd)
1801{
1802 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1803 struct ncsi_channel *nc, *active, *tmp;
1804 struct ncsi_package *np;
1805 unsigned long flags;
1806
1807 spin_lock_irqsave(&ndp->lock, flags);
1808
1809 if (!(ndp->flags & NCSI_DEV_RESET)) {
1810
1811 switch (nd->state & ncsi_dev_state_major) {
1812 case ncsi_dev_state_registered:
1813 case ncsi_dev_state_probe:
1814
1815 spin_unlock_irqrestore(&ndp->lock, flags);
1816 return 0;
1817 case ncsi_dev_state_suspend:
1818 case ncsi_dev_state_config:
1819
1820
1821
1822
1823 ndp->flags |= NCSI_DEV_RESET;
1824 spin_unlock_irqrestore(&ndp->lock, flags);
1825 return 0;
1826 }
1827 } else {
1828 switch (nd->state) {
1829 case ncsi_dev_state_suspend_done:
1830 case ncsi_dev_state_config_done:
1831 case ncsi_dev_state_functional:
1832
1833 break;
1834 default:
1835
1836 spin_unlock_irqrestore(&ndp->lock, flags);
1837 return 0;
1838 }
1839 }
1840
1841 if (!list_empty(&ndp->channel_queue)) {
1842
1843 list_for_each_entry_safe(nc, tmp, &ndp->channel_queue, link)
1844 list_del_init(&nc->link);
1845 }
1846 spin_unlock_irqrestore(&ndp->lock, flags);
1847
1848 active = NULL;
1849 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1850 NCSI_FOR_EACH_CHANNEL(np, nc) {
1851 spin_lock_irqsave(&nc->lock, flags);
1852
1853 if (nc->state == NCSI_CHANNEL_ACTIVE) {
1854 active = nc;
1855 nc->state = NCSI_CHANNEL_INVISIBLE;
1856 spin_unlock_irqrestore(&nc->lock, flags);
1857 ncsi_stop_channel_monitor(nc);
1858 break;
1859 }
1860
1861 spin_unlock_irqrestore(&nc->lock, flags);
1862 }
1863 if (active)
1864 break;
1865 }
1866
1867 if (!active) {
1868
1869 spin_lock_irqsave(&ndp->lock, flags);
1870 ndp->flags &= ~NCSI_DEV_RESET;
1871 spin_unlock_irqrestore(&ndp->lock, flags);
1872 return ncsi_choose_active_channel(ndp);
1873 }
1874
1875 spin_lock_irqsave(&ndp->lock, flags);
1876 ndp->flags |= NCSI_DEV_RESET;
1877 ndp->active_channel = active;
1878 ndp->active_package = active->package;
1879 spin_unlock_irqrestore(&ndp->lock, flags);
1880
1881 nd->state = ncsi_dev_state_suspend;
1882 schedule_work(&ndp->work);
1883 return 0;
1884}
1885
1886void ncsi_unregister_dev(struct ncsi_dev *nd)
1887{
1888 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1889 struct ncsi_package *np, *tmp;
1890 unsigned long flags;
1891
1892 dev_remove_pack(&ndp->ptype);
1893
1894 list_for_each_entry_safe(np, tmp, &ndp->packages, node)
1895 ncsi_remove_package(np);
1896
1897 spin_lock_irqsave(&ncsi_dev_lock, flags);
1898 list_del_rcu(&ndp->node);
1899#if IS_ENABLED(CONFIG_IPV6)
1900 if (list_empty(&ncsi_dev_list))
1901 unregister_inet6addr_notifier(&ncsi_inet6addr_notifier);
1902#endif
1903 spin_unlock_irqrestore(&ncsi_dev_lock, flags);
1904
1905 ncsi_unregister_netlink(nd->dev);
1906
1907 kfree(ndp);
1908}
1909EXPORT_SYMBOL_GPL(ncsi_unregister_dev);
1910
