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