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