?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vfio/type1: untag user pointers in vaddr_get_pfn
[linux/fpc-iii.git] / net / ncsi / ncsi-manage.c
blob755aab66dcab75f8a1eada1e29d1545e78fb7199
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright Gavin Shan, IBM Corporation 2016.
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
24 LIST_HEAD(ncsi_dev_list);
25 DEFINE_SPINLOCK(ncsi_dev_lock);
26
27 bool ncsi_channel_has_link(struct ncsi_channel *channel)
28 {
29 return !!(channel->modes[NCSI_MODE_LINK].data[2] & 0x1);
30 }
31
32 bool 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
50 static 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
84 report:
85 nd->handler(nd);
86 }
87
88 static 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
160 void 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
173 void 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
188 struct 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
201 struct 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
238 static 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 /* Release filters */
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 /* Remove and free channel */
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
262 struct 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
275 struct 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
306 void 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 /* Release all child channels */
313 list_for_each_entry_safe(nc, tmp, &np->channels, node)
314 ncsi_remove_channel(nc);
315
316 /* Remove and free package */
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
325 void 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 /* For two consecutive NCSI commands, the packet IDs shouldn't
343 * be same. Otherwise, the bogus response might be replied. So
344 * the available IDs are allocated in round-robin fashion.
345 */
346 struct 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 /* Check if there is one available request until the ceiling */
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 /* Fail back to check from the starting cursor */
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
378 found:
379 spin_unlock_irqrestore(&ndp->lock, flags);
380 return nr;
381 }
382
383 void 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 /* Release command and response */
408 consume_skb(cmd);
409 consume_skb(rsp);
410 }
411
412 struct 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
424 static 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 /* If the request already had associated response,
434 * let the response handler to release it.
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 /* Find the package */
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 /* Release the request */
457 ncsi_free_request(nr);
458 }
459
460 static 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 /* Fall through */
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 /* To retrieve the last link states of channels in current
489 * package when current active channel needs fail over to
490 * another one. It means we will possibly select another
491 * channel as next active one. The link states of channels
492 * are most important factor of the selection. So we need
493 * accurate link states. Unfortunately, the link states on
494 * inactive channels can't be updated with LSC AEN in time.
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 /* If there is another channel active on this package
548 * do not deselect the package.
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;
584 error:
585 nd->state = ncsi_dev_state_functional;
586 }
587
588 /* Check the VLAN filter bitmap for a set filter, and construct a
589 * "Set VLAN Filter - Disable" packet if found.
590 */
591 static 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 /* HW filter index starts at 1 */
618 nca->bytes[6] = index + 1;
619 nca->bytes[7] = 0x00;
620 return 0;
621 }
622
623 /* Find an outstanding VLAN tag and constuct a "Set VLAN Filter - Enable"
624 * packet.
625 */
626 static 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 /* No VLAN ID is not set */
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 /* HW filter index starts at 1 */
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 /* NCSI OEM Command APIs */
688 static 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
709 static 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 /* OEM Command handlers initialization */
735 static 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
743 static 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 /* This function should only be called once, return if flag set */
749 if (nca->ndp->gma_flag == 1)
750 return -1;
751
752 /* Find gma handler for given manufacturer id */
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 /* Set the flag for GMA command which should only be called once */
769 nca->ndp->gma_flag = 1;
770
771 /* Get Mac address from NCSI device */
772 return nch->handler(nca);
773 }
774
775 #endif /* CONFIG_NCSI_OEM_CMD_GET_MAC */
776
777 /* Determine if a given channel from the channel_queue should be used for Tx */
778 static 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 /* Check if any other channel has Tx enabled; a channel may have already
786 * been configured and removed from the channel queue.
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 /* This channel is the preferred channel and has link */
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 /* This channel has link */
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 /* No other channel has link; default to this one */
816 return true;
817 }
818
819 /* Change the active Tx channel in a multi-channel setup */
820 int 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 /* Find current channel with Tx enabled */
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 /* Find a suitable channel for Tx */
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
908 static 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 /* Select the specific package */
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 /* Clear initial state */
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 /* CONFIG_NCSI_OEM_CMD_GET_MAC */
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 /* Clear any active filters on the channel before setting */
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 /* Repeat */
1002 nd->state = ncsi_dev_state_config_clear_vids;
1003 /* Add known VLAN tags to the filter */
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 /* Repeat */
1012 nd->state = ncsi_dev_state_config_svf;
1013 /* Enable/Disable the VLAN filter */
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 /* Use first entry in unicast filter table. Note that
1024 * the MAC filter table starts from entry 1 instead of
1025 * 0.
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 /* CONFIG_IPV6 */
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 /* Enable AEN if it's supported */
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 /* A reset event happened during config, start it now */
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 /* This channel's configuration has been updated
1101 * part-way during the config state - start the
1102 * channel configuration over
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 /* Update the hot channel */
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
1142 error:
1143 ncsi_report_link(ndp, true);
1144 }
1145
1146 static 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 /* By default the search is done once an inactive channel with up
1159 * link is found, unless a preferred channel is set.
1160 * If multi_package or multi_channel are configured all channels in the
1161 * whitelist are added to the channel queue.
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 /* If multi_channel is enabled configure all valid
1193 * channels whether or not they currently have link
1194 * so they will have AENs enabled.
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
1234 static 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 /* The hardware arbitration is disabled if any one channel
1242 * doesn't support explicitly.
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
1267 static 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 /* Fall through */
1282 case ncsi_dev_state_probe_deselect:
1283 ndp->pending_req_num = 8;
1284
1285 /* Deselect all possible packages */
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 /* No response */
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 /* Clear initial state */
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 /* Retrieve version, capability or link status */
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 /* Deselect the current package */
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 /* Probe next package */
1377 ndp->package_probe_id++;
1378 if (ndp->package_probe_id >= 8) {
1379 /* Probe finished */
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 /* Check if all packages have HWA support */
1393 ncsi_check_hwa(ndp);
1394 ncsi_choose_active_channel(ndp);
1395 }
1396
1397 return;
1398 error:
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
1405 static 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
1427 int 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
1474 out:
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)
1487 static 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 /* We might not have active channel or packages. The IPv6
1518 * required multicast will be enabled when active channel
1519 * or packages are chosen.
1520 */
1521 np = ndp->active_package;
1522 nc = ndp->active_channel;
1523 if (!action || !np || !nc)
1524 return NOTIFY_OK;
1525
1526 /* We needn't enable or disable it if the function isn't supported */
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
1545 static struct notifier_block ncsi_inet6addr_notifier = {
1546 .notifier_call = ncsi_inet6addr_event,
1547 };
1548 #endif /* CONFIG_IPV6 */
1549
1550 static 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 /* Channels may be busy, mark dirty instead of
1563 * kicking if;
1564 * a) not ACTIVE (configured)
1565 * b) in the channel_queue (to be configured)
1566 * c) it's ndev is in the config state
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
1600 int 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 /* Add the VLAN id to our internal list */
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 }
1649 EXPORT_SYMBOL_GPL(ncsi_vlan_rx_add_vid);
1650
1651 int 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 /* Remove the VLAN id from our internal list */
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 }
1687 EXPORT_SYMBOL_GPL(ncsi_vlan_rx_kill_vid);
1688
1689 struct 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 /* Check if the device has been registered or not */
1698 nd = ncsi_find_dev(dev);
1699 if (nd)
1700 return nd;
1701
1702 /* Create NCSI device */
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 /* Initialize private NCSI device */
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 /* Register NCSI packet Rx handler */
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 /* Set up generic netlink interface */
1743 ncsi_init_netlink(dev);
1744
1745 return nd;
1746 }
1747 EXPORT_SYMBOL_GPL(ncsi_register_dev);
1748
1749 int 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 }
1766 EXPORT_SYMBOL_GPL(ncsi_start_dev);
1767
1768 void 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 /* Stop the channel monitor on any active channels. Don't reset the
1778 * channel state so we know which were active when ncsi_start_dev()
1779 * is next called.
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 }
1798 EXPORT_SYMBOL_GPL(ncsi_stop_dev);
1799
1800 int 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 /* Haven't been called yet, check states */
1811 switch (nd->state & ncsi_dev_state_major) {
1812 case ncsi_dev_state_registered:
1813 case ncsi_dev_state_probe:
1814 /* Not even probed yet - do nothing */
1815 spin_unlock_irqrestore(&ndp->lock, flags);
1816 return 0;
1817 case ncsi_dev_state_suspend:
1818 case ncsi_dev_state_config:
1819 /* Wait for the channel to finish its suspend/config
1820 * operation; once it finishes it will check for
1821 * NCSI_DEV_RESET and reset the state.
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 /* Ok */
1833 break;
1834 default:
1835 /* Current reset operation happening */
1836 spin_unlock_irqrestore(&ndp->lock, flags);
1837 return 0;
1838 }
1839 }
1840
1841 if (!list_empty(&ndp->channel_queue)) {
1842 /* Clear any channel queue we may have interrupted */
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 /* Done */
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
1886 void 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 }
1909 EXPORT_SYMBOL_GPL(ncsi_unregister_dev);
Linux with added FPC-III support