drivers/net/ethernet/sfc/efx.c

   1 /****************************************************************************
   2  * Driver for Solarflare Solarstorm network controllers and boards
   3  * Copyright 2005-2006 Fen Systems Ltd.
   4  * Copyright 2005-2011 Solarflare Communications Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation, incorporated herein by reference.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/pci.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/delay.h>
  16 #include <linux/notifier.h>
  17 #include <linux/ip.h>
  18 #include <linux/tcp.h>
  19 #include <linux/in.h>
  20 #include <linux/crc32.h>
  21 #include <linux/ethtool.h>
  22 #include <linux/topology.h>
  23 #include <linux/gfp.h>
  24 #include <linux/cpu_rmap.h>
  25 #include "net_driver.h"
  26 #include "efx.h"
  27 #include "nic.h"
  28 #include "selftest.h"
  29
  30 #include "mcdi.h"
  31 #include "workarounds.h"
  32
  33 /**************************************************************************
  34  *
  35  * Type name strings
  36  *
  37  **************************************************************************
  38  */
  39
  40 /* Loopback mode names (see LOOPBACK_MODE()) */
  41 const unsigned int efx_loopback_mode_max = LOOPBACK_MAX;
  42 const char *const efx_loopback_mode_names[] = {
  43         [LOOPBACK_NONE]         = "NONE",
  44         [LOOPBACK_DATA]         = "DATAPATH",
  45         [LOOPBACK_GMAC]         = "GMAC",
  46         [LOOPBACK_XGMII]        = "XGMII",
  47         [LOOPBACK_XGXS]         = "XGXS",
  48         [LOOPBACK_XAUI]         = "XAUI",
  49         [LOOPBACK_GMII]         = "GMII",
  50         [LOOPBACK_SGMII]        = "SGMII",
  51         [LOOPBACK_XGBR]         = "XGBR",
  52         [LOOPBACK_XFI]          = "XFI",
  53         [LOOPBACK_XAUI_FAR]     = "XAUI_FAR",
  54         [LOOPBACK_GMII_FAR]     = "GMII_FAR",
  55         [LOOPBACK_SGMII_FAR]    = "SGMII_FAR",
  56         [LOOPBACK_XFI_FAR]      = "XFI_FAR",
  57         [LOOPBACK_GPHY]         = "GPHY",
  58         [LOOPBACK_PHYXS]        = "PHYXS",
  59         [LOOPBACK_PCS]          = "PCS",
  60         [LOOPBACK_PMAPMD]       = "PMA/PMD",
  61         [LOOPBACK_XPORT]        = "XPORT",
  62         [LOOPBACK_XGMII_WS]     = "XGMII_WS",
  63         [LOOPBACK_XAUI_WS]      = "XAUI_WS",
  64         [LOOPBACK_XAUI_WS_FAR]  = "XAUI_WS_FAR",
  65         [LOOPBACK_XAUI_WS_NEAR] = "XAUI_WS_NEAR",
  66         [LOOPBACK_GMII_WS]      = "GMII_WS",
  67         [LOOPBACK_XFI_WS]       = "XFI_WS",
  68         [LOOPBACK_XFI_WS_FAR]   = "XFI_WS_FAR",
  69         [LOOPBACK_PHYXS_WS]     = "PHYXS_WS",
  70 };
  71
  72 const unsigned int efx_reset_type_max = RESET_TYPE_MAX;
  73 const char *const efx_reset_type_names[] = {
  74         [RESET_TYPE_INVISIBLE]     = "INVISIBLE",
  75         [RESET_TYPE_ALL]           = "ALL",
  76         [RESET_TYPE_WORLD]         = "WORLD",
  77         [RESET_TYPE_DISABLE]       = "DISABLE",
  78         [RESET_TYPE_TX_WATCHDOG]   = "TX_WATCHDOG",
  79         [RESET_TYPE_INT_ERROR]     = "INT_ERROR",
  80         [RESET_TYPE_RX_RECOVERY]   = "RX_RECOVERY",
  81         [RESET_TYPE_RX_DESC_FETCH] = "RX_DESC_FETCH",
  82         [RESET_TYPE_TX_DESC_FETCH] = "TX_DESC_FETCH",
  83         [RESET_TYPE_TX_SKIP]       = "TX_SKIP",
  84         [RESET_TYPE_MC_FAILURE]    = "MC_FAILURE",
  85 };
  86
  87 #define EFX_MAX_MTU (9 * 1024)
  88
  89 /* Reset workqueue. If any NIC has a hardware failure then a reset will be
  90  * queued onto this work queue. This is not a per-nic work queue, because
  91  * efx_reset_work() acquires the rtnl lock, so resets are naturally serialised.
  92  */
  93 static struct workqueue_struct *reset_workqueue;
  94
  95 /**************************************************************************
  96  *
  97  * Configurable values
  98  *
  99  *************************************************************************/
 100
 101 /*
 102  * Use separate channels for TX and RX events
 103  *
 104  * Set this to 1 to use separate channels for TX and RX. It allows us
 105  * to control interrupt affinity separately for TX and RX.
 106  *
 107  * This is only used in MSI-X interrupt mode
 108  */
 109 static unsigned int separate_tx_channels;
 110 module_param(separate_tx_channels, uint, 0444);
 111 MODULE_PARM_DESC(separate_tx_channels,
 112                  "Use separate channels for TX and RX");
 113
 114 /* This is the weight assigned to each of the (per-channel) virtual
 115  * NAPI devices.
 116  */
 117 static int napi_weight = 64;
 118
 119 /* This is the time (in jiffies) between invocations of the hardware
 120  * monitor.  On Falcon-based NICs, this will:
 121  * - Check the on-board hardware monitor;
 122  * - Poll the link state and reconfigure the hardware as necessary.
 123  */
 124 static unsigned int efx_monitor_interval = 1 * HZ;
 125
 126 /* Initial interrupt moderation settings.  They can be modified after
 127  * module load with ethtool.
 128  *
 129  * The default for RX should strike a balance between increasing the
 130  * round-trip latency and reducing overhead.
 131  */
 132 static unsigned int rx_irq_mod_usec = 60;
 133
 134 /* Initial interrupt moderation settings.  They can be modified after
 135  * module load with ethtool.
 136  *
 137  * This default is chosen to ensure that a 10G link does not go idle
 138  * while a TX queue is stopped after it has become full.  A queue is
 139  * restarted when it drops below half full.  The time this takes (assuming
 140  * worst case 3 descriptors per packet and 1024 descriptors) is
 141  *   512 / 3 * 1.2 = 205 usec.
 142  */
 143 static unsigned int tx_irq_mod_usec = 150;
 144
 145 /* This is the first interrupt mode to try out of:
 146  * 0 => MSI-X
 147  * 1 => MSI
 148  * 2 => legacy
 149  */
 150 static unsigned int interrupt_mode;
 151
 152 /* This is the requested number of CPUs to use for Receive-Side Scaling (RSS),
 153  * i.e. the number of CPUs among which we may distribute simultaneous
 154  * interrupt handling.
 155  *
 156  * Cards without MSI-X will only target one CPU via legacy or MSI interrupt.
 157  * The default (0) means to assign an interrupt to each core.
 158  */
 159 static unsigned int rss_cpus;
 160 module_param(rss_cpus, uint, 0444);
 161 MODULE_PARM_DESC(rss_cpus, "Number of CPUs to use for Receive-Side Scaling");
 162
 163 static int phy_flash_cfg;
 164 module_param(phy_flash_cfg, int, 0644);
 165 MODULE_PARM_DESC(phy_flash_cfg, "Set PHYs into reflash mode initially");
 166
 167 static unsigned irq_adapt_low_thresh = 8000;
 168 module_param(irq_adapt_low_thresh, uint, 0644);
 169 MODULE_PARM_DESC(irq_adapt_low_thresh,
 170                  "Threshold score for reducing IRQ moderation");
 171
 172 static unsigned irq_adapt_high_thresh = 16000;
 173 module_param(irq_adapt_high_thresh, uint, 0644);
 174 MODULE_PARM_DESC(irq_adapt_high_thresh,
 175                  "Threshold score for increasing IRQ moderation");
 176
 177 static unsigned debug = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
 178                          NETIF_MSG_LINK | NETIF_MSG_IFDOWN |
 179                          NETIF_MSG_IFUP | NETIF_MSG_RX_ERR |
 180                          NETIF_MSG_TX_ERR | NETIF_MSG_HW);
 181 module_param(debug, uint, 0);
 182 MODULE_PARM_DESC(debug, "Bitmapped debugging message enable value");
 183
 184 /**************************************************************************
 185  *
 186  * Utility functions and prototypes
 187  *
 188  *************************************************************************/
 189
 190 static void efx_start_interrupts(struct efx_nic *efx, bool may_keep_eventq);
 191 static void efx_stop_interrupts(struct efx_nic *efx, bool may_keep_eventq);
 192 static void efx_remove_channel(struct efx_channel *channel);
 193 static void efx_remove_channels(struct efx_nic *efx);
 194 static const struct efx_channel_type efx_default_channel_type;
 195 static void efx_remove_port(struct efx_nic *efx);
 196 static void efx_init_napi_channel(struct efx_channel *channel);
 197 static void efx_fini_napi(struct efx_nic *efx);
 198 static void efx_fini_napi_channel(struct efx_channel *channel);
 199 static void efx_fini_struct(struct efx_nic *efx);
 200 static void efx_start_all(struct efx_nic *efx);
 201 static void efx_stop_all(struct efx_nic *efx);
 202
 203 #define EFX_ASSERT_RESET_SERIALISED(efx)                \
 204         do {                                            \
 205                 if ((efx->state == STATE_RUNNING) ||    \
 206                     (efx->state == STATE_DISABLED))     \
 207                         ASSERT_RTNL();                  \
 208         } while (0)
 209
 210 /**************************************************************************
 211  *
 212  * Event queue processing
 213  *
 214  *************************************************************************/
 215
 216 /* Process channel's event queue
 217  *
 218  * This function is responsible for processing the event queue of a
 219  * single channel.  The caller must guarantee that this function will
 220  * never be concurrently called more than once on the same channel,
 221  * though different channels may be being processed concurrently.
 222  */
 223 static int efx_process_channel(struct efx_channel *channel, int budget)
 224 {
 225         int spent;
 226
 227         if (unlikely(!channel->enabled))
 228                 return 0;
 229
 230         spent = efx_nic_process_eventq(channel, budget);
 231         if (spent && efx_channel_has_rx_queue(channel)) {
 232                 struct efx_rx_queue *rx_queue =
 233                         efx_channel_get_rx_queue(channel);
 234
 235                 /* Deliver last RX packet. */
 236                 if (channel->rx_pkt) {
 237                         __efx_rx_packet(channel, channel->rx_pkt);
 238                         channel->rx_pkt = NULL;
 239                 }
 240                 if (rx_queue->enabled) {
 241                         efx_rx_strategy(channel);
 242                         efx_fast_push_rx_descriptors(rx_queue);
 243                 }
 244         }
 245
 246         return spent;
 247 }
 248
 249 /* Mark channel as finished processing
 250  *
 251  * Note that since we will not receive further interrupts for this
 252  * channel before we finish processing and call the eventq_read_ack()
 253  * method, there is no need to use the interrupt hold-off timers.
 254  */
 255 static inline void efx_channel_processed(struct efx_channel *channel)
 256 {
 257         /* The interrupt handler for this channel may set work_pending
 258          * as soon as we acknowledge the events we've seen.  Make sure
 259          * it's cleared before then. */
 260         channel->work_pending = false;
 261         smp_wmb();
 262
 263         efx_nic_eventq_read_ack(channel);
 264 }
 265
 266 /* NAPI poll handler
 267  *
 268  * NAPI guarantees serialisation of polls of the same device, which
 269  * provides the guarantee required by efx_process_channel().
 270  */
 271 static int efx_poll(struct napi_struct *napi, int budget)
 272 {
 273         struct efx_channel *channel =
 274                 container_of(napi, struct efx_channel, napi_str);
 275         struct efx_nic *efx = channel->efx;
 276         int spent;
 277
 278         netif_vdbg(efx, intr, efx->net_dev,
 279                    "channel %d NAPI poll executing on CPU %d\n",
 280                    channel->channel, raw_smp_processor_id());
 281
 282         spent = efx_process_channel(channel, budget);
 283
 284         if (spent < budget) {
 285                 if (efx_channel_has_rx_queue(channel) &&
 286                     efx->irq_rx_adaptive &&
 287                     unlikely(++channel->irq_count == 1000)) {
 288                         if (unlikely(channel->irq_mod_score <
 289                                      irq_adapt_low_thresh)) {
 290                                 if (channel->irq_moderation > 1) {
 291                                         channel->irq_moderation -= 1;
 292                                         efx->type->push_irq_moderation(channel);
 293                                 }
 294                         } else if (unlikely(channel->irq_mod_score >
 295                                             irq_adapt_high_thresh)) {
 296                                 if (channel->irq_moderation <
 297                                     efx->irq_rx_moderation) {
 298                                         channel->irq_moderation += 1;
 299                                         efx->type->push_irq_moderation(channel);
 300                                 }
 301                         }
 302                         channel->irq_count = 0;
 303                         channel->irq_mod_score = 0;
 304                 }
 305
 306                 efx_filter_rfs_expire(channel);
 307
 308                 /* There is no race here; although napi_disable() will
 309                  * only wait for napi_complete(), this isn't a problem
 310                  * since efx_channel_processed() will have no effect if
 311                  * interrupts have already been disabled.
 312                  */
 313                 napi_complete(napi);
 314                 efx_channel_processed(channel);
 315         }
 316
 317         return spent;
 318 }
 319
 320 /* Process the eventq of the specified channel immediately on this CPU
 321  *
 322  * Disable hardware generated interrupts, wait for any existing
 323  * processing to finish, then directly poll (and ack ) the eventq.
 324  * Finally reenable NAPI and interrupts.
 325  *
 326  * This is for use only during a loopback self-test.  It must not
 327  * deliver any packets up the stack as this can result in deadlock.
 328  */
 329 void efx_process_channel_now(struct efx_channel *channel)
 330 {
 331         struct efx_nic *efx = channel->efx;
 332
 333         BUG_ON(channel->channel >= efx->n_channels);
 334         BUG_ON(!channel->enabled);
 335         BUG_ON(!efx->loopback_selftest);
 336
 337         /* Disable interrupts and wait for ISRs to complete */
 338         efx_nic_disable_interrupts(efx);
 339         if (efx->legacy_irq) {
 340                 synchronize_irq(efx->legacy_irq);
 341                 efx->legacy_irq_enabled = false;
 342         }
 343         if (channel->irq)
 344                 synchronize_irq(channel->irq);
 345
 346         /* Wait for any NAPI processing to complete */
 347         napi_disable(&channel->napi_str);
 348
 349         /* Poll the channel */
 350         efx_process_channel(channel, channel->eventq_mask + 1);
 351
 352         /* Ack the eventq. This may cause an interrupt to be generated
 353          * when they are reenabled */
 354         efx_channel_processed(channel);
 355
 356         napi_enable(&channel->napi_str);
 357         if (efx->legacy_irq)
 358                 efx->legacy_irq_enabled = true;
 359         efx_nic_enable_interrupts(efx);
 360 }
 361
 362 /* Create event queue
 363  * Event queue memory allocations are done only once.  If the channel
 364  * is reset, the memory buffer will be reused; this guards against
 365  * errors during channel reset and also simplifies interrupt handling.
 366  */
 367 static int efx_probe_eventq(struct efx_channel *channel)
 368 {
 369         struct efx_nic *efx = channel->efx;
 370         unsigned long entries;
 371
 372         netif_dbg(efx, probe, efx->net_dev,
 373                   "chan %d create event queue\n", channel->channel);
 374
 375         /* Build an event queue with room for one event per tx and rx buffer,
 376          * plus some extra for link state events and MCDI completions. */
 377         entries = roundup_pow_of_two(efx->rxq_entries + efx->txq_entries + 128);
 378         EFX_BUG_ON_PARANOID(entries > EFX_MAX_EVQ_SIZE);
 379         channel->eventq_mask = max(entries, EFX_MIN_EVQ_SIZE) - 1;
 380
 381         return efx_nic_probe_eventq(channel);
 382 }
 383
 384 /* Prepare channel's event queue */
 385 static void efx_init_eventq(struct efx_channel *channel)
 386 {
 387         netif_dbg(channel->efx, drv, channel->efx->net_dev,
 388                   "chan %d init event queue\n", channel->channel);
 389
 390         channel->eventq_read_ptr = 0;
 391
 392         efx_nic_init_eventq(channel);
 393 }
 394
 395 /* Enable event queue processing and NAPI */
 396 static void efx_start_eventq(struct efx_channel *channel)
 397 {
 398         netif_dbg(channel->efx, ifup, channel->efx->net_dev,
 399                   "chan %d start event queue\n", channel->channel);
 400
 401         /* The interrupt handler for this channel may set work_pending
 402          * as soon as we enable it.  Make sure it's cleared before
 403          * then.  Similarly, make sure it sees the enabled flag set.
 404          */
 405         channel->work_pending = false;
 406         channel->enabled = true;
 407         smp_wmb();
 408
 409         napi_enable(&channel->napi_str);
 410         efx_nic_eventq_read_ack(channel);
 411 }
 412
 413 /* Disable event queue processing and NAPI */
 414 static void efx_stop_eventq(struct efx_channel *channel)
 415 {
 416         if (!channel->enabled)
 417                 return;
 418
 419         napi_disable(&channel->napi_str);
 420         channel->enabled = false;
 421 }
 422
 423 static void efx_fini_eventq(struct efx_channel *channel)
 424 {
 425         netif_dbg(channel->efx, drv, channel->efx->net_dev,
 426                   "chan %d fini event queue\n", channel->channel);
 427
 428         efx_nic_fini_eventq(channel);
 429 }
 430
 431 static void efx_remove_eventq(struct efx_channel *channel)
 432 {
 433         netif_dbg(channel->efx, drv, channel->efx->net_dev,
 434                   "chan %d remove event queue\n", channel->channel);
 435
 436         efx_nic_remove_eventq(channel);
 437 }
 438
 439 /**************************************************************************
 440  *
 441  * Channel handling
 442  *
 443  *************************************************************************/
 444
 445 /* Allocate and initialise a channel structure. */
 446 static struct efx_channel *
 447 efx_alloc_channel(struct efx_nic *efx, int i, struct efx_channel *old_channel)
 448 {
 449         struct efx_channel *channel;
 450         struct efx_rx_queue *rx_queue;
 451         struct efx_tx_queue *tx_queue;
 452         int j;
 453
 454         channel = kzalloc(sizeof(*channel), GFP_KERNEL);
 455         if (!channel)
 456                 return NULL;
 457
 458         channel->efx = efx;
 459         channel->channel = i;
 460         channel->type = &efx_default_channel_type;
 461
 462         for (j = 0; j < EFX_TXQ_TYPES; j++) {
 463                 tx_queue = &channel->tx_queue[j];
 464                 tx_queue->efx = efx;
 465                 tx_queue->queue = i * EFX_TXQ_TYPES + j;
 466                 tx_queue->channel = channel;
 467         }
 468
 469         rx_queue = &channel->rx_queue;
 470         rx_queue->efx = efx;
 471         setup_timer(&rx_queue->slow_fill, efx_rx_slow_fill,
 472                     (unsigned long)rx_queue);
 473
 474         return channel;
 475 }
 476
 477 /* Allocate and initialise a channel structure, copying parameters
 478  * (but not resources) from an old channel structure.
 479  */
 480 static struct efx_channel *
 481 efx_copy_channel(const struct efx_channel *old_channel)
 482 {
 483         struct efx_channel *channel;
 484         struct efx_rx_queue *rx_queue;
 485         struct efx_tx_queue *tx_queue;
 486         int j;
 487
 488         channel = kmalloc(sizeof(*channel), GFP_KERNEL);
 489         if (!channel)
 490                 return NULL;
 491
 492         *channel = *old_channel;
 493
 494         channel->napi_dev = NULL;
 495         memset(&channel->eventq, 0, sizeof(channel->eventq));
 496
 497         for (j = 0; j < EFX_TXQ_TYPES; j++) {
 498                 tx_queue = &channel->tx_queue[j];
 499                 if (tx_queue->channel)
 500                         tx_queue->channel = channel;
 501                 tx_queue->buffer = NULL;
 502                 memset(&tx_queue->txd, 0, sizeof(tx_queue->txd));
 503         }
 504
 505         rx_queue = &channel->rx_queue;
 506         rx_queue->buffer = NULL;
 507         memset(&rx_queue->rxd, 0, sizeof(rx_queue->rxd));
 508         setup_timer(&rx_queue->slow_fill, efx_rx_slow_fill,
 509                     (unsigned long)rx_queue);
 510
 511         return channel;
 512 }
 513
 514 static int efx_probe_channel(struct efx_channel *channel)
 515 {
 516         struct efx_tx_queue *tx_queue;
 517         struct efx_rx_queue *rx_queue;
 518         int rc;
 519
 520         netif_dbg(channel->efx, probe, channel->efx->net_dev,
 521                   "creating channel %d\n", channel->channel);
 522
 523         rc = channel->type->pre_probe(channel);
 524         if (rc)
 525                 goto fail;
 526
 527         rc = efx_probe_eventq(channel);
 528         if (rc)
 529                 goto fail;
 530
 531         efx_for_each_channel_tx_queue(tx_queue, channel) {
 532                 rc = efx_probe_tx_queue(tx_queue);
 533                 if (rc)
 534                         goto fail;
 535         }
 536
 537         efx_for_each_channel_rx_queue(rx_queue, channel) {
 538                 rc = efx_probe_rx_queue(rx_queue);
 539                 if (rc)
 540                         goto fail;
 541         }
 542
 543         channel->n_rx_frm_trunc = 0;
 544
 545         return 0;
 546
 547 fail:
 548         efx_remove_channel(channel);
 549         return rc;
 550 }
 551
 552 static void
 553 efx_get_channel_name(struct efx_channel *channel, char *buf, size_t len)
 554 {
 555         struct efx_nic *efx = channel->efx;
 556         const char *type;
 557         int number;
 558
 559         number = channel->channel;
 560         if (efx->tx_channel_offset == 0) {
 561                 type = "";
 562         } else if (channel->channel < efx->tx_channel_offset) {
 563                 type = "-rx";
 564         } else {
 565                 type = "-tx";
 566                 number -= efx->tx_channel_offset;
 567         }
 568         snprintf(buf, len, "%s%s-%d", efx->name, type, number);
 569 }
 570
 571 static void efx_set_channel_names(struct efx_nic *efx)
 572 {
 573         struct efx_channel *channel;
 574
 575         efx_for_each_channel(channel, efx)
 576                 channel->type->get_name(channel,
 577                                         efx->channel_name[channel->channel],
 578                                         sizeof(efx->channel_name[0]));
 579 }
 580
 581 static int efx_probe_channels(struct efx_nic *efx)
 582 {
 583         struct efx_channel *channel;
 584         int rc;
 585
 586         /* Restart special buffer allocation */
 587         efx->next_buffer_table = 0;
 588
 589         /* Probe channels in reverse, so that any 'extra' channels
 590          * use the start of the buffer table. This allows the traffic
 591          * channels to be resized without moving them or wasting the
 592          * entries before them.
 593          */
 594         efx_for_each_channel_rev(channel, efx) {
 595                 rc = efx_probe_channel(channel);
 596                 if (rc) {
 597                         netif_err(efx, probe, efx->net_dev,
 598                                   "failed to create channel %d\n",
 599                                   channel->channel);
 600                         goto fail;
 601                 }
 602         }
 603         efx_set_channel_names(efx);
 604
 605         return 0;
 606
 607 fail:
 608         efx_remove_channels(efx);
 609         return rc;
 610 }
 611
 612 /* Channels are shutdown and reinitialised whilst the NIC is running
 613  * to propagate configuration changes (mtu, checksum offload), or
 614  * to clear hardware error conditions
 615  */
 616 static void efx_start_datapath(struct efx_nic *efx)
 617 {
 618         struct efx_tx_queue *tx_queue;
 619         struct efx_rx_queue *rx_queue;
 620         struct efx_channel *channel;
 621
 622         /* Calculate the rx buffer allocation parameters required to
 623          * support the current MTU, including padding for header
 624          * alignment and overruns.
 625          */
 626         efx->rx_buffer_len = (max(EFX_PAGE_IP_ALIGN, NET_IP_ALIGN) +
 627                               EFX_MAX_FRAME_LEN(efx->net_dev->mtu) +
 628                               efx->type->rx_buffer_hash_size +
 629                               efx->type->rx_buffer_padding);
 630         efx->rx_buffer_order = get_order(efx->rx_buffer_len +
 631                                          sizeof(struct efx_rx_page_state));
 632
 633         /* Initialise the channels */
 634         efx_for_each_channel(channel, efx) {
 635                 efx_for_each_channel_tx_queue(tx_queue, channel)
 636                         efx_init_tx_queue(tx_queue);
 637
 638                 /* The rx buffer allocation strategy is MTU dependent */
 639                 efx_rx_strategy(channel);
 640
 641                 efx_for_each_channel_rx_queue(rx_queue, channel) {
 642                         efx_init_rx_queue(rx_queue);
 643                         efx_nic_generate_fill_event(rx_queue);
 644                 }
 645
 646                 WARN_ON(channel->rx_pkt != NULL);
 647                 efx_rx_strategy(channel);
 648         }
 649
 650         if (netif_device_present(efx->net_dev))
 651                 netif_tx_wake_all_queues(efx->net_dev);
 652 }
 653
 654 static void efx_stop_datapath(struct efx_nic *efx)
 655 {
 656         struct efx_channel *channel;
 657         struct efx_tx_queue *tx_queue;
 658         struct efx_rx_queue *rx_queue;
 659         struct pci_dev *dev = efx->pci_dev;
 660         int rc;
 661
 662         EFX_ASSERT_RESET_SERIALISED(efx);
 663         BUG_ON(efx->port_enabled);
 664
 665         /* Only perform flush if dma is enabled */
 666         if (dev->is_busmaster) {
 667                 rc = efx_nic_flush_queues(efx);
 668
 669                 if (rc && EFX_WORKAROUND_7803(efx)) {
 670                         /* Schedule a reset to recover from the flush failure. The
 671                          * descriptor caches reference memory we're about to free,
 672                          * but falcon_reconfigure_mac_wrapper() won't reconnect
 673                          * the MACs because of the pending reset. */
 674                         netif_err(efx, drv, efx->net_dev,
 675                                   "Resetting to recover from flush failure\n");
 676                         efx_schedule_reset(efx, RESET_TYPE_ALL);
 677                 } else if (rc) {
 678                         netif_err(efx, drv, efx->net_dev, "failed to flush queues\n");
 679                 } else {
 680                         netif_dbg(efx, drv, efx->net_dev,
 681                                   "successfully flushed all queues\n");
 682                 }
 683         }
 684
 685         efx_for_each_channel(channel, efx) {
 686                 /* RX packet processing is pipelined, so wait for the
 687                  * NAPI handler to complete.  At least event queue 0
 688                  * might be kept active by non-data events, so don't
 689                  * use napi_synchronize() but actually disable NAPI
 690                  * temporarily.
 691                  */
 692                 if (efx_channel_has_rx_queue(channel)) {
 693                         efx_stop_eventq(channel);
 694                         efx_start_eventq(channel);
 695                 }
 696
 697                 efx_for_each_channel_rx_queue(rx_queue, channel)
 698                         efx_fini_rx_queue(rx_queue);
 699                 efx_for_each_possible_channel_tx_queue(tx_queue, channel)
 700                         efx_fini_tx_queue(tx_queue);
 701         }
 702 }
 703
 704 static void efx_remove_channel(struct efx_channel *channel)
 705 {
 706         struct efx_tx_queue *tx_queue;
 707         struct efx_rx_queue *rx_queue;
 708
 709         netif_dbg(channel->efx, drv, channel->efx->net_dev,
 710                   "destroy chan %d\n", channel->channel);
 711
 712         efx_for_each_channel_rx_queue(rx_queue, channel)
 713                 efx_remove_rx_queue(rx_queue);
 714         efx_for_each_possible_channel_tx_queue(tx_queue, channel)
 715                 efx_remove_tx_queue(tx_queue);
 716         efx_remove_eventq(channel);
 717 }
 718
 719 static void efx_remove_channels(struct efx_nic *efx)
 720 {
 721         struct efx_channel *channel;
 722
 723         efx_for_each_channel(channel, efx)
 724                 efx_remove_channel(channel);
 725 }
 726
 727 int
 728 efx_realloc_channels(struct efx_nic *efx, u32 rxq_entries, u32 txq_entries)
 729 {
 730         struct efx_channel *other_channel[EFX_MAX_CHANNELS], *channel;
 731         u32 old_rxq_entries, old_txq_entries;
 732         unsigned i, next_buffer_table = 0;
 733         int rc = 0;
 734
 735         /* Not all channels should be reallocated. We must avoid
 736          * reallocating their buffer table entries.
 737          */
 738         efx_for_each_channel(channel, efx) {
 739                 struct efx_rx_queue *rx_queue;
 740                 struct efx_tx_queue *tx_queue;
 741
 742                 if (channel->type->copy)
 743                         continue;
 744                 next_buffer_table = max(next_buffer_table,
 745                                         channel->eventq.index +
 746                                         channel->eventq.entries);
 747                 efx_for_each_channel_rx_queue(rx_queue, channel)
 748                         next_buffer_table = max(next_buffer_table,
 749                                                 rx_queue->rxd.index +
 750                                                 rx_queue->rxd.entries);
 751                 efx_for_each_channel_tx_queue(tx_queue, channel)
 752                         next_buffer_table = max(next_buffer_table,
 753                                                 tx_queue->txd.index +
 754                                                 tx_queue->txd.entries);
 755         }
 756
 757         efx_stop_all(efx);
 758         efx_stop_interrupts(efx, true);
 759
 760         /* Clone channels (where possible) */
 761         memset(other_channel, 0, sizeof(other_channel));
 762         for (i = 0; i < efx->n_channels; i++) {
 763                 channel = efx->channel[i];
 764                 if (channel->type->copy)
 765                         channel = channel->type->copy(channel);
 766                 if (!channel) {
 767                         rc = -ENOMEM;
 768                         goto out;
 769                 }
 770                 other_channel[i] = channel;
 771         }
 772
 773         /* Swap entry counts and channel pointers */
 774         old_rxq_entries = efx->rxq_entries;
 775         old_txq_entries = efx->txq_entries;
 776         efx->rxq_entries = rxq_entries;
 777         efx->txq_entries = txq_entries;
 778         for (i = 0; i < efx->n_channels; i++) {
 779                 channel = efx->channel[i];
 780                 efx->channel[i] = other_channel[i];
 781                 other_channel[i] = channel;
 782         }
 783
 784         /* Restart buffer table allocation */
 785         efx->next_buffer_table = next_buffer_table;
 786
 787         for (i = 0; i < efx->n_channels; i++) {
 788                 channel = efx->channel[i];
 789                 if (!channel->type->copy)
 790                         continue;
 791                 rc = efx_probe_channel(channel);
 792                 if (rc)
 793                         goto rollback;
 794                 efx_init_napi_channel(efx->channel[i]);
 795         }
 796
 797 out:
 798         /* Destroy unused channel structures */
 799         for (i = 0; i < efx->n_channels; i++) {
 800                 channel = other_channel[i];
 801                 if (channel && channel->type->copy) {
 802                         efx_fini_napi_channel(channel);
 803                         efx_remove_channel(channel);
 804                         kfree(channel);
 805                 }
 806         }
 807
 808         efx_start_interrupts(efx, true);
 809         efx_start_all(efx);
 810         return rc;
 811
 812 rollback:
 813         /* Swap back */
 814         efx->rxq_entries = old_rxq_entries;
 815         efx->txq_entries = old_txq_entries;
 816         for (i = 0; i < efx->n_channels; i++) {
 817                 channel = efx->channel[i];
 818                 efx->channel[i] = other_channel[i];
 819                 other_channel[i] = channel;
 820         }
 821         goto out;
 822 }
 823
 824 void efx_schedule_slow_fill(struct efx_rx_queue *rx_queue)
 825 {
 826         mod_timer(&rx_queue->slow_fill, jiffies + msecs_to_jiffies(100));
 827 }
 828
 829 static const struct efx_channel_type efx_default_channel_type = {
 830         .pre_probe              = efx_channel_dummy_op_int,
 831         .get_name               = efx_get_channel_name,
 832         .copy                   = efx_copy_channel,
 833         .keep_eventq            = false,
 834 };
 835
 836 int efx_channel_dummy_op_int(struct efx_channel *channel)
 837 {
 838         return 0;
 839 }
 840
 841 /**************************************************************************
 842  *
 843  * Port handling
 844  *
 845  **************************************************************************/
 846
 847 /* This ensures that the kernel is kept informed (via
 848  * netif_carrier_on/off) of the link status, and also maintains the
 849  * link status's stop on the port's TX queue.
 850  */
 851 void efx_link_status_changed(struct efx_nic *efx)
 852 {
 853         struct efx_link_state *link_state = &efx->link_state;
 854
 855         /* SFC Bug 5356: A net_dev notifier is registered, so we must ensure
 856          * that no events are triggered between unregister_netdev() and the
 857          * driver unloading. A more general condition is that NETDEV_CHANGE
 858          * can only be generated between NETDEV_UP and NETDEV_DOWN */
 859         if (!netif_running(efx->net_dev))
 860                 return;
 861
 862         if (link_state->up != netif_carrier_ok(efx->net_dev)) {
 863                 efx->n_link_state_changes++;
 864
 865                 if (link_state->up)
 866                         netif_carrier_on(efx->net_dev);
 867                 else
 868                         netif_carrier_off(efx->net_dev);
 869         }
 870
 871         /* Status message for kernel log */
 872         if (link_state->up)
 873                 netif_info(efx, link, efx->net_dev,
 874                            "link up at %uMbps %s-duplex (MTU %d)%s\n",
 875                            link_state->speed, link_state->fd ? "full" : "half",
 876                            efx->net_dev->mtu,
 877                            (efx->promiscuous ? " [PROMISC]" : ""));
 878         else
 879                 netif_info(efx, link, efx->net_dev, "link down\n");
 880 }
 881
 882 void efx_link_set_advertising(struct efx_nic *efx, u32 advertising)
 883 {
 884         efx->link_advertising = advertising;
 885         if (advertising) {
 886                 if (advertising & ADVERTISED_Pause)
 887                         efx->wanted_fc |= (EFX_FC_TX | EFX_FC_RX);
 888                 else
 889                         efx->wanted_fc &= ~(EFX_FC_TX | EFX_FC_RX);
 890                 if (advertising & ADVERTISED_Asym_Pause)
 891                         efx->wanted_fc ^= EFX_FC_TX;
 892         }
 893 }
 894
 895 void efx_link_set_wanted_fc(struct efx_nic *efx, u8 wanted_fc)
 896 {
 897         efx->wanted_fc = wanted_fc;
 898         if (efx->link_advertising) {
 899                 if (wanted_fc & EFX_FC_RX)
 900                         efx->link_advertising |= (ADVERTISED_Pause |
 901                                                   ADVERTISED_Asym_Pause);
 902                 else
 903                         efx->link_advertising &= ~(ADVERTISED_Pause |
 904                                                    ADVERTISED_Asym_Pause);
 905                 if (wanted_fc & EFX_FC_TX)
 906                         efx->link_advertising ^= ADVERTISED_Asym_Pause;
 907         }
 908 }
 909
 910 static void efx_fini_port(struct efx_nic *efx);
 911
 912 /* Push loopback/power/transmit disable settings to the PHY, and reconfigure
 913  * the MAC appropriately. All other PHY configuration changes are pushed
 914  * through phy_op->set_settings(), and pushed asynchronously to the MAC
 915  * through efx_monitor().
 916  *
 917  * Callers must hold the mac_lock
 918  */
 919 int __efx_reconfigure_port(struct efx_nic *efx)
 920 {
 921         enum efx_phy_mode phy_mode;
 922         int rc;
 923
 924         WARN_ON(!mutex_is_locked(&efx->mac_lock));
 925
 926         /* Serialise the promiscuous flag with efx_set_rx_mode. */
 927         netif_addr_lock_bh(efx->net_dev);
 928         netif_addr_unlock_bh(efx->net_dev);
 929
 930         /* Disable PHY transmit in mac level loopbacks */
 931         phy_mode = efx->phy_mode;
 932         if (LOOPBACK_INTERNAL(efx))
 933                 efx->phy_mode |= PHY_MODE_TX_DISABLED;
 934         else
 935                 efx->phy_mode &= ~PHY_MODE_TX_DISABLED;
 936
 937         rc = efx->type->reconfigure_port(efx);
 938
 939         if (rc)
 940                 efx->phy_mode = phy_mode;
 941
 942         return rc;
 943 }
 944
 945 /* Reinitialise the MAC to pick up new PHY settings, even if the port is
 946  * disabled. */
 947 int efx_reconfigure_port(struct efx_nic *efx)
 948 {
 949         int rc;
 950
 951         EFX_ASSERT_RESET_SERIALISED(efx);
 952
 953         mutex_lock(&efx->mac_lock);
 954         rc = __efx_reconfigure_port(efx);
 955         mutex_unlock(&efx->mac_lock);
 956
 957         return rc;
 958 }
 959
 960 /* Asynchronous work item for changing MAC promiscuity and multicast
 961  * hash.  Avoid a drain/rx_ingress enable by reconfiguring the current
 962  * MAC directly. */
 963 static void efx_mac_work(struct work_struct *data)
 964 {
 965         struct efx_nic *efx = container_of(data, struct efx_nic, mac_work);
 966
 967         mutex_lock(&efx->mac_lock);
 968         if (efx->port_enabled)
 969                 efx->type->reconfigure_mac(efx);
 970         mutex_unlock(&efx->mac_lock);
 971 }
 972
 973 static int efx_probe_port(struct efx_nic *efx)
 974 {
 975         int rc;
 976
 977         netif_dbg(efx, probe, efx->net_dev, "create port\n");
 978
 979         if (phy_flash_cfg)
 980                 efx->phy_mode = PHY_MODE_SPECIAL;
 981
 982         /* Connect up MAC/PHY operations table */
 983         rc = efx->type->probe_port(efx);
 984         if (rc)
 985                 return rc;
 986
 987         /* Initialise MAC address to permanent address */
 988         memcpy(efx->net_dev->dev_addr, efx->net_dev->perm_addr, ETH_ALEN);
 989
 990         return 0;
 991 }
 992
 993 static int efx_init_port(struct efx_nic *efx)
 994 {
 995         int rc;
 996
 997         netif_dbg(efx, drv, efx->net_dev, "init port\n");
 998
 999         mutex_lock(&efx->mac_lock);
1000
1001         rc = efx->phy_op->init(efx);
1002         if (rc)
1003                 goto fail1;
1004
1005         efx->port_initialized = true;
1006
1007         /* Reconfigure the MAC before creating dma queues (required for
1008          * Falcon/A1 where RX_INGR_EN/TX_DRAIN_EN isn't supported) */
1009         efx->type->reconfigure_mac(efx);
1010
1011         /* Ensure the PHY advertises the correct flow control settings */
1012         rc = efx->phy_op->reconfigure(efx);
1013         if (rc)
1014                 goto fail2;
1015
1016         mutex_unlock(&efx->mac_lock);
1017         return 0;
1018
1019 fail2:
1020         efx->phy_op->fini(efx);
1021 fail1:
1022         mutex_unlock(&efx->mac_lock);
1023         return rc;
1024 }
1025
1026 static void efx_start_port(struct efx_nic *efx)
1027 {
1028         netif_dbg(efx, ifup, efx->net_dev, "start port\n");
1029         BUG_ON(efx->port_enabled);
1030
1031         mutex_lock(&efx->mac_lock);
1032         efx->port_enabled = true;
1033
1034         /* efx_mac_work() might have been scheduled after efx_stop_port(),
1035          * and then cancelled by efx_flush_all() */
1036         efx->type->reconfigure_mac(efx);
1037
1038         mutex_unlock(&efx->mac_lock);
1039 }
1040
1041 /* Prevent efx_mac_work() and efx_monitor() from working */
1042 static void efx_stop_port(struct efx_nic *efx)
1043 {
1044         netif_dbg(efx, ifdown, efx->net_dev, "stop port\n");
1045
1046         mutex_lock(&efx->mac_lock);
1047         efx->port_enabled = false;
1048         mutex_unlock(&efx->mac_lock);
1049
1050         /* Serialise against efx_set_multicast_list() */
1051         netif_addr_lock_bh(efx->net_dev);
1052         netif_addr_unlock_bh(efx->net_dev);
1053 }
1054
1055 static void efx_fini_port(struct efx_nic *efx)
1056 {
1057         netif_dbg(efx, drv, efx->net_dev, "shut down port\n");
1058
1059         if (!efx->port_initialized)
1060                 return;
1061
1062         efx->phy_op->fini(efx);
1063         efx->port_initialized = false;
1064
1065         efx->link_state.up = false;
1066         efx_link_status_changed(efx);
1067 }
1068
1069 static void efx_remove_port(struct efx_nic *efx)
1070 {
1071         netif_dbg(efx, drv, efx->net_dev, "destroying port\n");
1072
1073         efx->type->remove_port(efx);
1074 }
1075
1076 /**************************************************************************
1077  *
1078  * NIC handling
1079  *
1080  **************************************************************************/
1081
1082 /* This configures the PCI device to enable I/O and DMA. */
1083 static int efx_init_io(struct efx_nic *efx)
1084 {
1085         struct pci_dev *pci_dev = efx->pci_dev;
1086         dma_addr_t dma_mask = efx->type->max_dma_mask;
1087         int rc;
1088
1089         netif_dbg(efx, probe, efx->net_dev, "initialising I/O\n");
1090
1091         rc = pci_enable_device(pci_dev);
1092         if (rc) {
1093                 netif_err(efx, probe, efx->net_dev,
1094                           "failed to enable PCI device\n");
1095                 goto fail1;
1096         }
1097
1098         pci_set_master(pci_dev);
1099
1100         /* Set the PCI DMA mask.  Try all possibilities from our
1101          * genuine mask down to 32 bits, because some architectures
1102          * (e.g. x86_64 with iommu_sac_force set) will allow 40 bit
1103          * masks event though they reject 46 bit masks.
1104          */
1105         while (dma_mask > 0x7fffffffUL) {
1106                 if (pci_dma_supported(pci_dev, dma_mask)) {
1107                         rc = pci_set_dma_mask(pci_dev, dma_mask);
1108                         if (rc == 0)
1109                                 break;
1110                 }
1111                 dma_mask >>= 1;
1112         }
1113         if (rc) {
1114                 netif_err(efx, probe, efx->net_dev,
1115                           "could not find a suitable DMA mask\n");
1116                 goto fail2;
1117         }
1118         netif_dbg(efx, probe, efx->net_dev,
1119                   "using DMA mask %llx\n", (unsigned long long) dma_mask);
1120         rc = pci_set_consistent_dma_mask(pci_dev, dma_mask);
1121         if (rc) {
1122                 /* pci_set_consistent_dma_mask() is not *allowed* to
1123                  * fail with a mask that pci_set_dma_mask() accepted,
1124                  * but just in case...
1125                  */
1126                 netif_err(efx, probe, efx->net_dev,
1127                           "failed to set consistent DMA mask\n");
1128                 goto fail2;
1129         }
1130
1131         efx->membase_phys = pci_resource_start(efx->pci_dev, EFX_MEM_BAR);
1132         rc = pci_request_region(pci_dev, EFX_MEM_BAR, "sfc");
1133         if (rc) {
1134                 netif_err(efx, probe, efx->net_dev,
1135                           "request for memory BAR failed\n");
1136                 rc = -EIO;
1137                 goto fail3;
1138         }
1139         efx->membase = ioremap_nocache(efx->membase_phys,
1140                                        efx->type->mem_map_size);
1141         if (!efx->membase) {
1142                 netif_err(efx, probe, efx->net_dev,
1143                           "could not map memory BAR at %llx+%x\n",
1144                           (unsigned long long)efx->membase_phys,
1145                           efx->type->mem_map_size);
1146                 rc = -ENOMEM;
1147                 goto fail4;
1148         }
1149         netif_dbg(efx, probe, efx->net_dev,
1150                   "memory BAR at %llx+%x (virtual %p)\n",
1151                   (unsigned long long)efx->membase_phys,
1152                   efx->type->mem_map_size, efx->membase);
1153
1154         return 0;
1155
1156  fail4:
1157         pci_release_region(efx->pci_dev, EFX_MEM_BAR);
1158  fail3:
1159         efx->membase_phys = 0;
1160  fail2:
1161         pci_disable_device(efx->pci_dev);
1162  fail1:
1163         return rc;
1164 }
1165
1166 static void efx_fini_io(struct efx_nic *efx)
1167 {
1168         netif_dbg(efx, drv, efx->net_dev, "shutting down I/O\n");
1169
1170         if (efx->membase) {
1171                 iounmap(efx->membase);
1172                 efx->membase = NULL;
1173         }
1174
1175         if (efx->membase_phys) {
1176                 pci_release_region(efx->pci_dev, EFX_MEM_BAR);
1177                 efx->membase_phys = 0;
1178         }
1179
1180         pci_disable_device(efx->pci_dev);
1181 }
1182
1183 static unsigned int efx_wanted_parallelism(struct efx_nic *efx)
1184 {
1185         cpumask_var_t thread_mask;
1186         unsigned int count;
1187         int cpu;
1188
1189         if (rss_cpus) {
1190                 count = rss_cpus;
1191         } else {
1192                 if (unlikely(!zalloc_cpumask_var(&thread_mask, GFP_KERNEL))) {
1193                         netif_warn(efx, probe, efx->net_dev,
1194                                    "RSS disabled due to allocation failure\n");
1195                         return 1;
1196                 }
1197
1198                 count = 0;
1199                 for_each_online_cpu(cpu) {
1200                         if (!cpumask_test_cpu(cpu, thread_mask)) {
1201                                 ++count;
1202                                 cpumask_or(thread_mask, thread_mask,
1203                                            topology_thread_cpumask(cpu));
1204                         }
1205                 }
1206
1207                 free_cpumask_var(thread_mask);
1208         }
1209
1210         /* If RSS is requested for the PF *and* VFs then we can't write RSS
1211          * table entries that are inaccessible to VFs
1212          */
1213         if (efx_sriov_wanted(efx) && efx_vf_size(efx) > 1 &&
1214             count > efx_vf_size(efx)) {
1215                 netif_warn(efx, probe, efx->net_dev,
1216                            "Reducing number of RSS channels from %u to %u for "
1217                            "VF support. Increase vf-msix-limit to use more "
1218                            "channels on the PF.\n",
1219                            count, efx_vf_size(efx));
1220                 count = efx_vf_size(efx);
1221         }
1222
1223         return count;
1224 }
1225
1226 static int
1227 efx_init_rx_cpu_rmap(struct efx_nic *efx, struct msix_entry *xentries)
1228 {
1229 #ifdef CONFIG_RFS_ACCEL
1230         unsigned int i;
1231         int rc;
1232
1233         efx->net_dev->rx_cpu_rmap = alloc_irq_cpu_rmap(efx->n_rx_channels);
1234         if (!efx->net_dev->rx_cpu_rmap)
1235                 return -ENOMEM;
1236         for (i = 0; i < efx->n_rx_channels; i++) {
1237                 rc = irq_cpu_rmap_add(efx->net_dev->rx_cpu_rmap,
1238                                       xentries[i].vector);
1239                 if (rc) {
1240                         free_irq_cpu_rmap(efx->net_dev->rx_cpu_rmap);
1241                         efx->net_dev->rx_cpu_rmap = NULL;
1242                         return rc;
1243                 }
1244         }
1245 #endif
1246         return 0;
1247 }
1248
1249 /* Probe the number and type of interrupts we are able to obtain, and
1250  * the resulting numbers of channels and RX queues.
1251  */
1252 static int efx_probe_interrupts(struct efx_nic *efx)
1253 {
1254         unsigned int max_channels =
1255                 min(efx->type->phys_addr_channels, EFX_MAX_CHANNELS);
1256         unsigned int extra_channels = 0;
1257         unsigned int i, j;
1258         int rc;
1259
1260         for (i = 0; i < EFX_MAX_EXTRA_CHANNELS; i++)
1261                 if (efx->extra_channel_type[i])
1262                         ++extra_channels;
1263
1264         if (efx->interrupt_mode == EFX_INT_MODE_MSIX) {
1265                 struct msix_entry xentries[EFX_MAX_CHANNELS];
1266                 unsigned int n_channels;
1267
1268                 n_channels = efx_wanted_parallelism(efx);
1269                 if (separate_tx_channels)
1270                         n_channels *= 2;
1271                 n_channels += extra_channels;
1272                 n_channels = min(n_channels, max_channels);
1273
1274                 for (i = 0; i < n_channels; i++)
1275                         xentries[i].entry = i;
1276                 rc = pci_enable_msix(efx->pci_dev, xentries, n_channels);
1277                 if (rc > 0) {
1278                         netif_err(efx, drv, efx->net_dev,
1279                                   "WARNING: Insufficient MSI-X vectors"
1280                                   " available (%d < %u).\n", rc, n_channels);
1281                         netif_err(efx, drv, efx->net_dev,
1282                                   "WARNING: Performance may be reduced.\n");
1283                         EFX_BUG_ON_PARANOID(rc >= n_channels);
1284                         n_channels = rc;
1285                         rc = pci_enable_msix(efx->pci_dev, xentries,
1286                                              n_channels);
1287                 }
1288
1289                 if (rc == 0) {
1290                         efx->n_channels = n_channels;
1291                         if (n_channels > extra_channels)
1292                                 n_channels -= extra_channels;
1293                         if (separate_tx_channels) {
1294                                 efx->n_tx_channels = max(n_channels / 2, 1U);
1295                                 efx->n_rx_channels = max(n_channels -
1296                                                          efx->n_tx_channels,
1297                                                          1U);
1298                         } else {
1299                                 efx->n_tx_channels = n_channels;
1300                                 efx->n_rx_channels = n_channels;
1301                         }
1302                         rc = efx_init_rx_cpu_rmap(efx, xentries);
1303                         if (rc) {
1304                                 pci_disable_msix(efx->pci_dev);
1305                                 return rc;
1306                         }
1307                         for (i = 0; i < efx->n_channels; i++)
1308                                 efx_get_channel(efx, i)->irq =
1309                                         xentries[i].vector;
1310                 } else {
1311                         /* Fall back to single channel MSI */
1312                         efx->interrupt_mode = EFX_INT_MODE_MSI;
1313                         netif_err(efx, drv, efx->net_dev,
1314                                   "could not enable MSI-X\n");
1315                 }
1316         }
1317
1318         /* Try single interrupt MSI */
1319         if (efx->interrupt_mode == EFX_INT_MODE_MSI) {
1320                 efx->n_channels = 1;
1321                 efx->n_rx_channels = 1;
1322                 efx->n_tx_channels = 1;
1323                 rc = pci_enable_msi(efx->pci_dev);
1324                 if (rc == 0) {
1325                         efx_get_channel(efx, 0)->irq = efx->pci_dev->irq;
1326                 } else {
1327                         netif_err(efx, drv, efx->net_dev,
1328                                   "could not enable MSI\n");
1329                         efx->interrupt_mode = EFX_INT_MODE_LEGACY;
1330                 }
1331         }
1332
1333         /* Assume legacy interrupts */
1334         if (efx->interrupt_mode == EFX_INT_MODE_LEGACY) {
1335                 efx->n_channels = 1 + (separate_tx_channels ? 1 : 0);
1336                 efx->n_rx_channels = 1;
1337                 efx->n_tx_channels = 1;
1338                 efx->legacy_irq = efx->pci_dev->irq;
1339         }
1340
1341         /* Assign extra channels if possible */
1342         j = efx->n_channels;
1343         for (i = 0; i < EFX_MAX_EXTRA_CHANNELS; i++) {
1344                 if (!efx->extra_channel_type[i])
1345                         continue;
1346                 if (efx->interrupt_mode != EFX_INT_MODE_MSIX ||
1347                     efx->n_channels <= extra_channels) {
1348                         efx->extra_channel_type[i]->handle_no_channel(efx);
1349                 } else {
1350                         --j;
1351                         efx_get_channel(efx, j)->type =
1352                                 efx->extra_channel_type[i];
1353                 }
1354         }
1355
1356         /* RSS might be usable on VFs even if it is disabled on the PF */
1357         efx->rss_spread = (efx->n_rx_channels > 1 ?
1358                            efx->n_rx_channels : efx_vf_size(efx));
1359
1360         return 0;
1361 }
1362
1363 /* Enable interrupts, then probe and start the event queues */
1364 static void efx_start_interrupts(struct efx_nic *efx, bool may_keep_eventq)
1365 {
1366         struct efx_channel *channel;
1367
1368         if (efx->legacy_irq)
1369                 efx->legacy_irq_enabled = true;
1370         efx_nic_enable_interrupts(efx);
1371
1372         efx_for_each_channel(channel, efx) {
1373                 if (!channel->type->keep_eventq || !may_keep_eventq)
1374                         efx_init_eventq(channel);
1375                 efx_start_eventq(channel);
1376         }
1377
1378         efx_mcdi_mode_event(efx);
1379 }
1380
1381 static void efx_stop_interrupts(struct efx_nic *efx, bool may_keep_eventq)
1382 {
1383         struct efx_channel *channel;
1384
1385         efx_mcdi_mode_poll(efx);
1386
1387         efx_nic_disable_interrupts(efx);
1388         if (efx->legacy_irq) {
1389                 synchronize_irq(efx->legacy_irq);
1390                 efx->legacy_irq_enabled = false;
1391         }
1392
1393         efx_for_each_channel(channel, efx) {
1394                 if (channel->irq)
1395                         synchronize_irq(channel->irq);
1396
1397                 efx_stop_eventq(channel);
1398                 if (!channel->type->keep_eventq || !may_keep_eventq)
1399                         efx_fini_eventq(channel);
1400         }
1401 }
1402
1403 static void efx_remove_interrupts(struct efx_nic *efx)
1404 {
1405         struct efx_channel *channel;
1406
1407         /* Remove MSI/MSI-X interrupts */
1408         efx_for_each_channel(channel, efx)
1409                 channel->irq = 0;
1410         pci_disable_msi(efx->pci_dev);
1411         pci_disable_msix(efx->pci_dev);
1412
1413         /* Remove legacy interrupt */
1414         efx->legacy_irq = 0;
1415 }
1416
1417 static void efx_set_channels(struct efx_nic *efx)
1418 {
1419         struct efx_channel *channel;
1420         struct efx_tx_queue *tx_queue;
1421
1422         efx->tx_channel_offset =
1423                 separate_tx_channels ? efx->n_channels - efx->n_tx_channels : 0;
1424
1425         /* We need to adjust the TX queue numbers if we have separate
1426          * RX-only and TX-only channels.
1427          */
1428         efx_for_each_channel(channel, efx) {
1429                 efx_for_each_channel_tx_queue(tx_queue, channel)
1430                         tx_queue->queue -= (efx->tx_channel_offset *
1431                                             EFX_TXQ_TYPES);
1432         }
1433 }
1434
1435 static int efx_probe_nic(struct efx_nic *efx)
1436 {
1437         size_t i;
1438         int rc;
1439
1440         netif_dbg(efx, probe, efx->net_dev, "creating NIC\n");
1441
1442         /* Carry out hardware-type specific initialisation */
1443         rc = efx->type->probe(efx);
1444         if (rc)
1445                 return rc;
1446
1447         /* Determine the number of channels and queues by trying to hook
1448          * in MSI-X interrupts. */
1449         rc = efx_probe_interrupts(efx);
1450         if (rc)
1451                 goto fail;
1452
1453         efx->type->dimension_resources(efx);
1454
1455         if (efx->n_channels > 1)
1456                 get_random_bytes(&efx->rx_hash_key, sizeof(efx->rx_hash_key));
1457         for (i = 0; i < ARRAY_SIZE(efx->rx_indir_table); i++)
1458                 efx->rx_indir_table[i] =
1459                         ethtool_rxfh_indir_default(i, efx->rss_spread);
1460
1461         efx_set_channels(efx);
1462         netif_set_real_num_tx_queues(efx->net_dev, efx->n_tx_channels);
1463         netif_set_real_num_rx_queues(efx->net_dev, efx->n_rx_channels);
1464
1465         /* Initialise the interrupt moderation settings */
1466         efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true,
1467                                 true);
1468
1469         return 0;
1470
1471 fail:
1472         efx->type->remove(efx);
1473         return rc;
1474 }
1475
1476 static void efx_remove_nic(struct efx_nic *efx)
1477 {
1478         netif_dbg(efx, drv, efx->net_dev, "destroying NIC\n");
1479
1480         efx_remove_interrupts(efx);
1481         efx->type->remove(efx);
1482 }
1483
1484 /**************************************************************************
1485  *
1486  * NIC startup/shutdown
1487  *
1488  *************************************************************************/
1489
1490 static int efx_probe_all(struct efx_nic *efx)
1491 {
1492         int rc;
1493
1494         rc = efx_probe_nic(efx);
1495         if (rc) {
1496                 netif_err(efx, probe, efx->net_dev, "failed to create NIC\n");
1497                 goto fail1;
1498         }
1499
1500         rc = efx_probe_port(efx);
1501         if (rc) {
1502                 netif_err(efx, probe, efx->net_dev, "failed to create port\n");
1503                 goto fail2;
1504         }
1505
1506         efx->rxq_entries = efx->txq_entries = EFX_DEFAULT_DMAQ_SIZE;
1507
1508         rc = efx_probe_filters(efx);
1509         if (rc) {
1510                 netif_err(efx, probe, efx->net_dev,
1511                           "failed to create filter tables\n");
1512                 goto fail3;
1513         }
1514
1515         rc = efx_probe_channels(efx);
1516         if (rc)
1517                 goto fail4;
1518
1519         return 0;
1520
1521  fail4:
1522         efx_remove_filters(efx);
1523  fail3:
1524         efx_remove_port(efx);
1525  fail2:
1526         efx_remove_nic(efx);
1527  fail1:
1528         return rc;
1529 }
1530
1531 /* Called after previous invocation(s) of efx_stop_all, restarts the port,
1532  * kernel transmit queues and NAPI processing, and ensures that the port is
1533  * scheduled to be reconfigured. This function is safe to call multiple
1534  * times when the NIC is in any state.
1535  */
1536 static void efx_start_all(struct efx_nic *efx)
1537 {
1538         EFX_ASSERT_RESET_SERIALISED(efx);
1539
1540         /* Check that it is appropriate to restart the interface. All
1541          * of these flags are safe to read under just the rtnl lock */
1542         if (efx->port_enabled)
1543                 return;
1544         if ((efx->state != STATE_RUNNING) && (efx->state != STATE_INIT))
1545                 return;
1546         if (!netif_running(efx->net_dev))
1547                 return;
1548
1549         efx_start_port(efx);
1550         efx_start_datapath(efx);
1551
1552         /* Start the hardware monitor if there is one. Otherwise (we're link
1553          * event driven), we have to poll the PHY because after an event queue
1554          * flush, we could have a missed a link state change */
1555         if (efx->type->monitor != NULL) {
1556                 queue_delayed_work(efx->workqueue, &efx->monitor_work,
1557                                    efx_monitor_interval);
1558         } else {
1559                 mutex_lock(&efx->mac_lock);
1560                 if (efx->phy_op->poll(efx))
1561                         efx_link_status_changed(efx);
1562                 mutex_unlock(&efx->mac_lock);
1563         }
1564
1565         efx->type->start_stats(efx);
1566 }
1567
1568 /* Flush all delayed work. Should only be called when no more delayed work
1569  * will be scheduled. This doesn't flush pending online resets (efx_reset),
1570  * since we're holding the rtnl_lock at this point. */
1571 static void efx_flush_all(struct efx_nic *efx)
1572 {
1573         /* Make sure the hardware monitor and event self-test are stopped */
1574         cancel_delayed_work_sync(&efx->monitor_work);
1575         efx_selftest_async_cancel(efx);
1576         /* Stop scheduled port reconfigurations */
1577         cancel_work_sync(&efx->mac_work);
1578 }
1579
1580 /* Quiesce hardware and software without bringing the link down.
1581  * Safe to call multiple times, when the nic and interface is in any
1582  * state. The caller is guaranteed to subsequently be in a position
1583  * to modify any hardware and software state they see fit without
1584  * taking locks. */
1585 static void efx_stop_all(struct efx_nic *efx)
1586 {
1587         EFX_ASSERT_RESET_SERIALISED(efx);
1588
1589         /* port_enabled can be read safely under the rtnl lock */
1590         if (!efx->port_enabled)
1591                 return;
1592
1593         efx->type->stop_stats(efx);
1594         efx_stop_port(efx);
1595
1596         /* Flush efx_mac_work(), refill_workqueue, monitor_work */
1597         efx_flush_all(efx);
1598
1599         /* Stop the kernel transmit interface late, so the watchdog
1600          * timer isn't ticking over the flush */
1601         netif_tx_disable(efx->net_dev);
1602
1603         efx_stop_datapath(efx);
1604 }
1605
1606 static void efx_remove_all(struct efx_nic *efx)
1607 {
1608         efx_remove_channels(efx);
1609         efx_remove_filters(efx);
1610         efx_remove_port(efx);
1611         efx_remove_nic(efx);
1612 }
1613
1614 /**************************************************************************
1615  *
1616  * Interrupt moderation
1617  *
1618  **************************************************************************/
1619
1620 static unsigned int irq_mod_ticks(unsigned int usecs, unsigned int quantum_ns)
1621 {
1622         if (usecs == 0)
1623                 return 0;
1624         if (usecs * 1000 < quantum_ns)
1625                 return 1; /* never round down to 0 */
1626         return usecs * 1000 / quantum_ns;
1627 }
1628
1629 /* Set interrupt moderation parameters */
1630 int efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs,
1631                             unsigned int rx_usecs, bool rx_adaptive,
1632                             bool rx_may_override_tx)
1633 {
1634         struct efx_channel *channel;
1635         unsigned int irq_mod_max = DIV_ROUND_UP(efx->type->timer_period_max *
1636                                                 efx->timer_quantum_ns,
1637                                                 1000);
1638         unsigned int tx_ticks;
1639         unsigned int rx_ticks;
1640
1641         EFX_ASSERT_RESET_SERIALISED(efx);
1642
1643         if (tx_usecs > irq_mod_max || rx_usecs > irq_mod_max)
1644                 return -EINVAL;
1645
1646         tx_ticks = irq_mod_ticks(tx_usecs, efx->timer_quantum_ns);
1647         rx_ticks = irq_mod_ticks(rx_usecs, efx->timer_quantum_ns);
1648
1649         if (tx_ticks != rx_ticks && efx->tx_channel_offset == 0 &&
1650             !rx_may_override_tx) {
1651                 netif_err(efx, drv, efx->net_dev, "Channels are shared. "
1652                           "RX and TX IRQ moderation must be equal\n");
1653                 return -EINVAL;
1654         }
1655
1656         efx->irq_rx_adaptive = rx_adaptive;
1657         efx->irq_rx_moderation = rx_ticks;
1658         efx_for_each_channel(channel, efx) {
1659                 if (efx_channel_has_rx_queue(channel))
1660                         channel->irq_moderation = rx_ticks;
1661                 else if (efx_channel_has_tx_queues(channel))
1662                         channel->irq_moderation = tx_ticks;
1663         }
1664
1665         return 0;
1666 }
1667
1668 void efx_get_irq_moderation(struct efx_nic *efx, unsigned int *tx_usecs,
1669                             unsigned int *rx_usecs, bool *rx_adaptive)
1670 {
1671         /* We must round up when converting ticks to microseconds
1672          * because we round down when converting the other way.
1673          */
1674
1675         *rx_adaptive = efx->irq_rx_adaptive;
1676         *rx_usecs = DIV_ROUND_UP(efx->irq_rx_moderation *
1677                                  efx->timer_quantum_ns,
1678                                  1000);
1679
1680         /* If channels are shared between RX and TX, so is IRQ
1681          * moderation.  Otherwise, IRQ moderation is the same for all
1682          * TX channels and is not adaptive.
1683          */
1684         if (efx->tx_channel_offset == 0)
1685                 *tx_usecs = *rx_usecs;
1686         else
1687                 *tx_usecs = DIV_ROUND_UP(
1688                         efx->channel[efx->tx_channel_offset]->irq_moderation *
1689                         efx->timer_quantum_ns,
1690                         1000);
1691 }
1692
1693 /**************************************************************************
1694  *
1695  * Hardware monitor
1696  *
1697  **************************************************************************/
1698
1699 /* Run periodically off the general workqueue */
1700 static void efx_monitor(struct work_struct *data)
1701 {
1702         struct efx_nic *efx = container_of(data, struct efx_nic,
1703                                            monitor_work.work);
1704
1705         netif_vdbg(efx, timer, efx->net_dev,
1706                    "hardware monitor executing on CPU %d\n",
1707                    raw_smp_processor_id());
1708         BUG_ON(efx->type->monitor == NULL);
1709
1710         /* If the mac_lock is already held then it is likely a port
1711          * reconfiguration is already in place, which will likely do
1712          * most of the work of monitor() anyway. */
1713         if (mutex_trylock(&efx->mac_lock)) {
1714                 if (efx->port_enabled)
1715                         efx->type->monitor(efx);
1716                 mutex_unlock(&efx->mac_lock);
1717         }
1718
1719         queue_delayed_work(efx->workqueue, &efx->monitor_work,
1720                            efx_monitor_interval);
1721 }
1722
1723 /**************************************************************************
1724  *
1725  * ioctls
1726  *
1727  *************************************************************************/
1728
1729 /* Net device ioctl
1730  * Context: process, rtnl_lock() held.
1731  */
1732 static int efx_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
1733 {
1734         struct efx_nic *efx = netdev_priv(net_dev);
1735         struct mii_ioctl_data *data = if_mii(ifr);
1736
1737         EFX_ASSERT_RESET_SERIALISED(efx);
1738
1739         /* Convert phy_id from older PRTAD/DEVAD format */
1740         if ((cmd == SIOCGMIIREG || cmd == SIOCSMIIREG) &&
1741             (data->phy_id & 0xfc00) == 0x0400)
1742                 data->phy_id ^= MDIO_PHY_ID_C45 | 0x0400;
1743
1744         return mdio_mii_ioctl(&efx->mdio, data, cmd);
1745 }
1746
1747 /**************************************************************************
1748  *
1749  * NAPI interface
1750  *
1751  **************************************************************************/
1752
1753 static void efx_init_napi_channel(struct efx_channel *channel)
1754 {
1755         struct efx_nic *efx = channel->efx;
1756
1757         channel->napi_dev = efx->net_dev;
1758         netif_napi_add(channel->napi_dev, &channel->napi_str,
1759                        efx_poll, napi_weight);
1760 }
1761
1762 static void efx_init_napi(struct efx_nic *efx)
1763 {
1764         struct efx_channel *channel;
1765
1766         efx_for_each_channel(channel, efx)
1767                 efx_init_napi_channel(channel);
1768 }
1769
1770 static void efx_fini_napi_channel(struct efx_channel *channel)
1771 {
1772         if (channel->napi_dev)
1773                 netif_napi_del(&channel->napi_str);
1774         channel->napi_dev = NULL;
1775 }
1776
1777 static void efx_fini_napi(struct efx_nic *efx)
1778 {
1779         struct efx_channel *channel;
1780
1781         efx_for_each_channel(channel, efx)
1782                 efx_fini_napi_channel(channel);
1783 }
1784
1785 /**************************************************************************
1786  *
1787  * Kernel netpoll interface
1788  *
1789  *************************************************************************/
1790
1791 #ifdef CONFIG_NET_POLL_CONTROLLER
1792
1793 /* Although in the common case interrupts will be disabled, this is not
1794  * guaranteed. However, all our work happens inside the NAPI callback,
1795  * so no locking is required.
1796  */
1797 static void efx_netpoll(struct net_device *net_dev)
1798 {
1799         struct efx_nic *efx = netdev_priv(net_dev);
1800         struct efx_channel *channel;
1801
1802         efx_for_each_channel(channel, efx)
1803                 efx_schedule_channel(channel);
1804 }
1805
1806 #endif
1807
1808 /**************************************************************************
1809  *
1810  * Kernel net device interface
1811  *
1812  *************************************************************************/
1813
1814 /* Context: process, rtnl_lock() held. */
1815 static int efx_net_open(struct net_device *net_dev)
1816 {
1817         struct efx_nic *efx = netdev_priv(net_dev);
1818         EFX_ASSERT_RESET_SERIALISED(efx);
1819
1820         netif_dbg(efx, ifup, efx->net_dev, "opening device on CPU %d\n",
1821                   raw_smp_processor_id());
1822
1823         if (efx->state == STATE_DISABLED)
1824                 return -EIO;
1825         if (efx->phy_mode & PHY_MODE_SPECIAL)
1826                 return -EBUSY;
1827         if (efx_mcdi_poll_reboot(efx) && efx_reset(efx, RESET_TYPE_ALL))
1828                 return -EIO;
1829
1830         /* Notify the kernel of the link state polled during driver load,
1831          * before the monitor starts running */
1832         efx_link_status_changed(efx);
1833
1834         efx_start_all(efx);
1835         efx_selftest_async_start(efx);
1836         return 0;
1837 }
1838
1839 /* Context: process, rtnl_lock() held.
1840  * Note that the kernel will ignore our return code; this method
1841  * should really be a void.
1842  */
1843 static int efx_net_stop(struct net_device *net_dev)
1844 {
1845         struct efx_nic *efx = netdev_priv(net_dev);
1846
1847         netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",
1848                   raw_smp_processor_id());
1849
1850         if (efx->state != STATE_DISABLED) {
1851                 /* Stop the device and flush all the channels */
1852                 efx_stop_all(efx);
1853         }
1854
1855         return 0;
1856 }
1857
1858 /* Context: process, dev_base_lock or RTNL held, non-blocking. */
1859 static struct rtnl_link_stats64 *efx_net_stats(struct net_device *net_dev,
1860                                                struct rtnl_link_stats64 *stats)
1861 {
1862         struct efx_nic *efx = netdev_priv(net_dev);
1863         struct efx_mac_stats *mac_stats = &efx->mac_stats;
1864
1865         spin_lock_bh(&efx->stats_lock);
1866
1867         efx->type->update_stats(efx);
1868
1869         stats->rx_packets = mac_stats->rx_packets;
1870         stats->tx_packets = mac_stats->tx_packets;
1871         stats->rx_bytes = mac_stats->rx_bytes;
1872         stats->tx_bytes = mac_stats->tx_bytes;
1873         stats->rx_dropped = efx->n_rx_nodesc_drop_cnt;
1874         stats->multicast = mac_stats->rx_multicast;
1875         stats->collisions = mac_stats->tx_collision;
1876         stats->rx_length_errors = (mac_stats->rx_gtjumbo +
1877                                    mac_stats->rx_length_error);
1878         stats->rx_crc_errors = mac_stats->rx_bad;
1879         stats->rx_frame_errors = mac_stats->rx_align_error;
1880         stats->rx_fifo_errors = mac_stats->rx_overflow;
1881         stats->rx_missed_errors = mac_stats->rx_missed;
1882         stats->tx_window_errors = mac_stats->tx_late_collision;
1883
1884         stats->rx_errors = (stats->rx_length_errors +
1885                             stats->rx_crc_errors +
1886                             stats->rx_frame_errors +
1887                             mac_stats->rx_symbol_error);
1888         stats->tx_errors = (stats->tx_window_errors +
1889                             mac_stats->tx_bad);
1890
1891         spin_unlock_bh(&efx->stats_lock);
1892
1893         return stats;
1894 }
1895
1896 /* Context: netif_tx_lock held, BHs disabled. */
1897 static void efx_watchdog(struct net_device *net_dev)
1898 {
1899         struct efx_nic *efx = netdev_priv(net_dev);
1900
1901         netif_err(efx, tx_err, efx->net_dev,
1902                   "TX stuck with port_enabled=%d: resetting channels\n",
1903                   efx->port_enabled);
1904
1905         efx_schedule_reset(efx, RESET_TYPE_TX_WATCHDOG);
1906 }
1907
1908
1909 /* Context: process, rtnl_lock() held. */
1910 static int efx_change_mtu(struct net_device *net_dev, int new_mtu)
1911 {
1912         struct efx_nic *efx = netdev_priv(net_dev);
1913
1914         EFX_ASSERT_RESET_SERIALISED(efx);
1915
1916         if (new_mtu > EFX_MAX_MTU)
1917                 return -EINVAL;
1918
1919         efx_stop_all(efx);
1920
1921         netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);
1922
1923         mutex_lock(&efx->mac_lock);
1924         /* Reconfigure the MAC before enabling the dma queues so that
1925          * the RX buffers don't overflow */
1926         net_dev->mtu = new_mtu;
1927         efx->type->reconfigure_mac(efx);
1928         mutex_unlock(&efx->mac_lock);
1929
1930         efx_start_all(efx);
1931         return 0;
1932 }
1933
1934 static int efx_set_mac_address(struct net_device *net_dev, void *data)
1935 {
1936         struct efx_nic *efx = netdev_priv(net_dev);
1937         struct sockaddr *addr = data;
1938         char *new_addr = addr->sa_data;
1939
1940         EFX_ASSERT_RESET_SERIALISED(efx);
1941
1942         if (!is_valid_ether_addr(new_addr)) {
1943                 netif_err(efx, drv, efx->net_dev,
1944                           "invalid ethernet MAC address requested: %pM\n",
1945                           new_addr);
1946                 return -EADDRNOTAVAIL;
1947         }
1948
1949         memcpy(net_dev->dev_addr, new_addr, net_dev->addr_len);
1950         efx_sriov_mac_address_changed(efx);
1951
1952         /* Reconfigure the MAC */
1953         mutex_lock(&efx->mac_lock);
1954         efx->type->reconfigure_mac(efx);
1955         mutex_unlock(&efx->mac_lock);
1956
1957         return 0;
1958 }
1959
1960 /* Context: netif_addr_lock held, BHs disabled. */
1961 static void efx_set_rx_mode(struct net_device *net_dev)
1962 {
1963         struct efx_nic *efx = netdev_priv(net_dev);
1964         struct netdev_hw_addr *ha;
1965         union efx_multicast_hash *mc_hash = &efx->multicast_hash;
1966         u32 crc;
1967         int bit;
1968
1969         efx->promiscuous = !!(net_dev->flags & IFF_PROMISC);
1970
1971         /* Build multicast hash table */
1972         if (efx->promiscuous || (net_dev->flags & IFF_ALLMULTI)) {
1973                 memset(mc_hash, 0xff, sizeof(*mc_hash));
1974         } else {
1975                 memset(mc_hash, 0x00, sizeof(*mc_hash));
1976                 netdev_for_each_mc_addr(ha, net_dev) {
1977                         crc = ether_crc_le(ETH_ALEN, ha->addr);
1978                         bit = crc & (EFX_MCAST_HASH_ENTRIES - 1);
1979                         set_bit_le(bit, mc_hash->byte);
1980                 }
1981
1982                 /* Broadcast packets go through the multicast hash filter.
1983                  * ether_crc_le() of the broadcast address is 0xbe2612ff
1984                  * so we always add bit 0xff to the mask.
1985                  */
1986                 set_bit_le(0xff, mc_hash->byte);
1987         }
1988
1989         if (efx->port_enabled)
1990                 queue_work(efx->workqueue, &efx->mac_work);
1991         /* Otherwise efx_start_port() will do this */
1992 }
1993
1994 static int efx_set_features(struct net_device *net_dev, netdev_features_t data)
1995 {
1996         struct efx_nic *efx = netdev_priv(net_dev);
1997
1998         /* If disabling RX n-tuple filtering, clear existing filters */
1999         if (net_dev->features & ~data & NETIF_F_NTUPLE)
2000                 efx_filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);
2001
2002         return 0;
2003 }
2004
2005 static const struct net_device_ops efx_netdev_ops = {
2006         .ndo_open               = efx_net_open,
2007         .ndo_stop               = efx_net_stop,
2008         .ndo_get_stats64        = efx_net_stats,
2009         .ndo_tx_timeout         = efx_watchdog,
2010         .ndo_start_xmit         = efx_hard_start_xmit,
2011         .ndo_validate_addr      = eth_validate_addr,
2012         .ndo_do_ioctl           = efx_ioctl,
2013         .ndo_change_mtu         = efx_change_mtu,
2014         .ndo_set_mac_address    = efx_set_mac_address,
2015         .ndo_set_rx_mode        = efx_set_rx_mode,
2016         .ndo_set_features       = efx_set_features,
2017 #ifdef CONFIG_SFC_SRIOV
2018         .ndo_set_vf_mac         = efx_sriov_set_vf_mac,
2019         .ndo_set_vf_vlan        = efx_sriov_set_vf_vlan,
2020         .ndo_set_vf_spoofchk    = efx_sriov_set_vf_spoofchk,
2021         .ndo_get_vf_config      = efx_sriov_get_vf_config,
2022 #endif
2023 #ifdef CONFIG_NET_POLL_CONTROLLER
2024         .ndo_poll_controller = efx_netpoll,
2025 #endif
2026         .ndo_setup_tc           = efx_setup_tc,
2027 #ifdef CONFIG_RFS_ACCEL
2028         .ndo_rx_flow_steer      = efx_filter_rfs,
2029 #endif
2030 };
2031
2032 static void efx_update_name(struct efx_nic *efx)
2033 {
2034         strcpy(efx->name, efx->net_dev->name);
2035         efx_mtd_rename(efx);
2036         efx_set_channel_names(efx);
2037 }
2038
2039 static int efx_netdev_event(struct notifier_block *this,
2040                             unsigned long event, void *ptr)
2041 {
2042         struct net_device *net_dev = ptr;
2043
2044         if (net_dev->netdev_ops == &efx_netdev_ops &&
2045             event == NETDEV_CHANGENAME)
2046                 efx_update_name(netdev_priv(net_dev));
2047
2048         return NOTIFY_DONE;
2049 }
2050
2051 static struct notifier_block efx_netdev_notifier = {
2052         .notifier_call = efx_netdev_event,
2053 };
2054
2055 static ssize_t
2056 show_phy_type(struct device *dev, struct device_attribute *attr, char *buf)
2057 {
2058         struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));
2059         return sprintf(buf, "%d\n", efx->phy_type);
2060 }
2061 static DEVICE_ATTR(phy_type, 0644, show_phy_type, NULL);
2062
2063 static int efx_register_netdev(struct efx_nic *efx)
2064 {
2065         struct net_device *net_dev = efx->net_dev;
2066         struct efx_channel *channel;
2067         int rc;
2068
2069         net_dev->watchdog_timeo = 5 * HZ;
2070         net_dev->irq = efx->pci_dev->irq;
2071         net_dev->netdev_ops = &efx_netdev_ops;
2072         SET_ETHTOOL_OPS(net_dev, &efx_ethtool_ops);
2073
2074         rtnl_lock();
2075
2076         rc = dev_alloc_name(net_dev, net_dev->name);
2077         if (rc < 0)
2078                 goto fail_locked;
2079         efx_update_name(efx);
2080
2081         rc = register_netdevice(net_dev);
2082         if (rc)
2083                 goto fail_locked;
2084
2085         efx_for_each_channel(channel, efx) {
2086                 struct efx_tx_queue *tx_queue;
2087                 efx_for_each_channel_tx_queue(tx_queue, channel)
2088                         efx_init_tx_queue_core_txq(tx_queue);
2089         }
2090
2091         /* Always start with carrier off; PHY events will detect the link */
2092         netif_carrier_off(net_dev);
2093
2094         rtnl_unlock();
2095
2096         rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_type);
2097         if (rc) {
2098                 netif_err(efx, drv, efx->net_dev,
2099                           "failed to init net dev attributes\n");
2100                 goto fail_registered;
2101         }
2102
2103         return 0;
2104
2105 fail_locked:
2106         rtnl_unlock();
2107         netif_err(efx, drv, efx->net_dev, "could not register net dev\n");
2108         return rc;
2109
2110 fail_registered:
2111         unregister_netdev(net_dev);
2112         return rc;
2113 }
2114
2115 static void efx_unregister_netdev(struct efx_nic *efx)
2116 {
2117         struct efx_channel *channel;
2118         struct efx_tx_queue *tx_queue;
2119
2120         if (!efx->net_dev)
2121                 return;
2122
2123         BUG_ON(netdev_priv(efx->net_dev) != efx);
2124
2125         /* Free up any skbs still remaining. This has to happen before
2126          * we try to unregister the netdev as running their destructors
2127          * may be needed to get the device ref. count to 0. */
2128         efx_for_each_channel(channel, efx) {
2129                 efx_for_each_channel_tx_queue(tx_queue, channel)
2130                         efx_release_tx_buffers(tx_queue);
2131         }
2132
2133         strlcpy(efx->name, pci_name(efx->pci_dev), sizeof(efx->name));
2134         device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type);
2135         unregister_netdev(efx->net_dev);
2136 }
2137
2138 /**************************************************************************
2139  *
2140  * Device reset and suspend
2141  *
2142  **************************************************************************/
2143
2144 /* Tears down the entire software state and most of the hardware state
2145  * before reset.  */
2146 void efx_reset_down(struct efx_nic *efx, enum reset_type method)
2147 {
2148         EFX_ASSERT_RESET_SERIALISED(efx);
2149
2150         efx_stop_all(efx);
2151         mutex_lock(&efx->mac_lock);
2152
2153         efx_stop_interrupts(efx, false);
2154         if (efx->port_initialized && method != RESET_TYPE_INVISIBLE)
2155                 efx->phy_op->fini(efx);
2156         efx->type->fini(efx);
2157 }
2158
2159 /* This function will always ensure that the locks acquired in
2160  * efx_reset_down() are released. A failure return code indicates
2161  * that we were unable to reinitialise the hardware, and the
2162  * driver should be disabled. If ok is false, then the rx and tx
2163  * engines are not restarted, pending a RESET_DISABLE. */
2164 int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
2165 {
2166         int rc;
2167
2168         EFX_ASSERT_RESET_SERIALISED(efx);
2169
2170         rc = efx->type->init(efx);
2171         if (rc) {
2172                 netif_err(efx, drv, efx->net_dev, "failed to initialise NIC\n");
2173                 goto fail;
2174         }
2175
2176         if (!ok)
2177                 goto fail;
2178
2179         if (efx->port_initialized && method != RESET_TYPE_INVISIBLE) {
2180                 rc = efx->phy_op->init(efx);
2181                 if (rc)
2182                         goto fail;
2183                 if (efx->phy_op->reconfigure(efx))
2184                         netif_err(efx, drv, efx->net_dev,
2185                                   "could not restore PHY settings\n");
2186         }
2187
2188         efx->type->reconfigure_mac(efx);
2189
2190         efx_start_interrupts(efx, false);
2191         efx_restore_filters(efx);
2192         efx_sriov_reset(efx);
2193
2194         mutex_unlock(&efx->mac_lock);
2195
2196         efx_start_all(efx);
2197
2198         return 0;
2199
2200 fail:
2201         efx->port_initialized = false;
2202
2203         mutex_unlock(&efx->mac_lock);
2204
2205         return rc;
2206 }
2207
2208 /* Reset the NIC using the specified method.  Note that the reset may
2209  * fail, in which case the card will be left in an unusable state.
2210  *
2211  * Caller must hold the rtnl_lock.
2212  */
2213 int efx_reset(struct efx_nic *efx, enum reset_type method)
2214 {
2215         int rc, rc2;
2216         bool disabled;
2217
2218         netif_info(efx, drv, efx->net_dev, "resetting (%s)\n",
2219                    RESET_TYPE(method));
2220
2221         netif_device_detach(efx->net_dev);
2222         efx_reset_down(efx, method);
2223
2224         rc = efx->type->reset(efx, method);
2225         if (rc) {
2226                 netif_err(efx, drv, efx->net_dev, "failed to reset hardware\n");
2227                 goto out;
2228         }
2229
2230         /* Clear flags for the scopes we covered.  We assume the NIC and
2231          * driver are now quiescent so that there is no race here.
2232          */
2233         efx->reset_pending &= -(1 << (method + 1));
2234
2235         /* Reinitialise bus-mastering, which may have been turned off before
2236          * the reset was scheduled. This is still appropriate, even in the
2237          * RESET_TYPE_DISABLE since this driver generally assumes the hardware
2238          * can respond to requests. */
2239         pci_set_master(efx->pci_dev);
2240
2241 out:
2242         /* Leave device stopped if necessary */
2243         disabled = rc || method == RESET_TYPE_DISABLE;
2244         rc2 = efx_reset_up(efx, method, !disabled);
2245         if (rc2) {
2246                 disabled = true;
2247                 if (!rc)
2248                         rc = rc2;
2249         }
2250
2251         if (disabled) {
2252                 dev_close(efx->net_dev);
2253                 netif_err(efx, drv, efx->net_dev, "has been disabled\n");
2254                 efx->state = STATE_DISABLED;
2255         } else {
2256                 netif_dbg(efx, drv, efx->net_dev, "reset complete\n");
2257                 netif_device_attach(efx->net_dev);
2258         }
2259         return rc;
2260 }
2261
2262 /* The worker thread exists so that code that cannot sleep can
2263  * schedule a reset for later.
2264  */
2265 static void efx_reset_work(struct work_struct *data)
2266 {
2267         struct efx_nic *efx = container_of(data, struct efx_nic, reset_work);
2268         unsigned long pending = ACCESS_ONCE(efx->reset_pending);
2269
2270         if (!pending)
2271                 return;
2272
2273         /* If we're not RUNNING then don't reset. Leave the reset_pending
2274          * flags set so that efx_pci_probe_main will be retried */
2275         if (efx->state != STATE_RUNNING) {
2276                 netif_info(efx, drv, efx->net_dev,
2277                            "scheduled reset quenched. NIC not RUNNING\n");
2278                 return;
2279         }
2280
2281         rtnl_lock();
2282         (void)efx_reset(efx, fls(pending) - 1);
2283         rtnl_unlock();
2284 }
2285
2286 void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
2287 {
2288         enum reset_type method;
2289
2290         switch (type) {
2291         case RESET_TYPE_INVISIBLE:
2292         case RESET_TYPE_ALL:
2293         case RESET_TYPE_WORLD:
2294         case RESET_TYPE_DISABLE:
2295                 method = type;
2296                 netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",
2297                           RESET_TYPE(method));
2298                 break;
2299         default:
2300                 method = efx->type->map_reset_reason(type);
2301                 netif_dbg(efx, drv, efx->net_dev,
2302                           "scheduling %s reset for %s\n",
2303                           RESET_TYPE(method), RESET_TYPE(type));
2304                 break;
2305         }
2306
2307         set_bit(method, &efx->reset_pending);
2308
2309         /* efx_process_channel() will no longer read events once a
2310          * reset is scheduled. So switch back to poll'd MCDI completions. */
2311         efx_mcdi_mode_poll(efx);
2312
2313         queue_work(reset_workqueue, &efx->reset_work);
2314 }
2315
2316 /**************************************************************************
2317  *
2318  * List of NICs we support
2319  *
2320  **************************************************************************/
2321
2322 /* PCI device ID table */
2323 static DEFINE_PCI_DEVICE_TABLE(efx_pci_table) = {
2324         {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE,
2325                     PCI_DEVICE_ID_SOLARFLARE_SFC4000A_0),
2326          .driver_data = (unsigned long) &falcon_a1_nic_type},
2327         {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE,
2328                     PCI_DEVICE_ID_SOLARFLARE_SFC4000B),
2329          .driver_data = (unsigned long) &falcon_b0_nic_type},
2330         {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0803),  /* SFC9020 */
2331          .driver_data = (unsigned long) &siena_a0_nic_type},
2332         {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0813),  /* SFL9021 */
2333          .driver_data = (unsigned long) &siena_a0_nic_type},
2334         {0}                     /* end of list */
2335 };
2336
2337 /**************************************************************************
2338  *
2339  * Dummy PHY/MAC operations
2340  *
2341  * Can be used for some unimplemented operations
2342  * Needed so all function pointers are valid and do not have to be tested
2343  * before use
2344  *
2345  **************************************************************************/
2346 int efx_port_dummy_op_int(struct efx_nic *efx)
2347 {
2348         return 0;
2349 }
2350 void efx_port_dummy_op_void(struct efx_nic *efx) {}
2351
2352 static bool efx_port_dummy_op_poll(struct efx_nic *efx)
2353 {
2354         return false;
2355 }
2356
2357 static const struct efx_phy_operations efx_dummy_phy_operations = {
2358         .init            = efx_port_dummy_op_int,
2359         .reconfigure     = efx_port_dummy_op_int,
2360         .poll            = efx_port_dummy_op_poll,
2361         .fini            = efx_port_dummy_op_void,
2362 };
2363
2364 /**************************************************************************
2365  *
2366  * Data housekeeping
2367  *
2368  **************************************************************************/
2369
2370 /* This zeroes out and then fills in the invariants in a struct
2371  * efx_nic (including all sub-structures).
2372  */
2373 static int efx_init_struct(struct efx_nic *efx, const struct efx_nic_type *type,
2374                            struct pci_dev *pci_dev, struct net_device *net_dev)
2375 {
2376         int i;
2377
2378         /* Initialise common structures */
2379         memset(efx, 0, sizeof(*efx));
2380         spin_lock_init(&efx->biu_lock);
2381 #ifdef CONFIG_SFC_MTD
2382         INIT_LIST_HEAD(&efx->mtd_list);
2383 #endif
2384         INIT_WORK(&efx->reset_work, efx_reset_work);
2385         INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);
2386         INIT_DELAYED_WORK(&efx->selftest_work, efx_selftest_async_work);
2387         efx->pci_dev = pci_dev;
2388         efx->msg_enable = debug;
2389         efx->state = STATE_INIT;
2390         strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
2391
2392         efx->net_dev = net_dev;
2393         spin_lock_init(&efx->stats_lock);
2394         mutex_init(&efx->mac_lock);
2395         efx->phy_op = &efx_dummy_phy_operations;
2396         efx->mdio.dev = net_dev;
2397         INIT_WORK(&efx->mac_work, efx_mac_work);
2398         init_waitqueue_head(&efx->flush_wq);
2399
2400         for (i = 0; i < EFX_MAX_CHANNELS; i++) {
2401                 efx->channel[i] = efx_alloc_channel(efx, i, NULL);
2402                 if (!efx->channel[i])
2403                         goto fail;
2404         }
2405
2406         efx->type = type;
2407
2408         EFX_BUG_ON_PARANOID(efx->type->phys_addr_channels > EFX_MAX_CHANNELS);
2409
2410         /* Higher numbered interrupt modes are less capable! */
2411         efx->interrupt_mode = max(efx->type->max_interrupt_mode,
2412                                   interrupt_mode);
2413
2414         /* Would be good to use the net_dev name, but we're too early */
2415         snprintf(efx->workqueue_name, sizeof(efx->workqueue_name), "sfc%s",
2416                  pci_name(pci_dev));
2417         efx->workqueue = create_singlethread_workqueue(efx->workqueue_name);
2418         if (!efx->workqueue)
2419                 goto fail;
2420
2421         return 0;
2422
2423 fail:
2424         efx_fini_struct(efx);
2425         return -ENOMEM;
2426 }
2427
2428 static void efx_fini_struct(struct efx_nic *efx)
2429 {
2430         int i;
2431
2432         for (i = 0; i < EFX_MAX_CHANNELS; i++)
2433                 kfree(efx->channel[i]);
2434
2435         if (efx->workqueue) {
2436                 destroy_workqueue(efx->workqueue);
2437                 efx->workqueue = NULL;
2438         }
2439 }
2440
2441 /**************************************************************************
2442  *
2443  * PCI interface
2444  *
2445  **************************************************************************/
2446
2447 /* Main body of final NIC shutdown code
2448  * This is called only at module unload (or hotplug removal).
2449  */
2450 static void efx_pci_remove_main(struct efx_nic *efx)
2451 {
2452 #ifdef CONFIG_RFS_ACCEL
2453         free_irq_cpu_rmap(efx->net_dev->rx_cpu_rmap);
2454         efx->net_dev->rx_cpu_rmap = NULL;
2455 #endif
2456         efx_stop_interrupts(efx, false);
2457         efx_nic_fini_interrupt(efx);
2458         efx_fini_port(efx);
2459         efx->type->fini(efx);
2460         efx_fini_napi(efx);
2461         efx_remove_all(efx);
2462 }
2463
2464 /* Final NIC shutdown
2465  * This is called only at module unload (or hotplug removal).
2466  */
2467 static void efx_pci_remove(struct pci_dev *pci_dev)
2468 {
2469         struct efx_nic *efx;
2470
2471         efx = pci_get_drvdata(pci_dev);
2472         if (!efx)
2473                 return;
2474
2475         /* Mark the NIC as fini, then stop the interface */
2476         rtnl_lock();
2477         efx->state = STATE_FINI;
2478         dev_close(efx->net_dev);
2479
2480         /* Allow any queued efx_resets() to complete */
2481         rtnl_unlock();
2482
2483         efx_stop_interrupts(efx, false);
2484         efx_sriov_fini(efx);
2485         efx_unregister_netdev(efx);
2486
2487         efx_mtd_remove(efx);
2488
2489         /* Wait for any scheduled resets to complete. No more will be
2490          * scheduled from this point because efx_stop_all() has been
2491          * called, we are no longer registered with driverlink, and
2492          * the net_device's have been removed. */
2493         cancel_work_sync(&efx->reset_work);
2494
2495         efx_pci_remove_main(efx);
2496
2497         efx_fini_io(efx);
2498         netif_dbg(efx, drv, efx->net_dev, "shutdown successful\n");
2499
2500         pci_set_drvdata(pci_dev, NULL);
2501         efx_fini_struct(efx);
2502         free_netdev(efx->net_dev);
2503 };
2504
2505 /* NIC VPD information
2506  * Called during probe to display the part number of the
2507  * installed NIC.  VPD is potentially very large but this should
2508  * always appear within the first 512 bytes.
2509  */
2510 #define SFC_VPD_LEN 512
2511 static void efx_print_product_vpd(struct efx_nic *efx)
2512 {
2513         struct pci_dev *dev = efx->pci_dev;
2514         char vpd_data[SFC_VPD_LEN];
2515         ssize_t vpd_size;
2516         int i, j;
2517
2518         /* Get the vpd data from the device */
2519         vpd_size = pci_read_vpd(dev, 0, sizeof(vpd_data), vpd_data);
2520         if (vpd_size <= 0) {
2521                 netif_err(efx, drv, efx->net_dev, "Unable to read VPD\n");
2522                 return;
2523         }
2524
2525         /* Get the Read only section */
2526         i = pci_vpd_find_tag(vpd_data, 0, vpd_size, PCI_VPD_LRDT_RO_DATA);
2527         if (i < 0) {
2528                 netif_err(efx, drv, efx->net_dev, "VPD Read-only not found\n");
2529                 return;
2530         }
2531
2532         j = pci_vpd_lrdt_size(&vpd_data[i]);
2533         i += PCI_VPD_LRDT_TAG_SIZE;
2534         if (i + j > vpd_size)
2535                 j = vpd_size - i;
2536
2537         /* Get the Part number */
2538         i = pci_vpd_find_info_keyword(vpd_data, i, j, "PN");
2539         if (i < 0) {
2540                 netif_err(efx, drv, efx->net_dev, "Part number not found\n");
2541                 return;
2542         }
2543
2544         j = pci_vpd_info_field_size(&vpd_data[i]);
2545         i += PCI_VPD_INFO_FLD_HDR_SIZE;
2546         if (i + j > vpd_size) {
2547                 netif_err(efx, drv, efx->net_dev, "Incomplete part number\n");
2548                 return;
2549         }
2550
2551         netif_info(efx, drv, efx->net_dev,
2552                    "Part Number : %.*s\n", j, &vpd_data[i]);
2553 }
2554
2555
2556 /* Main body of NIC initialisation
2557  * This is called at module load (or hotplug insertion, theoretically).
2558  */
2559 static int efx_pci_probe_main(struct efx_nic *efx)
2560 {
2561         int rc;
2562
2563         /* Do start-of-day initialisation */
2564         rc = efx_probe_all(efx);
2565         if (rc)
2566                 goto fail1;
2567
2568         efx_init_napi(efx);
2569
2570         rc = efx->type->init(efx);
2571         if (rc) {
2572                 netif_err(efx, probe, efx->net_dev,
2573                           "failed to initialise NIC\n");
2574                 goto fail3;
2575         }
2576
2577         rc = efx_init_port(efx);
2578         if (rc) {
2579                 netif_err(efx, probe, efx->net_dev,
2580                           "failed to initialise port\n");
2581                 goto fail4;
2582         }
2583
2584         rc = efx_nic_init_interrupt(efx);
2585         if (rc)
2586                 goto fail5;
2587         efx_start_interrupts(efx, false);
2588
2589         return 0;
2590
2591  fail5:
2592         efx_fini_port(efx);
2593  fail4:
2594         efx->type->fini(efx);
2595  fail3:
2596         efx_fini_napi(efx);
2597         efx_remove_all(efx);
2598  fail1:
2599         return rc;
2600 }
2601
2602 /* NIC initialisation
2603  *
2604  * This is called at module load (or hotplug insertion,
2605  * theoretically).  It sets up PCI mappings, resets the NIC,
2606  * sets up and registers the network devices with the kernel and hooks
2607  * the interrupt service routine.  It does not prepare the device for
2608  * transmission; this is left to the first time one of the network
2609  * interfaces is brought up (i.e. efx_net_open).
2610  */
2611 static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
2612                                    const struct pci_device_id *entry)
2613 {
2614         const struct efx_nic_type *type = (const struct efx_nic_type *) entry->driver_data;
2615         struct net_device *net_dev;
2616         struct efx_nic *efx;
2617         int rc;
2618
2619         /* Allocate and initialise a struct net_device and struct efx_nic */
2620         net_dev = alloc_etherdev_mqs(sizeof(*efx), EFX_MAX_CORE_TX_QUEUES,
2621                                      EFX_MAX_RX_QUEUES);
2622         if (!net_dev)
2623                 return -ENOMEM;
2624         net_dev->features |= (type->offload_features | NETIF_F_SG |
2625                               NETIF_F_HIGHDMA | NETIF_F_TSO |
2626                               NETIF_F_RXCSUM);
2627         if (type->offload_features & NETIF_F_V6_CSUM)
2628                 net_dev->features |= NETIF_F_TSO6;
2629         /* Mask for features that also apply to VLAN devices */
2630         net_dev->vlan_features |= (NETIF_F_ALL_CSUM | NETIF_F_SG |
2631                                    NETIF_F_HIGHDMA | NETIF_F_ALL_TSO |
2632                                    NETIF_F_RXCSUM);
2633         /* All offloads can be toggled */
2634         net_dev->hw_features = net_dev->features & ~NETIF_F_HIGHDMA;
2635         efx = netdev_priv(net_dev);
2636         pci_set_drvdata(pci_dev, efx);
2637         SET_NETDEV_DEV(net_dev, &pci_dev->dev);
2638         rc = efx_init_struct(efx, type, pci_dev, net_dev);
2639         if (rc)
2640                 goto fail1;
2641
2642         netif_info(efx, probe, efx->net_dev,
2643                    "Solarflare NIC detected\n");
2644
2645         efx_print_product_vpd(efx);
2646
2647         /* Set up basic I/O (BAR mappings etc) */
2648         rc = efx_init_io(efx);
2649         if (rc)
2650                 goto fail2;
2651
2652         rc = efx_pci_probe_main(efx);
2653
2654         /* Serialise against efx_reset(). No more resets will be
2655          * scheduled since efx_stop_all() has been called, and we have
2656          * not and never have been registered.
2657          */
2658         cancel_work_sync(&efx->reset_work);
2659
2660         if (rc)
2661                 goto fail3;
2662
2663         /* If there was a scheduled reset during probe, the NIC is
2664          * probably hosed anyway.
2665          */
2666         if (efx->reset_pending) {
2667                 rc = -EIO;
2668                 goto fail4;
2669         }
2670
2671         /* Switch to the running state before we expose the device to the OS,
2672          * so that dev_open()|efx_start_all() will actually start the device */
2673         efx->state = STATE_RUNNING;
2674
2675         rc = efx_register_netdev(efx);
2676         if (rc)
2677                 goto fail4;
2678
2679         rc = efx_sriov_init(efx);
2680         if (rc)
2681                 netif_err(efx, probe, efx->net_dev,
2682                           "SR-IOV can't be enabled rc %d\n", rc);
2683
2684         netif_dbg(efx, probe, efx->net_dev, "initialisation successful\n");
2685
2686         /* Try to create MTDs, but allow this to fail */
2687         rtnl_lock();
2688         rc = efx_mtd_probe(efx);
2689         rtnl_unlock();
2690         if (rc)
2691                 netif_warn(efx, probe, efx->net_dev,
2692                            "failed to create MTDs (%d)\n", rc);
2693
2694         return 0;
2695
2696  fail4:
2697         efx_pci_remove_main(efx);
2698  fail3:
2699         efx_fini_io(efx);
2700  fail2:
2701         efx_fini_struct(efx);
2702  fail1:
2703         WARN_ON(rc > 0);
2704         netif_dbg(efx, drv, efx->net_dev, "initialisation failed. rc=%d\n", rc);
2705         free_netdev(net_dev);
2706         return rc;
2707 }
2708
2709 static int efx_pm_freeze(struct device *dev)
2710 {
2711         struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));
2712
2713         efx->state = STATE_FINI;
2714
2715         netif_device_detach(efx->net_dev);
2716
2717         efx_stop_all(efx);
2718         efx_stop_interrupts(efx, false);
2719
2720         return 0;
2721 }
2722
2723 static int efx_pm_thaw(struct device *dev)
2724 {
2725         struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));
2726
2727         efx->state = STATE_INIT;
2728
2729         efx_start_interrupts(efx, false);
2730
2731         mutex_lock(&efx->mac_lock);
2732         efx->phy_op->reconfigure(efx);
2733         mutex_unlock(&efx->mac_lock);
2734
2735         efx_start_all(efx);
2736
2737         netif_device_attach(efx->net_dev);
2738
2739         efx->state = STATE_RUNNING;
2740
2741         efx->type->resume_wol(efx);
2742
2743         /* Reschedule any quenched resets scheduled during efx_pm_freeze() */
2744         queue_work(reset_workqueue, &efx->reset_work);
2745
2746         return 0;
2747 }
2748
2749 static int efx_pm_poweroff(struct device *dev)
2750 {
2751         struct pci_dev *pci_dev = to_pci_dev(dev);
2752         struct efx_nic *efx = pci_get_drvdata(pci_dev);
2753
2754         efx->type->fini(efx);
2755
2756         efx->reset_pending = 0;
2757
2758         pci_save_state(pci_dev);
2759         return pci_set_power_state(pci_dev, PCI_D3hot);
2760 }
2761
2762 /* Used for both resume and restore */
2763 static int efx_pm_resume(struct device *dev)
2764 {
2765         struct pci_dev *pci_dev = to_pci_dev(dev);
2766         struct efx_nic *efx = pci_get_drvdata(pci_dev);
2767         int rc;
2768
2769         rc = pci_set_power_state(pci_dev, PCI_D0);
2770         if (rc)
2771                 return rc;
2772         pci_restore_state(pci_dev);
2773         rc = pci_enable_device(pci_dev);
2774         if (rc)
2775                 return rc;
2776         pci_set_master(efx->pci_dev);
2777         rc = efx->type->reset(efx, RESET_TYPE_ALL);
2778         if (rc)
2779                 return rc;
2780         rc = efx->type->init(efx);
2781         if (rc)
2782                 return rc;
2783         efx_pm_thaw(dev);
2784         return 0;
2785 }
2786
2787 static int efx_pm_suspend(struct device *dev)
2788 {
2789         int rc;
2790
2791         efx_pm_freeze(dev);
2792         rc = efx_pm_poweroff(dev);
2793         if (rc)
2794                 efx_pm_resume(dev);
2795         return rc;
2796 }
2797
2798 static const struct dev_pm_ops efx_pm_ops = {
2799         .suspend        = efx_pm_suspend,
2800         .resume         = efx_pm_resume,
2801         .freeze         = efx_pm_freeze,
2802         .thaw           = efx_pm_thaw,
2803         .poweroff       = efx_pm_poweroff,
2804         .restore        = efx_pm_resume,
2805 };
2806
2807 static struct pci_driver efx_pci_driver = {
2808         .name           = KBUILD_MODNAME,
2809         .id_table       = efx_pci_table,
2810         .probe          = efx_pci_probe,
2811         .remove         = efx_pci_remove,
2812         .driver.pm      = &efx_pm_ops,
2813 };
2814
2815 /**************************************************************************
2816  *
2817  * Kernel module interface
2818  *
2819  *************************************************************************/
2820
2821 module_param(interrupt_mode, uint, 0444);
2822 MODULE_PARM_DESC(interrupt_mode,
2823                  "Interrupt mode (0=>MSIX 1=>MSI 2=>legacy)");
2824
2825 static int __init efx_init_module(void)
2826 {
2827         int rc;
2828
2829         printk(KERN_INFO "Solarflare NET driver v" EFX_DRIVER_VERSION "\n");
2830
2831         rc = register_netdevice_notifier(&efx_netdev_notifier);
2832         if (rc)
2833                 goto err_notifier;
2834
2835         rc = efx_init_sriov();
2836         if (rc)
2837                 goto err_sriov;
2838
2839         reset_workqueue = create_singlethread_workqueue("sfc_reset");
2840         if (!reset_workqueue) {
2841                 rc = -ENOMEM;
2842                 goto err_reset;
2843         }
2844
2845         rc = pci_register_driver(&efx_pci_driver);
2846         if (rc < 0)
2847                 goto err_pci;
2848
2849         return 0;
2850
2851  err_pci:
2852         destroy_workqueue(reset_workqueue);
2853  err_reset:
2854         efx_fini_sriov();
2855  err_sriov:
2856         unregister_netdevice_notifier(&efx_netdev_notifier);
2857  err_notifier:
2858         return rc;
2859 }
2860
2861 static void __exit efx_exit_module(void)
2862 {
2863         printk(KERN_INFO "Solarflare NET driver unloading\n");
2864
2865         pci_unregister_driver(&efx_pci_driver);
2866         destroy_workqueue(reset_workqueue);
2867         efx_fini_sriov();
2868         unregister_netdevice_notifier(&efx_netdev_notifier);
2869
2870 }
2871
2872 module_init(efx_init_module);
2873 module_exit(efx_exit_module);
2874
2875 MODULE_AUTHOR("Solarflare Communications and "
2876               "Michael Brown <mbrown@fensystems.co.uk>");
2877 MODULE_DESCRIPTION("Solarflare Communications network driver");
2878 MODULE_LICENSE("GPL");
2879 MODULE_DEVICE_TABLE(pci, efx_pci_table);