net/ncsi/ncsi-manage.c

   1 /*
   2  * Copyright Gavin Shan, IBM Corporation 2016.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/netlink.h>
  16
  17 #include <net/ncsi.h>
  18 #include <net/net_namespace.h>
  19 #include <net/sock.h>
  20 #include <net/addrconf.h>
  21 #include <net/ipv6.h>
  22 #include <net/if_inet6.h>
  23
  24 #include "internal.h"
  25 #include "ncsi-pkt.h"
  26
  27 LIST_HEAD(ncsi_dev_list);
  28 DEFINE_SPINLOCK(ncsi_dev_lock);
  29
  30 static inline int ncsi_filter_size(int table)
  31 {
  32         int sizes[] = { 2, 6, 6, 6 };
  33
  34         BUILD_BUG_ON(ARRAY_SIZE(sizes) != NCSI_FILTER_MAX);
  35         if (table < NCSI_FILTER_BASE || table >= NCSI_FILTER_MAX)
  36                 return -EINVAL;
  37
  38         return sizes[table];
  39 }
  40
  41 int ncsi_find_filter(struct ncsi_channel *nc, int table, void *data)
  42 {
  43         struct ncsi_channel_filter *ncf;
  44         void *bitmap;
  45         int index, size;
  46         unsigned long flags;
  47
  48         ncf = nc->filters[table];
  49         if (!ncf)
  50                 return -ENXIO;
  51
  52         size = ncsi_filter_size(table);
  53         if (size < 0)
  54                 return size;
  55
  56         spin_lock_irqsave(&nc->lock, flags);
  57         bitmap = (void *)&ncf->bitmap;
  58         index = -1;
  59         while ((index = find_next_bit(bitmap, ncf->total, index + 1))
  60                < ncf->total) {
  61                 if (!memcmp(ncf->data + size * index, data, size)) {
  62                         spin_unlock_irqrestore(&nc->lock, flags);
  63                         return index;
  64                 }
  65         }
  66         spin_unlock_irqrestore(&nc->lock, flags);
  67
  68         return -ENOENT;
  69 }
  70
  71 int ncsi_add_filter(struct ncsi_channel *nc, int table, void *data)
  72 {
  73         struct ncsi_channel_filter *ncf;
  74         int index, size;
  75         void *bitmap;
  76         unsigned long flags;
  77
  78         size = ncsi_filter_size(table);
  79         if (size < 0)
  80                 return size;
  81
  82         index = ncsi_find_filter(nc, table, data);
  83         if (index >= 0)
  84                 return index;
  85
  86         ncf = nc->filters[table];
  87         if (!ncf)
  88                 return -ENODEV;
  89
  90         spin_lock_irqsave(&nc->lock, flags);
  91         bitmap = (void *)&ncf->bitmap;
  92         do {
  93                 index = find_next_zero_bit(bitmap, ncf->total, 0);
  94                 if (index >= ncf->total) {
  95                         spin_unlock_irqrestore(&nc->lock, flags);
  96                         return -ENOSPC;
  97                 }
  98         } while (test_and_set_bit(index, bitmap));
  99
 100         memcpy(ncf->data + size * index, data, size);
 101         spin_unlock_irqrestore(&nc->lock, flags);
 102
 103         return index;
 104 }
 105
 106 int ncsi_remove_filter(struct ncsi_channel *nc, int table, int index)
 107 {
 108         struct ncsi_channel_filter *ncf;
 109         int size;
 110         void *bitmap;
 111         unsigned long flags;
 112
 113         size = ncsi_filter_size(table);
 114         if (size < 0)
 115                 return size;
 116
 117         ncf = nc->filters[table];
 118         if (!ncf || index >= ncf->total)
 119                 return -ENODEV;
 120
 121         spin_lock_irqsave(&nc->lock, flags);
 122         bitmap = (void *)&ncf->bitmap;
 123         if (test_and_clear_bit(index, bitmap))
 124                 memset(ncf->data + size * index, 0, size);
 125         spin_unlock_irqrestore(&nc->lock, flags);
 126
 127         return 0;
 128 }
 129
 130 static void ncsi_report_link(struct ncsi_dev_priv *ndp, bool force_down)
 131 {
 132         struct ncsi_dev *nd = &ndp->ndev;
 133         struct ncsi_package *np;
 134         struct ncsi_channel *nc;
 135         unsigned long flags;
 136
 137         nd->state = ncsi_dev_state_functional;
 138         if (force_down) {
 139                 nd->link_up = 0;
 140                 goto report;
 141         }
 142
 143         nd->link_up = 0;
 144         NCSI_FOR_EACH_PACKAGE(ndp, np) {
 145                 NCSI_FOR_EACH_CHANNEL(np, nc) {
 146                         spin_lock_irqsave(&nc->lock, flags);
 147
 148                         if (!list_empty(&nc->link) ||
 149                             nc->state != NCSI_CHANNEL_ACTIVE) {
 150                                 spin_unlock_irqrestore(&nc->lock, flags);
 151                                 continue;
 152                         }
 153
 154                         if (nc->modes[NCSI_MODE_LINK].data[2] & 0x1) {
 155                                 spin_unlock_irqrestore(&nc->lock, flags);
 156                                 nd->link_up = 1;
 157                                 goto report;
 158                         }
 159
 160                         spin_unlock_irqrestore(&nc->lock, flags);
 161                 }
 162         }
 163
 164 report:
 165         nd->handler(nd);
 166 }
 167
 168 static void ncsi_channel_monitor(unsigned long data)
 169 {
 170         struct ncsi_channel *nc = (struct ncsi_channel *)data;
 171         struct ncsi_package *np = nc->package;
 172         struct ncsi_dev_priv *ndp = np->ndp;
 173         struct ncsi_cmd_arg nca;
 174         bool enabled, chained;
 175         unsigned int monitor_state;
 176         unsigned long flags;
 177         int state, ret;
 178
 179         spin_lock_irqsave(&nc->lock, flags);
 180         state = nc->state;
 181         chained = !list_empty(&nc->link);
 182         enabled = nc->monitor.enabled;
 183         monitor_state = nc->monitor.state;
 184         spin_unlock_irqrestore(&nc->lock, flags);
 185
 186         if (!enabled || chained)
 187                 return;
 188         if (state != NCSI_CHANNEL_INACTIVE &&
 189             state != NCSI_CHANNEL_ACTIVE)
 190                 return;
 191
 192         switch (monitor_state) {
 193         case NCSI_CHANNEL_MONITOR_START:
 194         case NCSI_CHANNEL_MONITOR_RETRY:
 195                 nca.ndp = ndp;
 196                 nca.package = np->id;
 197                 nca.channel = nc->id;
 198                 nca.type = NCSI_PKT_CMD_GLS;
 199                 nca.req_flags = 0;
 200                 ret = ncsi_xmit_cmd(&nca);
 201                 if (ret) {
 202                         netdev_err(ndp->ndev.dev, "Error %d sending GLS\n",
 203                                    ret);
 204                         return;
 205                 }
 206
 207                 break;
 208         case NCSI_CHANNEL_MONITOR_WAIT ... NCSI_CHANNEL_MONITOR_WAIT_MAX:
 209                 break;
 210         default:
 211                 if (!(ndp->flags & NCSI_DEV_HWA) &&
 212                     state == NCSI_CHANNEL_ACTIVE) {
 213                         ncsi_report_link(ndp, true);
 214                         ndp->flags |= NCSI_DEV_RESHUFFLE;
 215                 }
 216
 217                 spin_lock_irqsave(&nc->lock, flags);
 218                 nc->state = NCSI_CHANNEL_INVISIBLE;
 219                 spin_unlock_irqrestore(&nc->lock, flags);
 220
 221                 spin_lock_irqsave(&ndp->lock, flags);
 222                 nc->state = NCSI_CHANNEL_INACTIVE;
 223                 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
 224                 spin_unlock_irqrestore(&ndp->lock, flags);
 225                 ncsi_process_next_channel(ndp);
 226                 return;
 227         }
 228
 229         spin_lock_irqsave(&nc->lock, flags);
 230         nc->monitor.state++;
 231         spin_unlock_irqrestore(&nc->lock, flags);
 232         mod_timer(&nc->monitor.timer, jiffies + HZ);
 233 }
 234
 235 void ncsi_start_channel_monitor(struct ncsi_channel *nc)
 236 {
 237         unsigned long flags;
 238
 239         spin_lock_irqsave(&nc->lock, flags);
 240         WARN_ON_ONCE(nc->monitor.enabled);
 241         nc->monitor.enabled = true;
 242         nc->monitor.state = NCSI_CHANNEL_MONITOR_START;
 243         spin_unlock_irqrestore(&nc->lock, flags);
 244
 245         mod_timer(&nc->monitor.timer, jiffies + HZ);
 246 }
 247
 248 void ncsi_stop_channel_monitor(struct ncsi_channel *nc)
 249 {
 250         unsigned long flags;
 251
 252         spin_lock_irqsave(&nc->lock, flags);
 253         if (!nc->monitor.enabled) {
 254                 spin_unlock_irqrestore(&nc->lock, flags);
 255                 return;
 256         }
 257         nc->monitor.enabled = false;
 258         spin_unlock_irqrestore(&nc->lock, flags);
 259
 260         del_timer_sync(&nc->monitor.timer);
 261 }
 262
 263 struct ncsi_channel *ncsi_find_channel(struct ncsi_package *np,
 264                                        unsigned char id)
 265 {
 266         struct ncsi_channel *nc;
 267
 268         NCSI_FOR_EACH_CHANNEL(np, nc) {
 269                 if (nc->id == id)
 270                         return nc;
 271         }
 272
 273         return NULL;
 274 }
 275
 276 struct ncsi_channel *ncsi_add_channel(struct ncsi_package *np, unsigned char id)
 277 {
 278         struct ncsi_channel *nc, *tmp;
 279         int index;
 280         unsigned long flags;
 281
 282         nc = kzalloc(sizeof(*nc), GFP_ATOMIC);
 283         if (!nc)
 284                 return NULL;
 285
 286         nc->id = id;
 287         nc->package = np;
 288         nc->state = NCSI_CHANNEL_INACTIVE;
 289         nc->monitor.enabled = false;
 290         setup_timer(&nc->monitor.timer,
 291                     ncsi_channel_monitor, (unsigned long)nc);
 292         spin_lock_init(&nc->lock);
 293         INIT_LIST_HEAD(&nc->link);
 294         for (index = 0; index < NCSI_CAP_MAX; index++)
 295                 nc->caps[index].index = index;
 296         for (index = 0; index < NCSI_MODE_MAX; index++)
 297                 nc->modes[index].index = index;
 298
 299         spin_lock_irqsave(&np->lock, flags);
 300         tmp = ncsi_find_channel(np, id);
 301         if (tmp) {
 302                 spin_unlock_irqrestore(&np->lock, flags);
 303                 kfree(nc);
 304                 return tmp;
 305         }
 306
 307         list_add_tail_rcu(&nc->node, &np->channels);
 308         np->channel_num++;
 309         spin_unlock_irqrestore(&np->lock, flags);
 310
 311         return nc;
 312 }
 313
 314 static void ncsi_remove_channel(struct ncsi_channel *nc)
 315 {
 316         struct ncsi_package *np = nc->package;
 317         struct ncsi_channel_filter *ncf;
 318         unsigned long flags;
 319         int i;
 320
 321         /* Release filters */
 322         spin_lock_irqsave(&nc->lock, flags);
 323         for (i = 0; i < NCSI_FILTER_MAX; i++) {
 324                 ncf = nc->filters[i];
 325                 if (!ncf)
 326                         continue;
 327
 328                 nc->filters[i] = NULL;
 329                 kfree(ncf);
 330         }
 331
 332         nc->state = NCSI_CHANNEL_INACTIVE;
 333         spin_unlock_irqrestore(&nc->lock, flags);
 334         ncsi_stop_channel_monitor(nc);
 335
 336         /* Remove and free channel */
 337         spin_lock_irqsave(&np->lock, flags);
 338         list_del_rcu(&nc->node);
 339         np->channel_num--;
 340         spin_unlock_irqrestore(&np->lock, flags);
 341
 342         kfree(nc);
 343 }
 344
 345 struct ncsi_package *ncsi_find_package(struct ncsi_dev_priv *ndp,
 346                                        unsigned char id)
 347 {
 348         struct ncsi_package *np;
 349
 350         NCSI_FOR_EACH_PACKAGE(ndp, np) {
 351                 if (np->id == id)
 352                         return np;
 353         }
 354
 355         return NULL;
 356 }
 357
 358 struct ncsi_package *ncsi_add_package(struct ncsi_dev_priv *ndp,
 359                                       unsigned char id)
 360 {
 361         struct ncsi_package *np, *tmp;
 362         unsigned long flags;
 363
 364         np = kzalloc(sizeof(*np), GFP_ATOMIC);
 365         if (!np)
 366                 return NULL;
 367
 368         np->id = id;
 369         np->ndp = ndp;
 370         spin_lock_init(&np->lock);
 371         INIT_LIST_HEAD(&np->channels);
 372
 373         spin_lock_irqsave(&ndp->lock, flags);
 374         tmp = ncsi_find_package(ndp, id);
 375         if (tmp) {
 376                 spin_unlock_irqrestore(&ndp->lock, flags);
 377                 kfree(np);
 378                 return tmp;
 379         }
 380
 381         list_add_tail_rcu(&np->node, &ndp->packages);
 382         ndp->package_num++;
 383         spin_unlock_irqrestore(&ndp->lock, flags);
 384
 385         return np;
 386 }
 387
 388 void ncsi_remove_package(struct ncsi_package *np)
 389 {
 390         struct ncsi_dev_priv *ndp = np->ndp;
 391         struct ncsi_channel *nc, *tmp;
 392         unsigned long flags;
 393
 394         /* Release all child channels */
 395         list_for_each_entry_safe(nc, tmp, &np->channels, node)
 396                 ncsi_remove_channel(nc);
 397
 398         /* Remove and free package */
 399         spin_lock_irqsave(&ndp->lock, flags);
 400         list_del_rcu(&np->node);
 401         ndp->package_num--;
 402         spin_unlock_irqrestore(&ndp->lock, flags);
 403
 404         kfree(np);
 405 }
 406
 407 void ncsi_find_package_and_channel(struct ncsi_dev_priv *ndp,
 408                                    unsigned char id,
 409                                    struct ncsi_package **np,
 410                                    struct ncsi_channel **nc)
 411 {
 412         struct ncsi_package *p;
 413         struct ncsi_channel *c;
 414
 415         p = ncsi_find_package(ndp, NCSI_PACKAGE_INDEX(id));
 416         c = p ? ncsi_find_channel(p, NCSI_CHANNEL_INDEX(id)) : NULL;
 417
 418         if (np)
 419                 *np = p;
 420         if (nc)
 421                 *nc = c;
 422 }
 423
 424 /* For two consecutive NCSI commands, the packet IDs shouldn't
 425  * be same. Otherwise, the bogus response might be replied. So
 426  * the available IDs are allocated in round-robin fashion.
 427  */
 428 struct ncsi_request *ncsi_alloc_request(struct ncsi_dev_priv *ndp,
 429                                         unsigned int req_flags)
 430 {
 431         struct ncsi_request *nr = NULL;
 432         int i, limit = ARRAY_SIZE(ndp->requests);
 433         unsigned long flags;
 434
 435         /* Check if there is one available request until the ceiling */
 436         spin_lock_irqsave(&ndp->lock, flags);
 437         for (i = ndp->request_id; i < limit; i++) {
 438                 if (ndp->requests[i].used)
 439                         continue;
 440
 441                 nr = &ndp->requests[i];
 442                 nr->used = true;
 443                 nr->flags = req_flags;
 444                 ndp->request_id = i + 1;
 445                 goto found;
 446         }
 447
 448         /* Fail back to check from the starting cursor */
 449         for (i = NCSI_REQ_START_IDX; i < ndp->request_id; i++) {
 450                 if (ndp->requests[i].used)
 451                         continue;
 452
 453                 nr = &ndp->requests[i];
 454                 nr->used = true;
 455                 nr->flags = req_flags;
 456                 ndp->request_id = i + 1;
 457                 goto found;
 458         }
 459
 460 found:
 461         spin_unlock_irqrestore(&ndp->lock, flags);
 462         return nr;
 463 }
 464
 465 void ncsi_free_request(struct ncsi_request *nr)
 466 {
 467         struct ncsi_dev_priv *ndp = nr->ndp;
 468         struct sk_buff *cmd, *rsp;
 469         unsigned long flags;
 470         bool driven;
 471
 472         if (nr->enabled) {
 473                 nr->enabled = false;
 474                 del_timer_sync(&nr->timer);
 475         }
 476
 477         spin_lock_irqsave(&ndp->lock, flags);
 478         cmd = nr->cmd;
 479         rsp = nr->rsp;
 480         nr->cmd = NULL;
 481         nr->rsp = NULL;
 482         nr->used = false;
 483         driven = !!(nr->flags & NCSI_REQ_FLAG_EVENT_DRIVEN);
 484         spin_unlock_irqrestore(&ndp->lock, flags);
 485
 486         if (driven && cmd && --ndp->pending_req_num == 0)
 487                 schedule_work(&ndp->work);
 488
 489         /* Release command and response */
 490         consume_skb(cmd);
 491         consume_skb(rsp);
 492 }
 493
 494 struct ncsi_dev *ncsi_find_dev(struct net_device *dev)
 495 {
 496         struct ncsi_dev_priv *ndp;
 497
 498         NCSI_FOR_EACH_DEV(ndp) {
 499                 if (ndp->ndev.dev == dev)
 500                         return &ndp->ndev;
 501         }
 502
 503         return NULL;
 504 }
 505
 506 static void ncsi_request_timeout(unsigned long data)
 507 {
 508         struct ncsi_request *nr = (struct ncsi_request *)data;
 509         struct ncsi_dev_priv *ndp = nr->ndp;
 510         unsigned long flags;
 511
 512         /* If the request already had associated response,
 513          * let the response handler to release it.
 514          */
 515         spin_lock_irqsave(&ndp->lock, flags);
 516         nr->enabled = false;
 517         if (nr->rsp || !nr->cmd) {
 518                 spin_unlock_irqrestore(&ndp->lock, flags);
 519                 return;
 520         }
 521         spin_unlock_irqrestore(&ndp->lock, flags);
 522
 523         /* Release the request */
 524         ncsi_free_request(nr);
 525 }
 526
 527 static void ncsi_suspend_channel(struct ncsi_dev_priv *ndp)
 528 {
 529         struct ncsi_dev *nd = &ndp->ndev;
 530         struct ncsi_package *np = ndp->active_package;
 531         struct ncsi_channel *nc = ndp->active_channel;
 532         struct ncsi_cmd_arg nca;
 533         unsigned long flags;
 534         int ret;
 535
 536         nca.ndp = ndp;
 537         nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
 538         switch (nd->state) {
 539         case ncsi_dev_state_suspend:
 540                 nd->state = ncsi_dev_state_suspend_select;
 541                 /* Fall through */
 542         case ncsi_dev_state_suspend_select:
 543                 ndp->pending_req_num = 1;
 544
 545                 nca.type = NCSI_PKT_CMD_SP;
 546                 nca.package = np->id;
 547                 nca.channel = NCSI_RESERVED_CHANNEL;
 548                 if (ndp->flags & NCSI_DEV_HWA)
 549                         nca.bytes[0] = 0;
 550                 else
 551                         nca.bytes[0] = 1;
 552
 553                 /* To retrieve the last link states of channels in current
 554                  * package when current active channel needs fail over to
 555                  * another one. It means we will possibly select another
 556                  * channel as next active one. The link states of channels
 557                  * are most important factor of the selection. So we need
 558                  * accurate link states. Unfortunately, the link states on
 559                  * inactive channels can't be updated with LSC AEN in time.
 560                  */
 561                 if (ndp->flags & NCSI_DEV_RESHUFFLE)
 562                         nd->state = ncsi_dev_state_suspend_gls;
 563                 else
 564                         nd->state = ncsi_dev_state_suspend_dcnt;
 565                 ret = ncsi_xmit_cmd(&nca);
 566                 if (ret)
 567                         goto error;
 568
 569                 break;
 570         case ncsi_dev_state_suspend_gls:
 571                 ndp->pending_req_num = np->channel_num;
 572
 573                 nca.type = NCSI_PKT_CMD_GLS;
 574                 nca.package = np->id;
 575
 576                 nd->state = ncsi_dev_state_suspend_dcnt;
 577                 NCSI_FOR_EACH_CHANNEL(np, nc) {
 578                         nca.channel = nc->id;
 579                         ret = ncsi_xmit_cmd(&nca);
 580                         if (ret)
 581                                 goto error;
 582                 }
 583
 584                 break;
 585         case ncsi_dev_state_suspend_dcnt:
 586                 ndp->pending_req_num = 1;
 587
 588                 nca.type = NCSI_PKT_CMD_DCNT;
 589                 nca.package = np->id;
 590                 nca.channel = nc->id;
 591
 592                 nd->state = ncsi_dev_state_suspend_dc;
 593                 ret = ncsi_xmit_cmd(&nca);
 594                 if (ret)
 595                         goto error;
 596
 597                 break;
 598         case ncsi_dev_state_suspend_dc:
 599                 ndp->pending_req_num = 1;
 600
 601                 nca.type = NCSI_PKT_CMD_DC;
 602                 nca.package = np->id;
 603                 nca.channel = nc->id;
 604                 nca.bytes[0] = 1;
 605
 606                 nd->state = ncsi_dev_state_suspend_deselect;
 607                 ret = ncsi_xmit_cmd(&nca);
 608                 if (ret)
 609                         goto error;
 610
 611                 break;
 612         case ncsi_dev_state_suspend_deselect:
 613                 ndp->pending_req_num = 1;
 614
 615                 nca.type = NCSI_PKT_CMD_DP;
 616                 nca.package = np->id;
 617                 nca.channel = NCSI_RESERVED_CHANNEL;
 618
 619                 nd->state = ncsi_dev_state_suspend_done;
 620                 ret = ncsi_xmit_cmd(&nca);
 621                 if (ret)
 622                         goto error;
 623
 624                 break;
 625         case ncsi_dev_state_suspend_done:
 626                 spin_lock_irqsave(&nc->lock, flags);
 627                 nc->state = NCSI_CHANNEL_INACTIVE;
 628                 spin_unlock_irqrestore(&nc->lock, flags);
 629                 ncsi_process_next_channel(ndp);
 630
 631                 break;
 632         default:
 633                 netdev_warn(nd->dev, "Wrong NCSI state 0x%x in suspend\n",
 634                             nd->state);
 635         }
 636
 637         return;
 638 error:
 639         nd->state = ncsi_dev_state_functional;
 640 }
 641
 642 static void ncsi_configure_channel(struct ncsi_dev_priv *ndp)
 643 {
 644         struct ncsi_dev *nd = &ndp->ndev;
 645         struct net_device *dev = nd->dev;
 646         struct ncsi_package *np = ndp->active_package;
 647         struct ncsi_channel *nc = ndp->active_channel;
 648         struct ncsi_channel *hot_nc = NULL;
 649         struct ncsi_cmd_arg nca;
 650         unsigned char index;
 651         unsigned long flags;
 652         int ret;
 653
 654         nca.ndp = ndp;
 655         nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
 656         switch (nd->state) {
 657         case ncsi_dev_state_config:
 658         case ncsi_dev_state_config_sp:
 659                 ndp->pending_req_num = 1;
 660
 661                 /* Select the specific package */
 662                 nca.type = NCSI_PKT_CMD_SP;
 663                 if (ndp->flags & NCSI_DEV_HWA)
 664                         nca.bytes[0] = 0;
 665                 else
 666                         nca.bytes[0] = 1;
 667                 nca.package = np->id;
 668                 nca.channel = NCSI_RESERVED_CHANNEL;
 669                 ret = ncsi_xmit_cmd(&nca);
 670                 if (ret)
 671                         goto error;
 672
 673                 nd->state = ncsi_dev_state_config_cis;
 674                 break;
 675         case ncsi_dev_state_config_cis:
 676                 ndp->pending_req_num = 1;
 677
 678                 /* Clear initial state */
 679                 nca.type = NCSI_PKT_CMD_CIS;
 680                 nca.package = np->id;
 681                 nca.channel = nc->id;
 682                 ret = ncsi_xmit_cmd(&nca);
 683                 if (ret)
 684                         goto error;
 685
 686                 nd->state = ncsi_dev_state_config_sma;
 687                 break;
 688         case ncsi_dev_state_config_sma:
 689         case ncsi_dev_state_config_ebf:
 690 #if IS_ENABLED(CONFIG_IPV6)
 691         case ncsi_dev_state_config_egmf:
 692 #endif
 693         case ncsi_dev_state_config_ecnt:
 694         case ncsi_dev_state_config_ec:
 695         case ncsi_dev_state_config_ae:
 696         case ncsi_dev_state_config_gls:
 697                 ndp->pending_req_num = 1;
 698
 699                 nca.package = np->id;
 700                 nca.channel = nc->id;
 701
 702                 /* Use first entry in unicast filter table. Note that
 703                  * the MAC filter table starts from entry 1 instead of
 704                  * 0.
 705                  */
 706                 if (nd->state == ncsi_dev_state_config_sma) {
 707                         nca.type = NCSI_PKT_CMD_SMA;
 708                         for (index = 0; index < 6; index++)
 709                                 nca.bytes[index] = dev->dev_addr[index];
 710                         nca.bytes[6] = 0x1;
 711                         nca.bytes[7] = 0x1;
 712                         nd->state = ncsi_dev_state_config_ebf;
 713                 } else if (nd->state == ncsi_dev_state_config_ebf) {
 714                         nca.type = NCSI_PKT_CMD_EBF;
 715                         nca.dwords[0] = nc->caps[NCSI_CAP_BC].cap;
 716                         nd->state = ncsi_dev_state_config_ecnt;
 717 #if IS_ENABLED(CONFIG_IPV6)
 718                         if (ndp->inet6_addr_num > 0 &&
 719                             (nc->caps[NCSI_CAP_GENERIC].cap &
 720                              NCSI_CAP_GENERIC_MC))
 721                                 nd->state = ncsi_dev_state_config_egmf;
 722                         else
 723                                 nd->state = ncsi_dev_state_config_ecnt;
 724                 } else if (nd->state == ncsi_dev_state_config_egmf) {
 725                         nca.type = NCSI_PKT_CMD_EGMF;
 726                         nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap;
 727                         nd->state = ncsi_dev_state_config_ecnt;
 728 #endif /* CONFIG_IPV6 */
 729                 } else if (nd->state == ncsi_dev_state_config_ecnt) {
 730                         nca.type = NCSI_PKT_CMD_ECNT;
 731                         nd->state = ncsi_dev_state_config_ec;
 732                 } else if (nd->state == ncsi_dev_state_config_ec) {
 733                         /* Enable AEN if it's supported */
 734                         nca.type = NCSI_PKT_CMD_EC;
 735                         nd->state = ncsi_dev_state_config_ae;
 736                         if (!(nc->caps[NCSI_CAP_AEN].cap & NCSI_CAP_AEN_MASK))
 737                                 nd->state = ncsi_dev_state_config_gls;
 738                 } else if (nd->state == ncsi_dev_state_config_ae) {
 739                         nca.type = NCSI_PKT_CMD_AE;
 740                         nca.bytes[0] = 0;
 741                         nca.dwords[1] = nc->caps[NCSI_CAP_AEN].cap;
 742                         nd->state = ncsi_dev_state_config_gls;
 743                 } else if (nd->state == ncsi_dev_state_config_gls) {
 744                         nca.type = NCSI_PKT_CMD_GLS;
 745                         nd->state = ncsi_dev_state_config_done;
 746                 }
 747
 748                 ret = ncsi_xmit_cmd(&nca);
 749                 if (ret)
 750                         goto error;
 751                 break;
 752         case ncsi_dev_state_config_done:
 753                 spin_lock_irqsave(&nc->lock, flags);
 754                 if (nc->modes[NCSI_MODE_LINK].data[2] & 0x1) {
 755                         hot_nc = nc;
 756                         nc->state = NCSI_CHANNEL_ACTIVE;
 757                 } else {
 758                         hot_nc = NULL;
 759                         nc->state = NCSI_CHANNEL_INACTIVE;
 760                 }
 761                 spin_unlock_irqrestore(&nc->lock, flags);
 762
 763                 /* Update the hot channel */
 764                 spin_lock_irqsave(&ndp->lock, flags);
 765                 ndp->hot_channel = hot_nc;
 766                 spin_unlock_irqrestore(&ndp->lock, flags);
 767
 768                 ncsi_start_channel_monitor(nc);
 769                 ncsi_process_next_channel(ndp);
 770                 break;
 771         default:
 772                 netdev_warn(dev, "Wrong NCSI state 0x%x in config\n",
 773                             nd->state);
 774         }
 775
 776         return;
 777
 778 error:
 779         ncsi_report_link(ndp, true);
 780 }
 781
 782 static int ncsi_choose_active_channel(struct ncsi_dev_priv *ndp)
 783 {
 784         struct ncsi_package *np;
 785         struct ncsi_channel *nc, *found, *hot_nc;
 786         struct ncsi_channel_mode *ncm;
 787         unsigned long flags;
 788
 789         spin_lock_irqsave(&ndp->lock, flags);
 790         hot_nc = ndp->hot_channel;
 791         spin_unlock_irqrestore(&ndp->lock, flags);
 792
 793         /* The search is done once an inactive channel with up
 794          * link is found.
 795          */
 796         found = NULL;
 797         NCSI_FOR_EACH_PACKAGE(ndp, np) {
 798                 NCSI_FOR_EACH_CHANNEL(np, nc) {
 799                         spin_lock_irqsave(&nc->lock, flags);
 800
 801                         if (!list_empty(&nc->link) ||
 802                             nc->state != NCSI_CHANNEL_INACTIVE) {
 803                                 spin_unlock_irqrestore(&nc->lock, flags);
 804                                 continue;
 805                         }
 806
 807                         if (!found)
 808                                 found = nc;
 809
 810                         if (nc == hot_nc)
 811                                 found = nc;
 812
 813                         ncm = &nc->modes[NCSI_MODE_LINK];
 814                         if (ncm->data[2] & 0x1) {
 815                                 spin_unlock_irqrestore(&nc->lock, flags);
 816                                 found = nc;
 817                                 goto out;
 818                         }
 819
 820                         spin_unlock_irqrestore(&nc->lock, flags);
 821                 }
 822         }
 823
 824         if (!found) {
 825                 ncsi_report_link(ndp, true);
 826                 return -ENODEV;
 827         }
 828
 829 out:
 830         spin_lock_irqsave(&ndp->lock, flags);
 831         list_add_tail_rcu(&found->link, &ndp->channel_queue);
 832         spin_unlock_irqrestore(&ndp->lock, flags);
 833
 834         return ncsi_process_next_channel(ndp);
 835 }
 836
 837 static bool ncsi_check_hwa(struct ncsi_dev_priv *ndp)
 838 {
 839         struct ncsi_package *np;
 840         struct ncsi_channel *nc;
 841         unsigned int cap;
 842
 843         /* The hardware arbitration is disabled if any one channel
 844          * doesn't support explicitly.
 845          */
 846         NCSI_FOR_EACH_PACKAGE(ndp, np) {
 847                 NCSI_FOR_EACH_CHANNEL(np, nc) {
 848                         cap = nc->caps[NCSI_CAP_GENERIC].cap;
 849                         if (!(cap & NCSI_CAP_GENERIC_HWA) ||
 850                             (cap & NCSI_CAP_GENERIC_HWA_MASK) !=
 851                             NCSI_CAP_GENERIC_HWA_SUPPORT) {
 852                                 ndp->flags &= ~NCSI_DEV_HWA;
 853                                 return false;
 854                         }
 855                 }
 856         }
 857
 858         ndp->flags |= NCSI_DEV_HWA;
 859         return true;
 860 }
 861
 862 static int ncsi_enable_hwa(struct ncsi_dev_priv *ndp)
 863 {
 864         struct ncsi_package *np;
 865         struct ncsi_channel *nc;
 866         unsigned long flags;
 867
 868         /* Move all available channels to processing queue */
 869         spin_lock_irqsave(&ndp->lock, flags);
 870         NCSI_FOR_EACH_PACKAGE(ndp, np) {
 871                 NCSI_FOR_EACH_CHANNEL(np, nc) {
 872                         WARN_ON_ONCE(nc->state != NCSI_CHANNEL_INACTIVE ||
 873                                      !list_empty(&nc->link));
 874                         ncsi_stop_channel_monitor(nc);
 875                         list_add_tail_rcu(&nc->link, &ndp->channel_queue);
 876                 }
 877         }
 878         spin_unlock_irqrestore(&ndp->lock, flags);
 879
 880         /* We can have no channels in extremely case */
 881         if (list_empty(&ndp->channel_queue)) {
 882                 ncsi_report_link(ndp, false);
 883                 return -ENOENT;
 884         }
 885
 886         return ncsi_process_next_channel(ndp);
 887 }
 888
 889 static void ncsi_probe_channel(struct ncsi_dev_priv *ndp)
 890 {
 891         struct ncsi_dev *nd = &ndp->ndev;
 892         struct ncsi_package *np;
 893         struct ncsi_channel *nc;
 894         struct ncsi_cmd_arg nca;
 895         unsigned char index;
 896         int ret;
 897
 898         nca.ndp = ndp;
 899         nca.req_flags = NCSI_REQ_FLAG_EVENT_DRIVEN;
 900         switch (nd->state) {
 901         case ncsi_dev_state_probe:
 902                 nd->state = ncsi_dev_state_probe_deselect;
 903                 /* Fall through */
 904         case ncsi_dev_state_probe_deselect:
 905                 ndp->pending_req_num = 8;
 906
 907                 /* Deselect all possible packages */
 908                 nca.type = NCSI_PKT_CMD_DP;
 909                 nca.channel = NCSI_RESERVED_CHANNEL;
 910                 for (index = 0; index < 8; index++) {
 911                         nca.package = index;
 912                         ret = ncsi_xmit_cmd(&nca);
 913                         if (ret)
 914                                 goto error;
 915                 }
 916
 917                 nd->state = ncsi_dev_state_probe_package;
 918                 break;
 919         case ncsi_dev_state_probe_package:
 920                 ndp->pending_req_num = 16;
 921
 922                 /* Select all possible packages */
 923                 nca.type = NCSI_PKT_CMD_SP;
 924                 nca.bytes[0] = 1;
 925                 nca.channel = NCSI_RESERVED_CHANNEL;
 926                 for (index = 0; index < 8; index++) {
 927                         nca.package = index;
 928                         ret = ncsi_xmit_cmd(&nca);
 929                         if (ret)
 930                                 goto error;
 931                 }
 932
 933                 /* Disable all possible packages */
 934                 nca.type = NCSI_PKT_CMD_DP;
 935                 for (index = 0; index < 8; index++) {
 936                         nca.package = index;
 937                         ret = ncsi_xmit_cmd(&nca);
 938                         if (ret)
 939                                 goto error;
 940                 }
 941
 942                 nd->state = ncsi_dev_state_probe_channel;
 943                 break;
 944         case ncsi_dev_state_probe_channel:
 945                 if (!ndp->active_package)
 946                         ndp->active_package = list_first_or_null_rcu(
 947                                 &ndp->packages, struct ncsi_package, node);
 948                 else if (list_is_last(&ndp->active_package->node,
 949                                       &ndp->packages))
 950                         ndp->active_package = NULL;
 951                 else
 952                         ndp->active_package = list_next_entry(
 953                                 ndp->active_package, node);
 954
 955                 /* All available packages and channels are enumerated. The
 956                  * enumeration happens for once when the NCSI interface is
 957                  * started. So we need continue to start the interface after
 958                  * the enumeration.
 959                  *
 960                  * We have to choose an active channel before configuring it.
 961                  * Note that we possibly don't have active channel in extreme
 962                  * situation.
 963                  */
 964                 if (!ndp->active_package) {
 965                         ndp->flags |= NCSI_DEV_PROBED;
 966                         if (ncsi_check_hwa(ndp))
 967                                 ncsi_enable_hwa(ndp);
 968                         else
 969                                 ncsi_choose_active_channel(ndp);
 970                         return;
 971                 }
 972
 973                 /* Select the active package */
 974                 ndp->pending_req_num = 1;
 975                 nca.type = NCSI_PKT_CMD_SP;
 976                 nca.bytes[0] = 1;
 977                 nca.package = ndp->active_package->id;
 978                 nca.channel = NCSI_RESERVED_CHANNEL;
 979                 ret = ncsi_xmit_cmd(&nca);
 980                 if (ret)
 981                         goto error;
 982
 983                 nd->state = ncsi_dev_state_probe_cis;
 984                 break;
 985         case ncsi_dev_state_probe_cis:
 986                 ndp->pending_req_num = NCSI_RESERVED_CHANNEL;
 987
 988                 /* Clear initial state */
 989                 nca.type = NCSI_PKT_CMD_CIS;
 990                 nca.package = ndp->active_package->id;
 991                 for (index = 0; index < NCSI_RESERVED_CHANNEL; index++) {
 992                         nca.channel = index;
 993                         ret = ncsi_xmit_cmd(&nca);
 994                         if (ret)
 995                                 goto error;
 996                 }
 997
 998                 nd->state = ncsi_dev_state_probe_gvi;
 999                 break;
1000         case ncsi_dev_state_probe_gvi:
1001         case ncsi_dev_state_probe_gc:
1002         case ncsi_dev_state_probe_gls:
1003                 np = ndp->active_package;
1004                 ndp->pending_req_num = np->channel_num;
1005
1006                 /* Retrieve version, capability or link status */
1007                 if (nd->state == ncsi_dev_state_probe_gvi)
1008                         nca.type = NCSI_PKT_CMD_GVI;
1009                 else if (nd->state == ncsi_dev_state_probe_gc)
1010                         nca.type = NCSI_PKT_CMD_GC;
1011                 else
1012                         nca.type = NCSI_PKT_CMD_GLS;
1013
1014                 nca.package = np->id;
1015                 NCSI_FOR_EACH_CHANNEL(np, nc) {
1016                         nca.channel = nc->id;
1017                         ret = ncsi_xmit_cmd(&nca);
1018                         if (ret)
1019                                 goto error;
1020                 }
1021
1022                 if (nd->state == ncsi_dev_state_probe_gvi)
1023                         nd->state = ncsi_dev_state_probe_gc;
1024                 else if (nd->state == ncsi_dev_state_probe_gc)
1025                         nd->state = ncsi_dev_state_probe_gls;
1026                 else
1027                         nd->state = ncsi_dev_state_probe_dp;
1028                 break;
1029         case ncsi_dev_state_probe_dp:
1030                 ndp->pending_req_num = 1;
1031
1032                 /* Deselect the active package */
1033                 nca.type = NCSI_PKT_CMD_DP;
1034                 nca.package = ndp->active_package->id;
1035                 nca.channel = NCSI_RESERVED_CHANNEL;
1036                 ret = ncsi_xmit_cmd(&nca);
1037                 if (ret)
1038                         goto error;
1039
1040                 /* Scan channels in next package */
1041                 nd->state = ncsi_dev_state_probe_channel;
1042                 break;
1043         default:
1044                 netdev_warn(nd->dev, "Wrong NCSI state 0x%0x in enumeration\n",
1045                             nd->state);
1046         }
1047
1048         return;
1049 error:
1050         ncsi_report_link(ndp, true);
1051 }
1052
1053 static void ncsi_dev_work(struct work_struct *work)
1054 {
1055         struct ncsi_dev_priv *ndp = container_of(work,
1056                         struct ncsi_dev_priv, work);
1057         struct ncsi_dev *nd = &ndp->ndev;
1058
1059         switch (nd->state & ncsi_dev_state_major) {
1060         case ncsi_dev_state_probe:
1061                 ncsi_probe_channel(ndp);
1062                 break;
1063         case ncsi_dev_state_suspend:
1064                 ncsi_suspend_channel(ndp);
1065                 break;
1066         case ncsi_dev_state_config:
1067                 ncsi_configure_channel(ndp);
1068                 break;
1069         default:
1070                 netdev_warn(nd->dev, "Wrong NCSI state 0x%x in workqueue\n",
1071                             nd->state);
1072         }
1073 }
1074
1075 int ncsi_process_next_channel(struct ncsi_dev_priv *ndp)
1076 {
1077         struct ncsi_channel *nc;
1078         int old_state;
1079         unsigned long flags;
1080
1081         spin_lock_irqsave(&ndp->lock, flags);
1082         nc = list_first_or_null_rcu(&ndp->channel_queue,
1083                                     struct ncsi_channel, link);
1084         if (!nc) {
1085                 spin_unlock_irqrestore(&ndp->lock, flags);
1086                 goto out;
1087         }
1088
1089         list_del_init(&nc->link);
1090         spin_unlock_irqrestore(&ndp->lock, flags);
1091
1092         spin_lock_irqsave(&nc->lock, flags);
1093         old_state = nc->state;
1094         nc->state = NCSI_CHANNEL_INVISIBLE;
1095         spin_unlock_irqrestore(&nc->lock, flags);
1096
1097         ndp->active_channel = nc;
1098         ndp->active_package = nc->package;
1099
1100         switch (old_state) {
1101         case NCSI_CHANNEL_INACTIVE:
1102                 ndp->ndev.state = ncsi_dev_state_config;
1103                 ncsi_configure_channel(ndp);
1104                 break;
1105         case NCSI_CHANNEL_ACTIVE:
1106                 ndp->ndev.state = ncsi_dev_state_suspend;
1107                 ncsi_suspend_channel(ndp);
1108                 break;
1109         default:
1110                 netdev_err(ndp->ndev.dev, "Invalid state 0x%x on %d:%d\n",
1111                            old_state, nc->package->id, nc->id);
1112                 ncsi_report_link(ndp, false);
1113                 return -EINVAL;
1114         }
1115
1116         return 0;
1117
1118 out:
1119         ndp->active_channel = NULL;
1120         ndp->active_package = NULL;
1121         if (ndp->flags & NCSI_DEV_RESHUFFLE) {
1122                 ndp->flags &= ~NCSI_DEV_RESHUFFLE;
1123                 return ncsi_choose_active_channel(ndp);
1124         }
1125
1126         ncsi_report_link(ndp, false);
1127         return -ENODEV;
1128 }
1129
1130 #if IS_ENABLED(CONFIG_IPV6)
1131 static int ncsi_inet6addr_event(struct notifier_block *this,
1132                                 unsigned long event, void *data)
1133 {
1134         struct inet6_ifaddr *ifa = data;
1135         struct net_device *dev = ifa->idev->dev;
1136         struct ncsi_dev *nd = ncsi_find_dev(dev);
1137         struct ncsi_dev_priv *ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
1138         struct ncsi_package *np;
1139         struct ncsi_channel *nc;
1140         struct ncsi_cmd_arg nca;
1141         bool action;
1142         int ret;
1143
1144         if (!ndp || (ipv6_addr_type(&ifa->addr) &
1145             (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK)))
1146                 return NOTIFY_OK;
1147
1148         switch (event) {
1149         case NETDEV_UP:
1150                 action = (++ndp->inet6_addr_num) == 1;
1151                 nca.type = NCSI_PKT_CMD_EGMF;
1152                 break;
1153         case NETDEV_DOWN:
1154                 action = (--ndp->inet6_addr_num == 0);
1155                 nca.type = NCSI_PKT_CMD_DGMF;
1156                 break;
1157         default:
1158                 return NOTIFY_OK;
1159         }
1160
1161         /* We might not have active channel or packages. The IPv6
1162          * required multicast will be enabled when active channel
1163          * or packages are chosen.
1164          */
1165         np = ndp->active_package;
1166         nc = ndp->active_channel;
1167         if (!action || !np || !nc)
1168                 return NOTIFY_OK;
1169
1170         /* We needn't enable or disable it if the function isn't supported */
1171         if (!(nc->caps[NCSI_CAP_GENERIC].cap & NCSI_CAP_GENERIC_MC))
1172                 return NOTIFY_OK;
1173
1174         nca.ndp = ndp;
1175         nca.req_flags = 0;
1176         nca.package = np->id;
1177         nca.channel = nc->id;
1178         nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap;
1179         ret = ncsi_xmit_cmd(&nca);
1180         if (ret) {
1181                 netdev_warn(dev, "Fail to %s global multicast filter (%d)\n",
1182                             (event == NETDEV_UP) ? "enable" : "disable", ret);
1183                 return NOTIFY_DONE;
1184         }
1185
1186         return NOTIFY_OK;
1187 }
1188
1189 static struct notifier_block ncsi_inet6addr_notifier = {
1190         .notifier_call = ncsi_inet6addr_event,
1191 };
1192 #endif /* CONFIG_IPV6 */
1193
1194 struct ncsi_dev *ncsi_register_dev(struct net_device *dev,
1195                                    void (*handler)(struct ncsi_dev *ndev))
1196 {
1197         struct ncsi_dev_priv *ndp;
1198         struct ncsi_dev *nd;
1199         unsigned long flags;
1200         int i;
1201
1202         /* Check if the device has been registered or not */
1203         nd = ncsi_find_dev(dev);
1204         if (nd)
1205                 return nd;
1206
1207         /* Create NCSI device */
1208         ndp = kzalloc(sizeof(*ndp), GFP_ATOMIC);
1209         if (!ndp)
1210                 return NULL;
1211
1212         nd = &ndp->ndev;
1213         nd->state = ncsi_dev_state_registered;
1214         nd->dev = dev;
1215         nd->handler = handler;
1216         ndp->pending_req_num = 0;
1217         INIT_LIST_HEAD(&ndp->channel_queue);
1218         INIT_WORK(&ndp->work, ncsi_dev_work);
1219
1220         /* Initialize private NCSI device */
1221         spin_lock_init(&ndp->lock);
1222         INIT_LIST_HEAD(&ndp->packages);
1223         ndp->request_id = NCSI_REQ_START_IDX;
1224         for (i = 0; i < ARRAY_SIZE(ndp->requests); i++) {
1225                 ndp->requests[i].id = i;
1226                 ndp->requests[i].ndp = ndp;
1227                 setup_timer(&ndp->requests[i].timer,
1228                             ncsi_request_timeout,
1229                             (unsigned long)&ndp->requests[i]);
1230         }
1231
1232         spin_lock_irqsave(&ncsi_dev_lock, flags);
1233 #if IS_ENABLED(CONFIG_IPV6)
1234         ndp->inet6_addr_num = 0;
1235         if (list_empty(&ncsi_dev_list))
1236                 register_inet6addr_notifier(&ncsi_inet6addr_notifier);
1237 #endif
1238         list_add_tail_rcu(&ndp->node, &ncsi_dev_list);
1239         spin_unlock_irqrestore(&ncsi_dev_lock, flags);
1240
1241         /* Register NCSI packet Rx handler */
1242         ndp->ptype.type = cpu_to_be16(ETH_P_NCSI);
1243         ndp->ptype.func = ncsi_rcv_rsp;
1244         ndp->ptype.dev = dev;
1245         dev_add_pack(&ndp->ptype);
1246
1247         return nd;
1248 }
1249 EXPORT_SYMBOL_GPL(ncsi_register_dev);
1250
1251 int ncsi_start_dev(struct ncsi_dev *nd)
1252 {
1253         struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1254         int ret;
1255
1256         if (nd->state != ncsi_dev_state_registered &&
1257             nd->state != ncsi_dev_state_functional)
1258                 return -ENOTTY;
1259
1260         if (!(ndp->flags & NCSI_DEV_PROBED)) {
1261                 nd->state = ncsi_dev_state_probe;
1262                 schedule_work(&ndp->work);
1263                 return 0;
1264         }
1265
1266         if (ndp->flags & NCSI_DEV_HWA)
1267                 ret = ncsi_enable_hwa(ndp);
1268         else
1269                 ret = ncsi_choose_active_channel(ndp);
1270
1271         return ret;
1272 }
1273 EXPORT_SYMBOL_GPL(ncsi_start_dev);
1274
1275 void ncsi_stop_dev(struct ncsi_dev *nd)
1276 {
1277         struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1278         struct ncsi_package *np;
1279         struct ncsi_channel *nc;
1280         bool chained;
1281         int old_state;
1282         unsigned long flags;
1283
1284         /* Stop the channel monitor and reset channel's state */
1285         NCSI_FOR_EACH_PACKAGE(ndp, np) {
1286                 NCSI_FOR_EACH_CHANNEL(np, nc) {
1287                         ncsi_stop_channel_monitor(nc);
1288
1289                         spin_lock_irqsave(&nc->lock, flags);
1290                         chained = !list_empty(&nc->link);
1291                         old_state = nc->state;
1292                         nc->state = NCSI_CHANNEL_INACTIVE;
1293                         spin_unlock_irqrestore(&nc->lock, flags);
1294
1295                         WARN_ON_ONCE(chained ||
1296                                      old_state == NCSI_CHANNEL_INVISIBLE);
1297                 }
1298         }
1299
1300         ncsi_report_link(ndp, true);
1301 }
1302 EXPORT_SYMBOL_GPL(ncsi_stop_dev);
1303
1304 void ncsi_unregister_dev(struct ncsi_dev *nd)
1305 {
1306         struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1307         struct ncsi_package *np, *tmp;
1308         unsigned long flags;
1309
1310         dev_remove_pack(&ndp->ptype);
1311
1312         list_for_each_entry_safe(np, tmp, &ndp->packages, node)
1313                 ncsi_remove_package(np);
1314
1315         spin_lock_irqsave(&ncsi_dev_lock, flags);
1316         list_del_rcu(&ndp->node);
1317 #if IS_ENABLED(CONFIG_IPV6)
1318         if (list_empty(&ncsi_dev_list))
1319                 unregister_inet6addr_notifier(&ncsi_inet6addr_notifier);
1320 #endif
1321         spin_unlock_irqrestore(&ncsi_dev_lock, flags);
1322
1323         kfree(ndp);
1324 }
1325 EXPORT_SYMBOL_GPL(ncsi_unregister_dev);