root/net/ncsi/ncsi-manage.c

DEFINITIONS

1. ncsi_channel_has_link
2. ncsi_channel_is_last
3. ncsi_report_link
4. ncsi_channel_monitor
5. ncsi_start_channel_monitor
6. ncsi_stop_channel_monitor
7. ncsi_find_channel
8. ncsi_add_channel
9. ncsi_remove_channel
10. ncsi_find_package
11. ncsi_add_package
12. ncsi_remove_package
13. ncsi_find_package_and_channel
14. ncsi_alloc_request
15. ncsi_free_request
16. ncsi_find_dev
17. ncsi_request_timeout
18. ncsi_suspend_channel
19. clear_one_vid
20. set_one_vid
21. ncsi_oem_gma_handler_bcm
22. ncsi_oem_gma_handler_mlx
23. ncsi_gma_handler
24. ncsi_channel_is_tx
25. ncsi_update_tx_channel
26. ncsi_configure_channel
27. ncsi_choose_active_channel
28. ncsi_check_hwa
29. ncsi_probe_channel
30. ncsi_dev_work
31. ncsi_process_next_channel
32. ncsi_kick_channels
33. ncsi_vlan_rx_add_vid
34. ncsi_vlan_rx_kill_vid
35. ncsi_register_dev
36. ncsi_start_dev
37. ncsi_stop_dev
38. ncsi_reset_dev
39. ncsi_unregister_dev

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