net/ncsi/ncsi-manage.c

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