1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2874aeea5SJeff Kirsher /**************************************************************************** 3f7a6d2c4SBen Hutchings * Driver for Solarflare network controllers and boards 4874aeea5SJeff Kirsher * Copyright 2005-2006 Fen Systems Ltd. 5f7a6d2c4SBen Hutchings * Copyright 2005-2013 Solarflare Communications Inc. 6874aeea5SJeff Kirsher */ 7874aeea5SJeff Kirsher 8874aeea5SJeff Kirsher #include <linux/module.h> 9874aeea5SJeff Kirsher #include <linux/pci.h> 10874aeea5SJeff Kirsher #include <linux/netdevice.h> 11874aeea5SJeff Kirsher #include <linux/etherdevice.h> 12874aeea5SJeff Kirsher #include <linux/delay.h> 13874aeea5SJeff Kirsher #include <linux/notifier.h> 14874aeea5SJeff Kirsher #include <linux/ip.h> 15874aeea5SJeff Kirsher #include <linux/tcp.h> 16874aeea5SJeff Kirsher #include <linux/in.h> 17874aeea5SJeff Kirsher #include <linux/ethtool.h> 18874aeea5SJeff Kirsher #include <linux/topology.h> 19874aeea5SJeff Kirsher #include <linux/gfp.h> 20626950dbSAlexandre Rames #include <linux/aer.h> 21b28405b0SAlexandre Rames #include <linux/interrupt.h> 22874aeea5SJeff Kirsher #include "net_driver.h" 23e5fbd977SJon Cooper #include <net/gre.h> 24e5fbd977SJon Cooper #include <net/udp_tunnel.h> 25874aeea5SJeff Kirsher #include "efx.h" 26e1253f39SAlex Maftei (amaftei) #include "efx_common.h" 27e1253f39SAlex Maftei (amaftei) #include "efx_channels.h" 2851b35a45SEdward Cree #include "ef100.h" 29e1253f39SAlex Maftei (amaftei) #include "rx_common.h" 30e1253f39SAlex Maftei (amaftei) #include "tx_common.h" 31874aeea5SJeff Kirsher #include "nic.h" 3271827443SEdward Cree #include "io.h" 33dd40781eSBen Hutchings #include "selftest.h" 347fa8d547SShradha Shah #include "sriov.h" 35874aeea5SJeff Kirsher 36c77289b4SEdward Cree #include "mcdi_port_common.h" 37e5fbd977SJon Cooper #include "mcdi_pcol.h" 38874aeea5SJeff Kirsher #include "workarounds.h" 39874aeea5SJeff Kirsher 40874aeea5SJeff Kirsher /************************************************************************** 41874aeea5SJeff Kirsher * 42874aeea5SJeff Kirsher * Configurable values 43874aeea5SJeff Kirsher * 44874aeea5SJeff Kirsher *************************************************************************/ 45874aeea5SJeff Kirsher 46e4ff3232SEdward Cree module_param_named(interrupt_mode, efx_interrupt_mode, uint, 0444); 47e4ff3232SEdward Cree MODULE_PARM_DESC(interrupt_mode, 48e4ff3232SEdward Cree "Interrupt mode (0=>MSIX 1=>MSI 2=>legacy)"); 49e4ff3232SEdward Cree 5067e6398eSEdward Cree module_param(rss_cpus, uint, 0444); 5167e6398eSEdward Cree MODULE_PARM_DESC(rss_cpus, "Number of CPUs to use for Receive-Side Scaling"); 5267e6398eSEdward Cree 53874aeea5SJeff Kirsher /* 54874aeea5SJeff Kirsher * Use separate channels for TX and RX events 55874aeea5SJeff Kirsher * 56874aeea5SJeff Kirsher * Set this to 1 to use separate channels for TX and RX. It allows us 57874aeea5SJeff Kirsher * to control interrupt affinity separately for TX and RX. 58874aeea5SJeff Kirsher * 59874aeea5SJeff Kirsher * This is only used in MSI-X interrupt mode 60874aeea5SJeff Kirsher */ 61b0fbdae1SShradha Shah bool efx_separate_tx_channels; 62b0fbdae1SShradha Shah module_param(efx_separate_tx_channels, bool, 0444); 63b0fbdae1SShradha Shah MODULE_PARM_DESC(efx_separate_tx_channels, 64874aeea5SJeff Kirsher "Use separate channels for TX and RX"); 65874aeea5SJeff Kirsher 66874aeea5SJeff Kirsher /* Initial interrupt moderation settings. They can be modified after 67874aeea5SJeff Kirsher * module load with ethtool. 68874aeea5SJeff Kirsher * 69874aeea5SJeff Kirsher * The default for RX should strike a balance between increasing the 70874aeea5SJeff Kirsher * round-trip latency and reducing overhead. 71874aeea5SJeff Kirsher */ 72874aeea5SJeff Kirsher static unsigned int rx_irq_mod_usec = 60; 73874aeea5SJeff Kirsher 74874aeea5SJeff Kirsher /* Initial interrupt moderation settings. They can be modified after 75874aeea5SJeff Kirsher * module load with ethtool. 76874aeea5SJeff Kirsher * 77874aeea5SJeff Kirsher * This default is chosen to ensure that a 10G link does not go idle 78874aeea5SJeff Kirsher * while a TX queue is stopped after it has become full. A queue is 79874aeea5SJeff Kirsher * restarted when it drops below half full. The time this takes (assuming 80874aeea5SJeff Kirsher * worst case 3 descriptors per packet and 1024 descriptors) is 81874aeea5SJeff Kirsher * 512 / 3 * 1.2 = 205 usec. 82874aeea5SJeff Kirsher */ 83874aeea5SJeff Kirsher static unsigned int tx_irq_mod_usec = 150; 84874aeea5SJeff Kirsher 85b9cc977dSBen Hutchings static bool phy_flash_cfg; 86b9cc977dSBen Hutchings module_param(phy_flash_cfg, bool, 0644); 87874aeea5SJeff Kirsher MODULE_PARM_DESC(phy_flash_cfg, "Set PHYs into reflash mode initially"); 88874aeea5SJeff Kirsher 89874aeea5SJeff Kirsher static unsigned debug = (NETIF_MSG_DRV | NETIF_MSG_PROBE | 90874aeea5SJeff Kirsher NETIF_MSG_LINK | NETIF_MSG_IFDOWN | 91874aeea5SJeff Kirsher NETIF_MSG_IFUP | NETIF_MSG_RX_ERR | 92874aeea5SJeff Kirsher NETIF_MSG_TX_ERR | NETIF_MSG_HW); 93874aeea5SJeff Kirsher module_param(debug, uint, 0); 94874aeea5SJeff Kirsher MODULE_PARM_DESC(debug, "Bitmapped debugging message enable value"); 95874aeea5SJeff Kirsher 96874aeea5SJeff Kirsher /************************************************************************** 97874aeea5SJeff Kirsher * 98874aeea5SJeff Kirsher * Utility functions and prototypes 99874aeea5SJeff Kirsher * 100874aeea5SJeff Kirsher *************************************************************************/ 101874aeea5SJeff Kirsher 102874aeea5SJeff Kirsher static void efx_remove_port(struct efx_nic *efx); 103e45a4fedSCharles McLachlan static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog); 104e45a4fedSCharles McLachlan static int efx_xdp(struct net_device *dev, struct netdev_bpf *xdp); 105dfe44c1fSCharles McLachlan static int efx_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **xdpfs, 106dfe44c1fSCharles McLachlan u32 flags); 107874aeea5SJeff Kirsher 108874aeea5SJeff Kirsher #define EFX_ASSERT_RESET_SERIALISED(efx) \ 109874aeea5SJeff Kirsher do { \ 110f16aeea0SBen Hutchings if ((efx->state == STATE_READY) || \ 111626950dbSAlexandre Rames (efx->state == STATE_RECOVERY) || \ 112874aeea5SJeff Kirsher (efx->state == STATE_DISABLED)) \ 113874aeea5SJeff Kirsher ASSERT_RTNL(); \ 114874aeea5SJeff Kirsher } while (0) 115874aeea5SJeff Kirsher 116874aeea5SJeff Kirsher /************************************************************************** 117874aeea5SJeff Kirsher * 118874aeea5SJeff Kirsher * Port handling 119874aeea5SJeff Kirsher * 120874aeea5SJeff Kirsher **************************************************************************/ 121874aeea5SJeff Kirsher 122874aeea5SJeff Kirsher static void efx_fini_port(struct efx_nic *efx); 123874aeea5SJeff Kirsher 124874aeea5SJeff Kirsher static int efx_probe_port(struct efx_nic *efx) 125874aeea5SJeff Kirsher { 126874aeea5SJeff Kirsher int rc; 127874aeea5SJeff Kirsher 128874aeea5SJeff Kirsher netif_dbg(efx, probe, efx->net_dev, "create port\n"); 129874aeea5SJeff Kirsher 130874aeea5SJeff Kirsher if (phy_flash_cfg) 131874aeea5SJeff Kirsher efx->phy_mode = PHY_MODE_SPECIAL; 132874aeea5SJeff Kirsher 133874aeea5SJeff Kirsher /* Connect up MAC/PHY operations table */ 134874aeea5SJeff Kirsher rc = efx->type->probe_port(efx); 135874aeea5SJeff Kirsher if (rc) 136874aeea5SJeff Kirsher return rc; 137874aeea5SJeff Kirsher 138e332bcb3SBen Hutchings /* Initialise MAC address to permanent address */ 139cd84ff4dSEdward Cree ether_addr_copy(efx->net_dev->dev_addr, efx->net_dev->perm_addr); 140874aeea5SJeff Kirsher 141874aeea5SJeff Kirsher return 0; 142874aeea5SJeff Kirsher } 143874aeea5SJeff Kirsher 144874aeea5SJeff Kirsher static int efx_init_port(struct efx_nic *efx) 145874aeea5SJeff Kirsher { 146874aeea5SJeff Kirsher int rc; 147874aeea5SJeff Kirsher 148874aeea5SJeff Kirsher netif_dbg(efx, drv, efx->net_dev, "init port\n"); 149874aeea5SJeff Kirsher 150874aeea5SJeff Kirsher mutex_lock(&efx->mac_lock); 151874aeea5SJeff Kirsher 152874aeea5SJeff Kirsher efx->port_initialized = true; 153874aeea5SJeff Kirsher 154874aeea5SJeff Kirsher /* Ensure the PHY advertises the correct flow control settings */ 155c77289b4SEdward Cree rc = efx_mcdi_port_reconfigure(efx); 156267d9d73SEdward Cree if (rc && rc != -EPERM) 157c77289b4SEdward Cree goto fail; 158874aeea5SJeff Kirsher 159874aeea5SJeff Kirsher mutex_unlock(&efx->mac_lock); 160874aeea5SJeff Kirsher return 0; 161874aeea5SJeff Kirsher 162c77289b4SEdward Cree fail: 163874aeea5SJeff Kirsher mutex_unlock(&efx->mac_lock); 164874aeea5SJeff Kirsher return rc; 165874aeea5SJeff Kirsher } 166874aeea5SJeff Kirsher 167874aeea5SJeff Kirsher static void efx_fini_port(struct efx_nic *efx) 168874aeea5SJeff Kirsher { 169874aeea5SJeff Kirsher netif_dbg(efx, drv, efx->net_dev, "shut down port\n"); 170874aeea5SJeff Kirsher 171874aeea5SJeff Kirsher if (!efx->port_initialized) 172874aeea5SJeff Kirsher return; 173874aeea5SJeff Kirsher 174874aeea5SJeff Kirsher efx->port_initialized = false; 175874aeea5SJeff Kirsher 176874aeea5SJeff Kirsher efx->link_state.up = false; 177874aeea5SJeff Kirsher efx_link_status_changed(efx); 178874aeea5SJeff Kirsher } 179874aeea5SJeff Kirsher 180874aeea5SJeff Kirsher static void efx_remove_port(struct efx_nic *efx) 181874aeea5SJeff Kirsher { 182874aeea5SJeff Kirsher netif_dbg(efx, drv, efx->net_dev, "destroying port\n"); 183874aeea5SJeff Kirsher 184874aeea5SJeff Kirsher efx->type->remove_port(efx); 185874aeea5SJeff Kirsher } 186874aeea5SJeff Kirsher 187874aeea5SJeff Kirsher /************************************************************************** 188874aeea5SJeff Kirsher * 189874aeea5SJeff Kirsher * NIC handling 190874aeea5SJeff Kirsher * 191874aeea5SJeff Kirsher **************************************************************************/ 192874aeea5SJeff Kirsher 1930bcf4a64SBen Hutchings static LIST_HEAD(efx_primary_list); 1940bcf4a64SBen Hutchings static LIST_HEAD(efx_unassociated_list); 1950bcf4a64SBen Hutchings 1960bcf4a64SBen Hutchings static bool efx_same_controller(struct efx_nic *left, struct efx_nic *right) 1970bcf4a64SBen Hutchings { 1980bcf4a64SBen Hutchings return left->type == right->type && 1990bcf4a64SBen Hutchings left->vpd_sn && right->vpd_sn && 2000bcf4a64SBen Hutchings !strcmp(left->vpd_sn, right->vpd_sn); 2010bcf4a64SBen Hutchings } 2020bcf4a64SBen Hutchings 2030bcf4a64SBen Hutchings static void efx_associate(struct efx_nic *efx) 2040bcf4a64SBen Hutchings { 2050bcf4a64SBen Hutchings struct efx_nic *other, *next; 2060bcf4a64SBen Hutchings 2070bcf4a64SBen Hutchings if (efx->primary == efx) { 2080bcf4a64SBen Hutchings /* Adding primary function; look for secondaries */ 2090bcf4a64SBen Hutchings 2100bcf4a64SBen Hutchings netif_dbg(efx, probe, efx->net_dev, "adding to primary list\n"); 2110bcf4a64SBen Hutchings list_add_tail(&efx->node, &efx_primary_list); 2120bcf4a64SBen Hutchings 2130bcf4a64SBen Hutchings list_for_each_entry_safe(other, next, &efx_unassociated_list, 2140bcf4a64SBen Hutchings node) { 2150bcf4a64SBen Hutchings if (efx_same_controller(efx, other)) { 2160bcf4a64SBen Hutchings list_del(&other->node); 2170bcf4a64SBen Hutchings netif_dbg(other, probe, other->net_dev, 2180bcf4a64SBen Hutchings "moving to secondary list of %s %s\n", 2190bcf4a64SBen Hutchings pci_name(efx->pci_dev), 2200bcf4a64SBen Hutchings efx->net_dev->name); 2210bcf4a64SBen Hutchings list_add_tail(&other->node, 2220bcf4a64SBen Hutchings &efx->secondary_list); 2230bcf4a64SBen Hutchings other->primary = efx; 2240bcf4a64SBen Hutchings } 2250bcf4a64SBen Hutchings } 2260bcf4a64SBen Hutchings } else { 2270bcf4a64SBen Hutchings /* Adding secondary function; look for primary */ 2280bcf4a64SBen Hutchings 2290bcf4a64SBen Hutchings list_for_each_entry(other, &efx_primary_list, node) { 2300bcf4a64SBen Hutchings if (efx_same_controller(efx, other)) { 2310bcf4a64SBen Hutchings netif_dbg(efx, probe, efx->net_dev, 2320bcf4a64SBen Hutchings "adding to secondary list of %s %s\n", 2330bcf4a64SBen Hutchings pci_name(other->pci_dev), 2340bcf4a64SBen Hutchings other->net_dev->name); 2350bcf4a64SBen Hutchings list_add_tail(&efx->node, 2360bcf4a64SBen Hutchings &other->secondary_list); 2370bcf4a64SBen Hutchings efx->primary = other; 2380bcf4a64SBen Hutchings return; 2390bcf4a64SBen Hutchings } 2400bcf4a64SBen Hutchings } 2410bcf4a64SBen Hutchings 2420bcf4a64SBen Hutchings netif_dbg(efx, probe, efx->net_dev, 2430bcf4a64SBen Hutchings "adding to unassociated list\n"); 2440bcf4a64SBen Hutchings list_add_tail(&efx->node, &efx_unassociated_list); 2450bcf4a64SBen Hutchings } 2460bcf4a64SBen Hutchings } 2470bcf4a64SBen Hutchings 2480bcf4a64SBen Hutchings static void efx_dissociate(struct efx_nic *efx) 2490bcf4a64SBen Hutchings { 2500bcf4a64SBen Hutchings struct efx_nic *other, *next; 2510bcf4a64SBen Hutchings 2520bcf4a64SBen Hutchings list_del(&efx->node); 2530bcf4a64SBen Hutchings efx->primary = NULL; 2540bcf4a64SBen Hutchings 2550bcf4a64SBen Hutchings list_for_each_entry_safe(other, next, &efx->secondary_list, node) { 2560bcf4a64SBen Hutchings list_del(&other->node); 2570bcf4a64SBen Hutchings netif_dbg(other, probe, other->net_dev, 2580bcf4a64SBen Hutchings "moving to unassociated list\n"); 2590bcf4a64SBen Hutchings list_add_tail(&other->node, &efx_unassociated_list); 2600bcf4a64SBen Hutchings other->primary = NULL; 2610bcf4a64SBen Hutchings } 2620bcf4a64SBen Hutchings } 2630bcf4a64SBen Hutchings 264874aeea5SJeff Kirsher static int efx_probe_nic(struct efx_nic *efx) 265874aeea5SJeff Kirsher { 266874aeea5SJeff Kirsher int rc; 267874aeea5SJeff Kirsher 268874aeea5SJeff Kirsher netif_dbg(efx, probe, efx->net_dev, "creating NIC\n"); 269874aeea5SJeff Kirsher 270874aeea5SJeff Kirsher /* Carry out hardware-type specific initialisation */ 271874aeea5SJeff Kirsher rc = efx->type->probe(efx); 272874aeea5SJeff Kirsher if (rc) 273874aeea5SJeff Kirsher return rc; 274874aeea5SJeff Kirsher 275b0fbdae1SShradha Shah do { 276b0fbdae1SShradha Shah if (!efx->max_channels || !efx->max_tx_channels) { 277b0fbdae1SShradha Shah netif_err(efx, drv, efx->net_dev, 278b0fbdae1SShradha Shah "Insufficient resources to allocate" 279b0fbdae1SShradha Shah " any channels\n"); 280b0fbdae1SShradha Shah rc = -ENOSPC; 281b0fbdae1SShradha Shah goto fail1; 282b0fbdae1SShradha Shah } 283b0fbdae1SShradha Shah 284b0fbdae1SShradha Shah /* Determine the number of channels and queues by trying 285b0fbdae1SShradha Shah * to hook in MSI-X interrupts. 286b0fbdae1SShradha Shah */ 287874aeea5SJeff Kirsher rc = efx_probe_interrupts(efx); 288874aeea5SJeff Kirsher if (rc) 289c15eed22SBen Hutchings goto fail1; 290874aeea5SJeff Kirsher 2913990a8ffSCharles McLachlan rc = efx_set_channels(efx); 2923990a8ffSCharles McLachlan if (rc) 2933990a8ffSCharles McLachlan goto fail1; 29452ad762bSDaniel Pieczko 295b0fbdae1SShradha Shah /* dimension_resources can fail with EAGAIN */ 296c15eed22SBen Hutchings rc = efx->type->dimension_resources(efx); 297b0fbdae1SShradha Shah if (rc != 0 && rc != -EAGAIN) 298c15eed22SBen Hutchings goto fail2; 29928e47c49SBen Hutchings 300b0fbdae1SShradha Shah if (rc == -EAGAIN) 301b0fbdae1SShradha Shah /* try again with new max_channels */ 302b0fbdae1SShradha Shah efx_remove_interrupts(efx); 303b0fbdae1SShradha Shah 304b0fbdae1SShradha Shah } while (rc == -EAGAIN); 305b0fbdae1SShradha Shah 306874aeea5SJeff Kirsher if (efx->n_channels > 1) 30742356d9aSEdward Cree netdev_rss_key_fill(efx->rss_context.rx_hash_key, 30842356d9aSEdward Cree sizeof(efx->rss_context.rx_hash_key)); 30942356d9aSEdward Cree efx_set_default_rx_indir_table(efx, &efx->rss_context); 310874aeea5SJeff Kirsher 311874aeea5SJeff Kirsher /* Initialise the interrupt moderation settings */ 312539de7c5SBert Kenward efx->irq_mod_step_us = DIV_ROUND_UP(efx->timer_quantum_ns, 1000); 3139e393b30SBen Hutchings efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true, 3149e393b30SBen Hutchings true); 315874aeea5SJeff Kirsher 316874aeea5SJeff Kirsher return 0; 317874aeea5SJeff Kirsher 318c15eed22SBen Hutchings fail2: 319c15eed22SBen Hutchings efx_remove_interrupts(efx); 320c15eed22SBen Hutchings fail1: 321874aeea5SJeff Kirsher efx->type->remove(efx); 322874aeea5SJeff Kirsher return rc; 323874aeea5SJeff Kirsher } 324874aeea5SJeff Kirsher 325874aeea5SJeff Kirsher static void efx_remove_nic(struct efx_nic *efx) 326874aeea5SJeff Kirsher { 327874aeea5SJeff Kirsher netif_dbg(efx, drv, efx->net_dev, "destroying NIC\n"); 328874aeea5SJeff Kirsher 329874aeea5SJeff Kirsher efx_remove_interrupts(efx); 330874aeea5SJeff Kirsher efx->type->remove(efx); 331874aeea5SJeff Kirsher } 332874aeea5SJeff Kirsher 333874aeea5SJeff Kirsher /************************************************************************** 334874aeea5SJeff Kirsher * 335874aeea5SJeff Kirsher * NIC startup/shutdown 336874aeea5SJeff Kirsher * 337874aeea5SJeff Kirsher *************************************************************************/ 338874aeea5SJeff Kirsher 339874aeea5SJeff Kirsher static int efx_probe_all(struct efx_nic *efx) 340874aeea5SJeff Kirsher { 341874aeea5SJeff Kirsher int rc; 342874aeea5SJeff Kirsher 343874aeea5SJeff Kirsher rc = efx_probe_nic(efx); 344874aeea5SJeff Kirsher if (rc) { 345874aeea5SJeff Kirsher netif_err(efx, probe, efx->net_dev, "failed to create NIC\n"); 346874aeea5SJeff Kirsher goto fail1; 347874aeea5SJeff Kirsher } 348874aeea5SJeff Kirsher 349874aeea5SJeff Kirsher rc = efx_probe_port(efx); 350874aeea5SJeff Kirsher if (rc) { 351874aeea5SJeff Kirsher netif_err(efx, probe, efx->net_dev, "failed to create port\n"); 352874aeea5SJeff Kirsher goto fail2; 353874aeea5SJeff Kirsher } 354874aeea5SJeff Kirsher 3557e6d06f0SBen Hutchings BUILD_BUG_ON(EFX_DEFAULT_DMAQ_SIZE < EFX_RXQ_MIN_ENT); 3567e6d06f0SBen Hutchings if (WARN_ON(EFX_DEFAULT_DMAQ_SIZE < EFX_TXQ_MIN_ENT(efx))) { 3577e6d06f0SBen Hutchings rc = -EINVAL; 3587e6d06f0SBen Hutchings goto fail3; 3597e6d06f0SBen Hutchings } 360874aeea5SJeff Kirsher 3616d8aaaf6SDaniel Pieczko #ifdef CONFIG_SFC_SRIOV 3626d8aaaf6SDaniel Pieczko rc = efx->type->vswitching_probe(efx); 3636d8aaaf6SDaniel Pieczko if (rc) /* not fatal; the PF will still work fine */ 3646d8aaaf6SDaniel Pieczko netif_warn(efx, probe, efx->net_dev, 3656d8aaaf6SDaniel Pieczko "failed to setup vswitching rc=%d;" 3666d8aaaf6SDaniel Pieczko " VFs may not function\n", rc); 3676d8aaaf6SDaniel Pieczko #endif 3686d8aaaf6SDaniel Pieczko 369874aeea5SJeff Kirsher rc = efx_probe_filters(efx); 370874aeea5SJeff Kirsher if (rc) { 371874aeea5SJeff Kirsher netif_err(efx, probe, efx->net_dev, 372874aeea5SJeff Kirsher "failed to create filter tables\n"); 3736d8aaaf6SDaniel Pieczko goto fail4; 374874aeea5SJeff Kirsher } 375874aeea5SJeff Kirsher 3767f967c01SBen Hutchings rc = efx_probe_channels(efx); 3777f967c01SBen Hutchings if (rc) 3786d8aaaf6SDaniel Pieczko goto fail5; 3797f967c01SBen Hutchings 380874aeea5SJeff Kirsher return 0; 381874aeea5SJeff Kirsher 3826d8aaaf6SDaniel Pieczko fail5: 3837f967c01SBen Hutchings efx_remove_filters(efx); 3846d8aaaf6SDaniel Pieczko fail4: 3856d8aaaf6SDaniel Pieczko #ifdef CONFIG_SFC_SRIOV 3866d8aaaf6SDaniel Pieczko efx->type->vswitching_remove(efx); 3876d8aaaf6SDaniel Pieczko #endif 388874aeea5SJeff Kirsher fail3: 389874aeea5SJeff Kirsher efx_remove_port(efx); 390874aeea5SJeff Kirsher fail2: 391874aeea5SJeff Kirsher efx_remove_nic(efx); 392874aeea5SJeff Kirsher fail1: 393874aeea5SJeff Kirsher return rc; 394874aeea5SJeff Kirsher } 395874aeea5SJeff Kirsher 396874aeea5SJeff Kirsher static void efx_remove_all(struct efx_nic *efx) 397874aeea5SJeff Kirsher { 398e45a4fedSCharles McLachlan rtnl_lock(); 399e45a4fedSCharles McLachlan efx_xdp_setup_prog(efx, NULL); 400e45a4fedSCharles McLachlan rtnl_unlock(); 401e45a4fedSCharles McLachlan 402874aeea5SJeff Kirsher efx_remove_channels(efx); 4037f967c01SBen Hutchings efx_remove_filters(efx); 4046d8aaaf6SDaniel Pieczko #ifdef CONFIG_SFC_SRIOV 4056d8aaaf6SDaniel Pieczko efx->type->vswitching_remove(efx); 4066d8aaaf6SDaniel Pieczko #endif 407874aeea5SJeff Kirsher efx_remove_port(efx); 408874aeea5SJeff Kirsher efx_remove_nic(efx); 409874aeea5SJeff Kirsher } 410874aeea5SJeff Kirsher 411874aeea5SJeff Kirsher /************************************************************************** 412874aeea5SJeff Kirsher * 413874aeea5SJeff Kirsher * Interrupt moderation 414874aeea5SJeff Kirsher * 415874aeea5SJeff Kirsher **************************************************************************/ 416539de7c5SBert Kenward unsigned int efx_usecs_to_ticks(struct efx_nic *efx, unsigned int usecs) 417874aeea5SJeff Kirsher { 418b548f976SBen Hutchings if (usecs == 0) 419b548f976SBen Hutchings return 0; 420539de7c5SBert Kenward if (usecs * 1000 < efx->timer_quantum_ns) 421874aeea5SJeff Kirsher return 1; /* never round down to 0 */ 422539de7c5SBert Kenward return usecs * 1000 / efx->timer_quantum_ns; 423539de7c5SBert Kenward } 424539de7c5SBert Kenward 425539de7c5SBert Kenward unsigned int efx_ticks_to_usecs(struct efx_nic *efx, unsigned int ticks) 426539de7c5SBert Kenward { 427539de7c5SBert Kenward /* We must round up when converting ticks to microseconds 428539de7c5SBert Kenward * because we round down when converting the other way. 429539de7c5SBert Kenward */ 430539de7c5SBert Kenward return DIV_ROUND_UP(ticks * efx->timer_quantum_ns, 1000); 431874aeea5SJeff Kirsher } 432874aeea5SJeff Kirsher 433874aeea5SJeff Kirsher /* Set interrupt moderation parameters */ 4349e393b30SBen Hutchings int efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs, 4359e393b30SBen Hutchings unsigned int rx_usecs, bool rx_adaptive, 4369e393b30SBen Hutchings bool rx_may_override_tx) 437874aeea5SJeff Kirsher { 438874aeea5SJeff Kirsher struct efx_channel *channel; 439d95e329aSBert Kenward unsigned int timer_max_us; 440d95e329aSBert Kenward 441874aeea5SJeff Kirsher EFX_ASSERT_RESET_SERIALISED(efx); 442874aeea5SJeff Kirsher 443d95e329aSBert Kenward timer_max_us = efx->timer_max_ns / 1000; 444d95e329aSBert Kenward 445d95e329aSBert Kenward if (tx_usecs > timer_max_us || rx_usecs > timer_max_us) 4469e393b30SBen Hutchings return -EINVAL; 4479e393b30SBen Hutchings 448539de7c5SBert Kenward if (tx_usecs != rx_usecs && efx->tx_channel_offset == 0 && 4499e393b30SBen Hutchings !rx_may_override_tx) { 4509e393b30SBen Hutchings netif_err(efx, drv, efx->net_dev, "Channels are shared. " 4519e393b30SBen Hutchings "RX and TX IRQ moderation must be equal\n"); 4529e393b30SBen Hutchings return -EINVAL; 4539e393b30SBen Hutchings } 4549e393b30SBen Hutchings 455874aeea5SJeff Kirsher efx->irq_rx_adaptive = rx_adaptive; 456539de7c5SBert Kenward efx->irq_rx_moderation_us = rx_usecs; 457874aeea5SJeff Kirsher efx_for_each_channel(channel, efx) { 458874aeea5SJeff Kirsher if (efx_channel_has_rx_queue(channel)) 459539de7c5SBert Kenward channel->irq_moderation_us = rx_usecs; 460874aeea5SJeff Kirsher else if (efx_channel_has_tx_queues(channel)) 461539de7c5SBert Kenward channel->irq_moderation_us = tx_usecs; 4623990a8ffSCharles McLachlan else if (efx_channel_is_xdp_tx(channel)) 4633990a8ffSCharles McLachlan channel->irq_moderation_us = tx_usecs; 464874aeea5SJeff Kirsher } 4659e393b30SBen Hutchings 4669e393b30SBen Hutchings return 0; 467874aeea5SJeff Kirsher } 468874aeea5SJeff Kirsher 469a0c4faf5SBen Hutchings void efx_get_irq_moderation(struct efx_nic *efx, unsigned int *tx_usecs, 470a0c4faf5SBen Hutchings unsigned int *rx_usecs, bool *rx_adaptive) 471a0c4faf5SBen Hutchings { 472a0c4faf5SBen Hutchings *rx_adaptive = efx->irq_rx_adaptive; 473539de7c5SBert Kenward *rx_usecs = efx->irq_rx_moderation_us; 474a0c4faf5SBen Hutchings 475a0c4faf5SBen Hutchings /* If channels are shared between RX and TX, so is IRQ 476a0c4faf5SBen Hutchings * moderation. Otherwise, IRQ moderation is the same for all 477a0c4faf5SBen Hutchings * TX channels and is not adaptive. 478a0c4faf5SBen Hutchings */ 479539de7c5SBert Kenward if (efx->tx_channel_offset == 0) { 480a0c4faf5SBen Hutchings *tx_usecs = *rx_usecs; 481539de7c5SBert Kenward } else { 482539de7c5SBert Kenward struct efx_channel *tx_channel; 483539de7c5SBert Kenward 484539de7c5SBert Kenward tx_channel = efx->channel[efx->tx_channel_offset]; 485539de7c5SBert Kenward *tx_usecs = tx_channel->irq_moderation_us; 486539de7c5SBert Kenward } 487a0c4faf5SBen Hutchings } 488a0c4faf5SBen Hutchings 489874aeea5SJeff Kirsher /************************************************************************** 490874aeea5SJeff Kirsher * 491874aeea5SJeff Kirsher * ioctls 492874aeea5SJeff Kirsher * 493874aeea5SJeff Kirsher *************************************************************************/ 494874aeea5SJeff Kirsher 495874aeea5SJeff Kirsher /* Net device ioctl 496874aeea5SJeff Kirsher * Context: process, rtnl_lock() held. 497874aeea5SJeff Kirsher */ 498874aeea5SJeff Kirsher static int efx_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd) 499874aeea5SJeff Kirsher { 500874aeea5SJeff Kirsher struct efx_nic *efx = netdev_priv(net_dev); 501874aeea5SJeff Kirsher struct mii_ioctl_data *data = if_mii(ifr); 502874aeea5SJeff Kirsher 5037c236c43SStuart Hodgson if (cmd == SIOCSHWTSTAMP) 504433dc9b3SBen Hutchings return efx_ptp_set_ts_config(efx, ifr); 505433dc9b3SBen Hutchings if (cmd == SIOCGHWTSTAMP) 506433dc9b3SBen Hutchings return efx_ptp_get_ts_config(efx, ifr); 5077c236c43SStuart Hodgson 508874aeea5SJeff Kirsher /* Convert phy_id from older PRTAD/DEVAD format */ 509874aeea5SJeff Kirsher if ((cmd == SIOCGMIIREG || cmd == SIOCSMIIREG) && 510874aeea5SJeff Kirsher (data->phy_id & 0xfc00) == 0x0400) 511874aeea5SJeff Kirsher data->phy_id ^= MDIO_PHY_ID_C45 | 0x0400; 512874aeea5SJeff Kirsher 513874aeea5SJeff Kirsher return mdio_mii_ioctl(&efx->mdio, data, cmd); 514874aeea5SJeff Kirsher } 515874aeea5SJeff Kirsher 516874aeea5SJeff Kirsher /************************************************************************** 517874aeea5SJeff Kirsher * 518874aeea5SJeff Kirsher * Kernel net device interface 519874aeea5SJeff Kirsher * 520874aeea5SJeff Kirsher *************************************************************************/ 521874aeea5SJeff Kirsher 522874aeea5SJeff Kirsher /* Context: process, rtnl_lock() held. */ 523e340be92SShradha Shah int efx_net_open(struct net_device *net_dev) 524874aeea5SJeff Kirsher { 525874aeea5SJeff Kirsher struct efx_nic *efx = netdev_priv(net_dev); 5268b7325b4SBen Hutchings int rc; 5278b7325b4SBen Hutchings 528874aeea5SJeff Kirsher netif_dbg(efx, ifup, efx->net_dev, "opening device on CPU %d\n", 529874aeea5SJeff Kirsher raw_smp_processor_id()); 530874aeea5SJeff Kirsher 5318b7325b4SBen Hutchings rc = efx_check_disabled(efx); 5328b7325b4SBen Hutchings if (rc) 5338b7325b4SBen Hutchings return rc; 534874aeea5SJeff Kirsher if (efx->phy_mode & PHY_MODE_SPECIAL) 535874aeea5SJeff Kirsher return -EBUSY; 536874aeea5SJeff Kirsher if (efx_mcdi_poll_reboot(efx) && efx_reset(efx, RESET_TYPE_ALL)) 537874aeea5SJeff Kirsher return -EIO; 538874aeea5SJeff Kirsher 539874aeea5SJeff Kirsher /* Notify the kernel of the link state polled during driver load, 540874aeea5SJeff Kirsher * before the monitor starts running */ 541874aeea5SJeff Kirsher efx_link_status_changed(efx); 542874aeea5SJeff Kirsher 543874aeea5SJeff Kirsher efx_start_all(efx); 5449c568fd8SPeter Dunning if (efx->state == STATE_DISABLED || efx->reset_pending) 5459c568fd8SPeter Dunning netif_device_detach(efx->net_dev); 546dd40781eSBen Hutchings efx_selftest_async_start(efx); 547874aeea5SJeff Kirsher return 0; 548874aeea5SJeff Kirsher } 549874aeea5SJeff Kirsher 550874aeea5SJeff Kirsher /* Context: process, rtnl_lock() held. 551874aeea5SJeff Kirsher * Note that the kernel will ignore our return code; this method 552874aeea5SJeff Kirsher * should really be a void. 553874aeea5SJeff Kirsher */ 554e340be92SShradha Shah int efx_net_stop(struct net_device *net_dev) 555874aeea5SJeff Kirsher { 556874aeea5SJeff Kirsher struct efx_nic *efx = netdev_priv(net_dev); 557874aeea5SJeff Kirsher 558874aeea5SJeff Kirsher netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n", 559874aeea5SJeff Kirsher raw_smp_processor_id()); 560874aeea5SJeff Kirsher 561874aeea5SJeff Kirsher /* Stop the device and flush all the channels */ 562874aeea5SJeff Kirsher efx_stop_all(efx); 563874aeea5SJeff Kirsher 564874aeea5SJeff Kirsher return 0; 565874aeea5SJeff Kirsher } 566874aeea5SJeff Kirsher 5674a53ea8aSAndrew Rybchenko static int efx_vlan_rx_add_vid(struct net_device *net_dev, __be16 proto, u16 vid) 5684a53ea8aSAndrew Rybchenko { 5694a53ea8aSAndrew Rybchenko struct efx_nic *efx = netdev_priv(net_dev); 5704a53ea8aSAndrew Rybchenko 5714a53ea8aSAndrew Rybchenko if (efx->type->vlan_rx_add_vid) 5724a53ea8aSAndrew Rybchenko return efx->type->vlan_rx_add_vid(efx, proto, vid); 5734a53ea8aSAndrew Rybchenko else 5744a53ea8aSAndrew Rybchenko return -EOPNOTSUPP; 5754a53ea8aSAndrew Rybchenko } 5764a53ea8aSAndrew Rybchenko 5774a53ea8aSAndrew Rybchenko static int efx_vlan_rx_kill_vid(struct net_device *net_dev, __be16 proto, u16 vid) 5784a53ea8aSAndrew Rybchenko { 5794a53ea8aSAndrew Rybchenko struct efx_nic *efx = netdev_priv(net_dev); 5804a53ea8aSAndrew Rybchenko 5814a53ea8aSAndrew Rybchenko if (efx->type->vlan_rx_kill_vid) 5824a53ea8aSAndrew Rybchenko return efx->type->vlan_rx_kill_vid(efx, proto, vid); 5834a53ea8aSAndrew Rybchenko else 5844a53ea8aSAndrew Rybchenko return -EOPNOTSUPP; 5854a53ea8aSAndrew Rybchenko } 5864a53ea8aSAndrew Rybchenko 5877fa8d547SShradha Shah static const struct net_device_ops efx_netdev_ops = { 588874aeea5SJeff Kirsher .ndo_open = efx_net_open, 589874aeea5SJeff Kirsher .ndo_stop = efx_net_stop, 590874aeea5SJeff Kirsher .ndo_get_stats64 = efx_net_stats, 591874aeea5SJeff Kirsher .ndo_tx_timeout = efx_watchdog, 592874aeea5SJeff Kirsher .ndo_start_xmit = efx_hard_start_xmit, 593874aeea5SJeff Kirsher .ndo_validate_addr = eth_validate_addr, 594874aeea5SJeff Kirsher .ndo_do_ioctl = efx_ioctl, 595874aeea5SJeff Kirsher .ndo_change_mtu = efx_change_mtu, 596874aeea5SJeff Kirsher .ndo_set_mac_address = efx_set_mac_address, 5970fca8c97SBen Hutchings .ndo_set_rx_mode = efx_set_rx_mode, 598874aeea5SJeff Kirsher .ndo_set_features = efx_set_features, 59924b2c375SEdward Cree .ndo_features_check = efx_features_check, 6004a53ea8aSAndrew Rybchenko .ndo_vlan_rx_add_vid = efx_vlan_rx_add_vid, 6014a53ea8aSAndrew Rybchenko .ndo_vlan_rx_kill_vid = efx_vlan_rx_kill_vid, 602cd2d5b52SBen Hutchings #ifdef CONFIG_SFC_SRIOV 6037fa8d547SShradha Shah .ndo_set_vf_mac = efx_sriov_set_vf_mac, 6047fa8d547SShradha Shah .ndo_set_vf_vlan = efx_sriov_set_vf_vlan, 6057fa8d547SShradha Shah .ndo_set_vf_spoofchk = efx_sriov_set_vf_spoofchk, 6067fa8d547SShradha Shah .ndo_get_vf_config = efx_sriov_get_vf_config, 6074392dc69SEdward Cree .ndo_set_vf_link_state = efx_sriov_set_vf_link_state, 608cd2d5b52SBen Hutchings #endif 60908a7b29bSBert Kenward .ndo_get_phys_port_id = efx_get_phys_port_id, 610ac019f08SBert Kenward .ndo_get_phys_port_name = efx_get_phys_port_name, 611874aeea5SJeff Kirsher .ndo_setup_tc = efx_setup_tc, 612874aeea5SJeff Kirsher #ifdef CONFIG_RFS_ACCEL 613874aeea5SJeff Kirsher .ndo_rx_flow_steer = efx_filter_rfs, 614874aeea5SJeff Kirsher #endif 615dfe44c1fSCharles McLachlan .ndo_xdp_xmit = efx_xdp_xmit, 616e45a4fedSCharles McLachlan .ndo_bpf = efx_xdp 617874aeea5SJeff Kirsher }; 618874aeea5SJeff Kirsher 619e45a4fedSCharles McLachlan static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog) 620e45a4fedSCharles McLachlan { 621e45a4fedSCharles McLachlan struct bpf_prog *old_prog; 622e45a4fedSCharles McLachlan 623e45a4fedSCharles McLachlan if (efx->xdp_rxq_info_failed) { 624e45a4fedSCharles McLachlan netif_err(efx, drv, efx->net_dev, 625e45a4fedSCharles McLachlan "Unable to bind XDP program due to previous failure of rxq_info\n"); 626e45a4fedSCharles McLachlan return -EINVAL; 627e45a4fedSCharles McLachlan } 628e45a4fedSCharles McLachlan 629e45a4fedSCharles McLachlan if (prog && efx->net_dev->mtu > efx_xdp_max_mtu(efx)) { 630e45a4fedSCharles McLachlan netif_err(efx, drv, efx->net_dev, 631e45a4fedSCharles McLachlan "Unable to configure XDP with MTU of %d (max: %d)\n", 632e45a4fedSCharles McLachlan efx->net_dev->mtu, efx_xdp_max_mtu(efx)); 633e45a4fedSCharles McLachlan return -EINVAL; 634e45a4fedSCharles McLachlan } 635e45a4fedSCharles McLachlan 636e45a4fedSCharles McLachlan old_prog = rtnl_dereference(efx->xdp_prog); 637e45a4fedSCharles McLachlan rcu_assign_pointer(efx->xdp_prog, prog); 638e45a4fedSCharles McLachlan /* Release the reference that was originally passed by the caller. */ 639e45a4fedSCharles McLachlan if (old_prog) 640e45a4fedSCharles McLachlan bpf_prog_put(old_prog); 641e45a4fedSCharles McLachlan 642e45a4fedSCharles McLachlan return 0; 643e45a4fedSCharles McLachlan } 644e45a4fedSCharles McLachlan 645e45a4fedSCharles McLachlan /* Context: process, rtnl_lock() held. */ 646e45a4fedSCharles McLachlan static int efx_xdp(struct net_device *dev, struct netdev_bpf *xdp) 647e45a4fedSCharles McLachlan { 648e45a4fedSCharles McLachlan struct efx_nic *efx = netdev_priv(dev); 649e45a4fedSCharles McLachlan 650e45a4fedSCharles McLachlan switch (xdp->command) { 651e45a4fedSCharles McLachlan case XDP_SETUP_PROG: 652e45a4fedSCharles McLachlan return efx_xdp_setup_prog(efx, xdp->prog); 653e45a4fedSCharles McLachlan default: 654e45a4fedSCharles McLachlan return -EINVAL; 655e45a4fedSCharles McLachlan } 656e45a4fedSCharles McLachlan } 657e45a4fedSCharles McLachlan 658dfe44c1fSCharles McLachlan static int efx_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **xdpfs, 659dfe44c1fSCharles McLachlan u32 flags) 660dfe44c1fSCharles McLachlan { 661dfe44c1fSCharles McLachlan struct efx_nic *efx = netdev_priv(dev); 662dfe44c1fSCharles McLachlan 663dfe44c1fSCharles McLachlan if (!netif_running(dev)) 664dfe44c1fSCharles McLachlan return -EINVAL; 665dfe44c1fSCharles McLachlan 666dfe44c1fSCharles McLachlan return efx_xdp_tx_buffers(efx, n, xdpfs, flags & XDP_XMIT_FLUSH); 667dfe44c1fSCharles McLachlan } 668dfe44c1fSCharles McLachlan 669874aeea5SJeff Kirsher static void efx_update_name(struct efx_nic *efx) 670874aeea5SJeff Kirsher { 671874aeea5SJeff Kirsher strcpy(efx->name, efx->net_dev->name); 672874aeea5SJeff Kirsher efx_mtd_rename(efx); 673874aeea5SJeff Kirsher efx_set_channel_names(efx); 674874aeea5SJeff Kirsher } 675874aeea5SJeff Kirsher 676874aeea5SJeff Kirsher static int efx_netdev_event(struct notifier_block *this, 677874aeea5SJeff Kirsher unsigned long event, void *ptr) 678874aeea5SJeff Kirsher { 679351638e7SJiri Pirko struct net_device *net_dev = netdev_notifier_info_to_dev(ptr); 680874aeea5SJeff Kirsher 6817fa8d547SShradha Shah if ((net_dev->netdev_ops == &efx_netdev_ops) && 682874aeea5SJeff Kirsher event == NETDEV_CHANGENAME) 683874aeea5SJeff Kirsher efx_update_name(netdev_priv(net_dev)); 684874aeea5SJeff Kirsher 685874aeea5SJeff Kirsher return NOTIFY_DONE; 686874aeea5SJeff Kirsher } 687874aeea5SJeff Kirsher 688874aeea5SJeff Kirsher static struct notifier_block efx_netdev_notifier = { 689874aeea5SJeff Kirsher .notifier_call = efx_netdev_event, 690874aeea5SJeff Kirsher }; 691874aeea5SJeff Kirsher 6923880fc37SYueHaibing static ssize_t phy_type_show(struct device *dev, 6933880fc37SYueHaibing struct device_attribute *attr, char *buf) 694874aeea5SJeff Kirsher { 6953e03a8baSChuhong Yuan struct efx_nic *efx = dev_get_drvdata(dev); 696874aeea5SJeff Kirsher return sprintf(buf, "%d\n", efx->phy_type); 697874aeea5SJeff Kirsher } 6983880fc37SYueHaibing static DEVICE_ATTR_RO(phy_type); 699874aeea5SJeff Kirsher 700874aeea5SJeff Kirsher static int efx_register_netdev(struct efx_nic *efx) 701874aeea5SJeff Kirsher { 702874aeea5SJeff Kirsher struct net_device *net_dev = efx->net_dev; 703874aeea5SJeff Kirsher struct efx_channel *channel; 704874aeea5SJeff Kirsher int rc; 705874aeea5SJeff Kirsher 706874aeea5SJeff Kirsher net_dev->watchdog_timeo = 5 * HZ; 707874aeea5SJeff Kirsher net_dev->irq = efx->pci_dev->irq; 7087fa8d547SShradha Shah net_dev->netdev_ops = &efx_netdev_ops; 7097fa8d547SShradha Shah if (efx_nic_rev(efx) >= EFX_REV_HUNT_A0) 7108127d661SBen Hutchings net_dev->priv_flags |= IFF_UNICAST_FLT; 7117ad24ea4SWilfried Klaebe net_dev->ethtool_ops = &efx_ethtool_ops; 7127e6d06f0SBen Hutchings net_dev->gso_max_segs = EFX_TSO_MAX_SEGS; 713cd94e519SBert Kenward net_dev->min_mtu = EFX_MIN_MTU; 714cd94e519SBert Kenward net_dev->max_mtu = EFX_MAX_MTU; 715874aeea5SJeff Kirsher 716874aeea5SJeff Kirsher rtnl_lock(); 717874aeea5SJeff Kirsher 7187153f623SBen Hutchings /* Enable resets to be scheduled and check whether any were 7197153f623SBen Hutchings * already requested. If so, the NIC is probably hosed so we 7207153f623SBen Hutchings * abort. 7217153f623SBen Hutchings */ 7227153f623SBen Hutchings efx->state = STATE_READY; 7237153f623SBen Hutchings smp_mb(); /* ensure we change state before checking reset_pending */ 7247153f623SBen Hutchings if (efx->reset_pending) { 725fa44821aSHeiner Kallweit pci_err(efx->pci_dev, "aborting probe due to scheduled reset\n"); 7267153f623SBen Hutchings rc = -EIO; 7277153f623SBen Hutchings goto fail_locked; 7287153f623SBen Hutchings } 7297153f623SBen Hutchings 730874aeea5SJeff Kirsher rc = dev_alloc_name(net_dev, net_dev->name); 731874aeea5SJeff Kirsher if (rc < 0) 732874aeea5SJeff Kirsher goto fail_locked; 733874aeea5SJeff Kirsher efx_update_name(efx); 734874aeea5SJeff Kirsher 7358f8b3d51SBen Hutchings /* Always start with carrier off; PHY events will detect the link */ 7368f8b3d51SBen Hutchings netif_carrier_off(net_dev); 7378f8b3d51SBen Hutchings 738874aeea5SJeff Kirsher rc = register_netdevice(net_dev); 739874aeea5SJeff Kirsher if (rc) 740874aeea5SJeff Kirsher goto fail_locked; 741874aeea5SJeff Kirsher 742874aeea5SJeff Kirsher efx_for_each_channel(channel, efx) { 743874aeea5SJeff Kirsher struct efx_tx_queue *tx_queue; 744874aeea5SJeff Kirsher efx_for_each_channel_tx_queue(tx_queue, channel) 745874aeea5SJeff Kirsher efx_init_tx_queue_core_txq(tx_queue); 746874aeea5SJeff Kirsher } 747874aeea5SJeff Kirsher 7480bcf4a64SBen Hutchings efx_associate(efx); 7490bcf4a64SBen Hutchings 750874aeea5SJeff Kirsher rtnl_unlock(); 751874aeea5SJeff Kirsher 752874aeea5SJeff Kirsher rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_type); 753874aeea5SJeff Kirsher if (rc) { 754874aeea5SJeff Kirsher netif_err(efx, drv, efx->net_dev, 755874aeea5SJeff Kirsher "failed to init net dev attributes\n"); 756874aeea5SJeff Kirsher goto fail_registered; 757874aeea5SJeff Kirsher } 758b69f7a3eSAlex Maftei (amaftei) 759b69f7a3eSAlex Maftei (amaftei) efx_init_mcdi_logging(efx); 760874aeea5SJeff Kirsher 761874aeea5SJeff Kirsher return 0; 762874aeea5SJeff Kirsher 7637153f623SBen Hutchings fail_registered: 7647153f623SBen Hutchings rtnl_lock(); 7650bcf4a64SBen Hutchings efx_dissociate(efx); 7667153f623SBen Hutchings unregister_netdevice(net_dev); 767874aeea5SJeff Kirsher fail_locked: 7687153f623SBen Hutchings efx->state = STATE_UNINIT; 769874aeea5SJeff Kirsher rtnl_unlock(); 770874aeea5SJeff Kirsher netif_err(efx, drv, efx->net_dev, "could not register net dev\n"); 771874aeea5SJeff Kirsher return rc; 772874aeea5SJeff Kirsher } 773874aeea5SJeff Kirsher 774874aeea5SJeff Kirsher static void efx_unregister_netdev(struct efx_nic *efx) 775874aeea5SJeff Kirsher { 776874aeea5SJeff Kirsher if (!efx->net_dev) 777874aeea5SJeff Kirsher return; 778874aeea5SJeff Kirsher 779874aeea5SJeff Kirsher BUG_ON(netdev_priv(efx->net_dev) != efx); 780874aeea5SJeff Kirsher 781e7fef9b4SEdward Cree if (efx_dev_registered(efx)) { 782874aeea5SJeff Kirsher strlcpy(efx->name, pci_name(efx->pci_dev), sizeof(efx->name)); 783b69f7a3eSAlex Maftei (amaftei) efx_fini_mcdi_logging(efx); 784874aeea5SJeff Kirsher device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type); 785e7fef9b4SEdward Cree unregister_netdev(efx->net_dev); 786e7fef9b4SEdward Cree } 787874aeea5SJeff Kirsher } 788874aeea5SJeff Kirsher 789874aeea5SJeff Kirsher /************************************************************************** 790874aeea5SJeff Kirsher * 791874aeea5SJeff Kirsher * List of NICs we support 792874aeea5SJeff Kirsher * 793874aeea5SJeff Kirsher **************************************************************************/ 794874aeea5SJeff Kirsher 795874aeea5SJeff Kirsher /* PCI device ID table */ 7969baa3c34SBenoit Taine static const struct pci_device_id efx_pci_table[] = { 797547c474fSBen Hutchings {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0803), /* SFC9020 */ 798874aeea5SJeff Kirsher .driver_data = (unsigned long) &siena_a0_nic_type}, 799547c474fSBen Hutchings {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0813), /* SFL9021 */ 800874aeea5SJeff Kirsher .driver_data = (unsigned long) &siena_a0_nic_type}, 8018127d661SBen Hutchings {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0903), /* SFC9120 PF */ 8028127d661SBen Hutchings .driver_data = (unsigned long) &efx_hunt_a0_nic_type}, 8036f7f8aa6SShradha Shah {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1903), /* SFC9120 VF */ 8046f7f8aa6SShradha Shah .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type}, 8053b06a00eSMateusz Wrzesinski {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0923), /* SFC9140 PF */ 8063b06a00eSMateusz Wrzesinski .driver_data = (unsigned long) &efx_hunt_a0_nic_type}, 807dd248f1bSBert Kenward {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1923), /* SFC9140 VF */ 808dd248f1bSBert Kenward .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type}, 809dd248f1bSBert Kenward {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0a03), /* SFC9220 PF */ 810dd248f1bSBert Kenward .driver_data = (unsigned long) &efx_hunt_a0_nic_type}, 811dd248f1bSBert Kenward {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1a03), /* SFC9220 VF */ 812dd248f1bSBert Kenward .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type}, 813aae5a316SEdward Cree {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0b03), /* SFC9250 PF */ 814aae5a316SEdward Cree .driver_data = (unsigned long) &efx_hunt_a0_nic_type}, 815aae5a316SEdward Cree {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1b03), /* SFC9250 VF */ 816aae5a316SEdward Cree .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type}, 817874aeea5SJeff Kirsher {0} /* end of list */ 818874aeea5SJeff Kirsher }; 819874aeea5SJeff Kirsher 820874aeea5SJeff Kirsher /************************************************************************** 821874aeea5SJeff Kirsher * 822874aeea5SJeff Kirsher * Data housekeeping 823874aeea5SJeff Kirsher * 824874aeea5SJeff Kirsher **************************************************************************/ 825874aeea5SJeff Kirsher 826e4d112e4SEdward Cree void efx_update_sw_stats(struct efx_nic *efx, u64 *stats) 827e4d112e4SEdward Cree { 828e4d112e4SEdward Cree u64 n_rx_nodesc_trunc = 0; 829e4d112e4SEdward Cree struct efx_channel *channel; 830e4d112e4SEdward Cree 831e4d112e4SEdward Cree efx_for_each_channel(channel, efx) 832e4d112e4SEdward Cree n_rx_nodesc_trunc += channel->n_rx_nodesc_trunc; 833e4d112e4SEdward Cree stats[GENERIC_STAT_rx_nodesc_trunc] = n_rx_nodesc_trunc; 834e4d112e4SEdward Cree stats[GENERIC_STAT_rx_noskb_drops] = atomic_read(&efx->n_rx_noskb_drops); 835e4d112e4SEdward Cree } 836e4d112e4SEdward Cree 837874aeea5SJeff Kirsher /************************************************************************** 838874aeea5SJeff Kirsher * 839874aeea5SJeff Kirsher * PCI interface 840874aeea5SJeff Kirsher * 841874aeea5SJeff Kirsher **************************************************************************/ 842874aeea5SJeff Kirsher 843874aeea5SJeff Kirsher /* Main body of final NIC shutdown code 844874aeea5SJeff Kirsher * This is called only at module unload (or hotplug removal). 845874aeea5SJeff Kirsher */ 846874aeea5SJeff Kirsher static void efx_pci_remove_main(struct efx_nic *efx) 847874aeea5SJeff Kirsher { 8487153f623SBen Hutchings /* Flush reset_work. It can no longer be scheduled since we 8497153f623SBen Hutchings * are not READY. 8507153f623SBen Hutchings */ 8517153f623SBen Hutchings BUG_ON(efx->state == STATE_READY); 85282c64484SAlex Maftei (amaftei) efx_flush_reset_workqueue(efx); 8537153f623SBen Hutchings 854d8291187SBen Hutchings efx_disable_interrupts(efx); 855a83762d9SBert Kenward efx_clear_interrupt_affinity(efx); 856874aeea5SJeff Kirsher efx_nic_fini_interrupt(efx); 857874aeea5SJeff Kirsher efx_fini_port(efx); 858874aeea5SJeff Kirsher efx->type->fini(efx); 859874aeea5SJeff Kirsher efx_fini_napi(efx); 860874aeea5SJeff Kirsher efx_remove_all(efx); 861874aeea5SJeff Kirsher } 862874aeea5SJeff Kirsher 863874aeea5SJeff Kirsher /* Final NIC shutdown 8642a3fc311SDaniel Pieczko * This is called only at module unload (or hotplug removal). A PF can call 8652a3fc311SDaniel Pieczko * this on its VFs to ensure they are unbound first. 866874aeea5SJeff Kirsher */ 867874aeea5SJeff Kirsher static void efx_pci_remove(struct pci_dev *pci_dev) 868874aeea5SJeff Kirsher { 869874aeea5SJeff Kirsher struct efx_nic *efx; 870874aeea5SJeff Kirsher 871874aeea5SJeff Kirsher efx = pci_get_drvdata(pci_dev); 872874aeea5SJeff Kirsher if (!efx) 873874aeea5SJeff Kirsher return; 874874aeea5SJeff Kirsher 875874aeea5SJeff Kirsher /* Mark the NIC as fini, then stop the interface */ 876874aeea5SJeff Kirsher rtnl_lock(); 8770bcf4a64SBen Hutchings efx_dissociate(efx); 878874aeea5SJeff Kirsher dev_close(efx->net_dev); 879d8291187SBen Hutchings efx_disable_interrupts(efx); 880ea6bb99eSEdward Cree efx->state = STATE_UNINIT; 881874aeea5SJeff Kirsher rtnl_unlock(); 882874aeea5SJeff Kirsher 8837fa8d547SShradha Shah if (efx->type->sriov_fini) 884d98a4ffeSShradha Shah efx->type->sriov_fini(efx); 8857fa8d547SShradha Shah 886874aeea5SJeff Kirsher efx_unregister_netdev(efx); 887874aeea5SJeff Kirsher 888874aeea5SJeff Kirsher efx_mtd_remove(efx); 889874aeea5SJeff Kirsher 890874aeea5SJeff Kirsher efx_pci_remove_main(efx); 891874aeea5SJeff Kirsher 89266a65128SEdward Cree efx_fini_io(efx); 893874aeea5SJeff Kirsher netif_dbg(efx, drv, efx->net_dev, "shutdown successful\n"); 894874aeea5SJeff Kirsher 895874aeea5SJeff Kirsher efx_fini_struct(efx); 896874aeea5SJeff Kirsher free_netdev(efx->net_dev); 897626950dbSAlexandre Rames 898626950dbSAlexandre Rames pci_disable_pcie_error_reporting(pci_dev); 899874aeea5SJeff Kirsher }; 900874aeea5SJeff Kirsher 901460eeaa0SBen Hutchings /* NIC VPD information 902460eeaa0SBen Hutchings * Called during probe to display the part number of the 903*5119e20fSHeiner Kallweit * installed NIC. 904460eeaa0SBen Hutchings */ 905ef215e64SBen Hutchings static void efx_probe_vpd_strings(struct efx_nic *efx) 906460eeaa0SBen Hutchings { 907460eeaa0SBen Hutchings struct pci_dev *dev = efx->pci_dev; 908ef215e64SBen Hutchings int ro_start, ro_size, i, j; 909*5119e20fSHeiner Kallweit unsigned int vpd_size; 910*5119e20fSHeiner Kallweit u8 *vpd_data; 911460eeaa0SBen Hutchings 912*5119e20fSHeiner Kallweit vpd_data = pci_vpd_alloc(dev, &vpd_size); 913*5119e20fSHeiner Kallweit if (IS_ERR(vpd_data)) { 914*5119e20fSHeiner Kallweit pci_warn(dev, "Unable to read VPD\n"); 915460eeaa0SBen Hutchings return; 916460eeaa0SBen Hutchings } 917460eeaa0SBen Hutchings 918460eeaa0SBen Hutchings /* Get the Read only section */ 9194cf0abbcSHeiner Kallweit ro_start = pci_vpd_find_tag(vpd_data, vpd_size, PCI_VPD_LRDT_RO_DATA); 920ef215e64SBen Hutchings if (ro_start < 0) { 921460eeaa0SBen Hutchings netif_err(efx, drv, efx->net_dev, "VPD Read-only not found\n"); 922*5119e20fSHeiner Kallweit goto out; 923460eeaa0SBen Hutchings } 924460eeaa0SBen Hutchings 925ef215e64SBen Hutchings ro_size = pci_vpd_lrdt_size(&vpd_data[ro_start]); 926ef215e64SBen Hutchings j = ro_size; 927ef215e64SBen Hutchings i = ro_start + PCI_VPD_LRDT_TAG_SIZE; 928460eeaa0SBen Hutchings if (i + j > vpd_size) 929460eeaa0SBen Hutchings j = vpd_size - i; 930460eeaa0SBen Hutchings 931460eeaa0SBen Hutchings /* Get the Part number */ 932460eeaa0SBen Hutchings i = pci_vpd_find_info_keyword(vpd_data, i, j, "PN"); 933460eeaa0SBen Hutchings if (i < 0) { 934460eeaa0SBen Hutchings netif_err(efx, drv, efx->net_dev, "Part number not found\n"); 935*5119e20fSHeiner Kallweit goto out; 936460eeaa0SBen Hutchings } 937460eeaa0SBen Hutchings 938460eeaa0SBen Hutchings j = pci_vpd_info_field_size(&vpd_data[i]); 939460eeaa0SBen Hutchings i += PCI_VPD_INFO_FLD_HDR_SIZE; 940460eeaa0SBen Hutchings if (i + j > vpd_size) { 941460eeaa0SBen Hutchings netif_err(efx, drv, efx->net_dev, "Incomplete part number\n"); 942*5119e20fSHeiner Kallweit goto out; 943460eeaa0SBen Hutchings } 944460eeaa0SBen Hutchings 945460eeaa0SBen Hutchings netif_info(efx, drv, efx->net_dev, 946460eeaa0SBen Hutchings "Part Number : %.*s\n", j, &vpd_data[i]); 947ef215e64SBen Hutchings 948ef215e64SBen Hutchings i = ro_start + PCI_VPD_LRDT_TAG_SIZE; 949ef215e64SBen Hutchings j = ro_size; 950ef215e64SBen Hutchings i = pci_vpd_find_info_keyword(vpd_data, i, j, "SN"); 951ef215e64SBen Hutchings if (i < 0) { 952ef215e64SBen Hutchings netif_err(efx, drv, efx->net_dev, "Serial number not found\n"); 953*5119e20fSHeiner Kallweit goto out; 954ef215e64SBen Hutchings } 955ef215e64SBen Hutchings 956ef215e64SBen Hutchings j = pci_vpd_info_field_size(&vpd_data[i]); 957ef215e64SBen Hutchings i += PCI_VPD_INFO_FLD_HDR_SIZE; 958ef215e64SBen Hutchings if (i + j > vpd_size) { 959ef215e64SBen Hutchings netif_err(efx, drv, efx->net_dev, "Incomplete serial number\n"); 960*5119e20fSHeiner Kallweit goto out; 961ef215e64SBen Hutchings } 962ef215e64SBen Hutchings 963ef215e64SBen Hutchings efx->vpd_sn = kmalloc(j + 1, GFP_KERNEL); 964ef215e64SBen Hutchings if (!efx->vpd_sn) 965*5119e20fSHeiner Kallweit goto out; 966ef215e64SBen Hutchings 967ef215e64SBen Hutchings snprintf(efx->vpd_sn, j + 1, "%s", &vpd_data[i]); 968*5119e20fSHeiner Kallweit out: 969*5119e20fSHeiner Kallweit kfree(vpd_data); 970460eeaa0SBen Hutchings } 971460eeaa0SBen Hutchings 972460eeaa0SBen Hutchings 973874aeea5SJeff Kirsher /* Main body of NIC initialisation 974874aeea5SJeff Kirsher * This is called at module load (or hotplug insertion, theoretically). 975874aeea5SJeff Kirsher */ 976874aeea5SJeff Kirsher static int efx_pci_probe_main(struct efx_nic *efx) 977874aeea5SJeff Kirsher { 978874aeea5SJeff Kirsher int rc; 979874aeea5SJeff Kirsher 980874aeea5SJeff Kirsher /* Do start-of-day initialisation */ 981874aeea5SJeff Kirsher rc = efx_probe_all(efx); 982874aeea5SJeff Kirsher if (rc) 983874aeea5SJeff Kirsher goto fail1; 984874aeea5SJeff Kirsher 985874aeea5SJeff Kirsher efx_init_napi(efx); 986874aeea5SJeff Kirsher 987193f2003SBert Kenward down_write(&efx->filter_sem); 988874aeea5SJeff Kirsher rc = efx->type->init(efx); 989193f2003SBert Kenward up_write(&efx->filter_sem); 990874aeea5SJeff Kirsher if (rc) { 991fa44821aSHeiner Kallweit pci_err(efx->pci_dev, "failed to initialise NIC\n"); 992874aeea5SJeff Kirsher goto fail3; 993874aeea5SJeff Kirsher } 994874aeea5SJeff Kirsher 995874aeea5SJeff Kirsher rc = efx_init_port(efx); 996874aeea5SJeff Kirsher if (rc) { 997874aeea5SJeff Kirsher netif_err(efx, probe, efx->net_dev, 998874aeea5SJeff Kirsher "failed to initialise port\n"); 999874aeea5SJeff Kirsher goto fail4; 1000874aeea5SJeff Kirsher } 1001874aeea5SJeff Kirsher 1002874aeea5SJeff Kirsher rc = efx_nic_init_interrupt(efx); 1003874aeea5SJeff Kirsher if (rc) 1004874aeea5SJeff Kirsher goto fail5; 1005a83762d9SBert Kenward 1006a83762d9SBert Kenward efx_set_interrupt_affinity(efx); 1007261e4d96SJon Cooper rc = efx_enable_interrupts(efx); 1008261e4d96SJon Cooper if (rc) 1009261e4d96SJon Cooper goto fail6; 1010874aeea5SJeff Kirsher 1011874aeea5SJeff Kirsher return 0; 1012874aeea5SJeff Kirsher 1013261e4d96SJon Cooper fail6: 1014a83762d9SBert Kenward efx_clear_interrupt_affinity(efx); 1015261e4d96SJon Cooper efx_nic_fini_interrupt(efx); 1016874aeea5SJeff Kirsher fail5: 1017874aeea5SJeff Kirsher efx_fini_port(efx); 1018874aeea5SJeff Kirsher fail4: 1019874aeea5SJeff Kirsher efx->type->fini(efx); 1020874aeea5SJeff Kirsher fail3: 1021874aeea5SJeff Kirsher efx_fini_napi(efx); 1022874aeea5SJeff Kirsher efx_remove_all(efx); 1023874aeea5SJeff Kirsher fail1: 1024874aeea5SJeff Kirsher return rc; 1025874aeea5SJeff Kirsher } 1026874aeea5SJeff Kirsher 10278a531400SJon Cooper static int efx_pci_probe_post_io(struct efx_nic *efx) 10288a531400SJon Cooper { 10298a531400SJon Cooper struct net_device *net_dev = efx->net_dev; 10308a531400SJon Cooper int rc = efx_pci_probe_main(efx); 10318a531400SJon Cooper 10328a531400SJon Cooper if (rc) 10338a531400SJon Cooper return rc; 10348a531400SJon Cooper 10358a531400SJon Cooper if (efx->type->sriov_init) { 10368a531400SJon Cooper rc = efx->type->sriov_init(efx); 10378a531400SJon Cooper if (rc) 1038fa44821aSHeiner Kallweit pci_err(efx->pci_dev, "SR-IOV can't be enabled rc %d\n", 1039fa44821aSHeiner Kallweit rc); 10408a531400SJon Cooper } 10418a531400SJon Cooper 10428a531400SJon Cooper /* Determine netdevice features */ 10438a531400SJon Cooper net_dev->features |= (efx->type->offload_features | NETIF_F_SG | 10446978729fSEdward Cree NETIF_F_TSO | NETIF_F_RXCSUM | NETIF_F_RXALL); 10458a531400SJon Cooper if (efx->type->offload_features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM)) 10468a531400SJon Cooper net_dev->features |= NETIF_F_TSO6; 10478a531400SJon Cooper /* Check whether device supports TSO */ 10488a531400SJon Cooper if (!efx->type->tso_versions || !efx->type->tso_versions(efx)) 10498a531400SJon Cooper net_dev->features &= ~NETIF_F_ALL_TSO; 10508a531400SJon Cooper /* Mask for features that also apply to VLAN devices */ 10518a531400SJon Cooper net_dev->vlan_features |= (NETIF_F_HW_CSUM | NETIF_F_SG | 10528a531400SJon Cooper NETIF_F_HIGHDMA | NETIF_F_ALL_TSO | 10538a531400SJon Cooper NETIF_F_RXCSUM); 10548a531400SJon Cooper 10556978729fSEdward Cree net_dev->hw_features |= net_dev->features & ~efx->fixed_features; 10566978729fSEdward Cree 10576978729fSEdward Cree /* Disable receiving frames with bad FCS, by default. */ 10586978729fSEdward Cree net_dev->features &= ~NETIF_F_RXALL; 10598a531400SJon Cooper 10608a531400SJon Cooper /* Disable VLAN filtering by default. It may be enforced if 10618a531400SJon Cooper * the feature is fixed (i.e. VLAN filters are required to 10628a531400SJon Cooper * receive VLAN tagged packets due to vPort restrictions). 10638a531400SJon Cooper */ 10648a531400SJon Cooper net_dev->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; 10658a531400SJon Cooper net_dev->features |= efx->fixed_features; 10668a531400SJon Cooper 10678a531400SJon Cooper rc = efx_register_netdev(efx); 10688a531400SJon Cooper if (!rc) 10698a531400SJon Cooper return 0; 10708a531400SJon Cooper 10718a531400SJon Cooper efx_pci_remove_main(efx); 10728a531400SJon Cooper return rc; 10738a531400SJon Cooper } 10748a531400SJon Cooper 1075874aeea5SJeff Kirsher /* NIC initialisation 1076874aeea5SJeff Kirsher * 1077874aeea5SJeff Kirsher * This is called at module load (or hotplug insertion, 107873ba7b68SBen Hutchings * theoretically). It sets up PCI mappings, resets the NIC, 1079874aeea5SJeff Kirsher * sets up and registers the network devices with the kernel and hooks 1080874aeea5SJeff Kirsher * the interrupt service routine. It does not prepare the device for 1081874aeea5SJeff Kirsher * transmission; this is left to the first time one of the network 1082874aeea5SJeff Kirsher * interfaces is brought up (i.e. efx_net_open). 1083874aeea5SJeff Kirsher */ 108487d1fc11SBill Pemberton static int efx_pci_probe(struct pci_dev *pci_dev, 1085874aeea5SJeff Kirsher const struct pci_device_id *entry) 1086874aeea5SJeff Kirsher { 1087874aeea5SJeff Kirsher struct net_device *net_dev; 1088874aeea5SJeff Kirsher struct efx_nic *efx; 1089fadac6aaSBen Hutchings int rc; 1090874aeea5SJeff Kirsher 1091874aeea5SJeff Kirsher /* Allocate and initialise a struct net_device and struct efx_nic */ 1092874aeea5SJeff Kirsher net_dev = alloc_etherdev_mqs(sizeof(*efx), EFX_MAX_CORE_TX_QUEUES, 1093874aeea5SJeff Kirsher EFX_MAX_RX_QUEUES); 1094874aeea5SJeff Kirsher if (!net_dev) 1095874aeea5SJeff Kirsher return -ENOMEM; 1096adeb15aaSBen Hutchings efx = netdev_priv(net_dev); 1097adeb15aaSBen Hutchings efx->type = (const struct efx_nic_type *) entry->driver_data; 1098ebfcd0fdSAndrew Rybchenko efx->fixed_features |= NETIF_F_HIGHDMA; 1099eb7cfd8cSAndrew Rybchenko 1100874aeea5SJeff Kirsher pci_set_drvdata(pci_dev, efx); 1101874aeea5SJeff Kirsher SET_NETDEV_DEV(net_dev, &pci_dev->dev); 1102adeb15aaSBen Hutchings rc = efx_init_struct(efx, pci_dev, net_dev); 1103874aeea5SJeff Kirsher if (rc) 1104874aeea5SJeff Kirsher goto fail1; 1105874aeea5SJeff Kirsher 1106fa44821aSHeiner Kallweit pci_info(pci_dev, "Solarflare NIC detected\n"); 1107874aeea5SJeff Kirsher 11086f7f8aa6SShradha Shah if (!efx->type->is_vf) 1109ef215e64SBen Hutchings efx_probe_vpd_strings(efx); 1110460eeaa0SBen Hutchings 1111874aeea5SJeff Kirsher /* Set up basic I/O (BAR mappings etc) */ 1112b1940451SAlex Maftei (amaftei) rc = efx_init_io(efx, efx->type->mem_bar(efx), efx->type->max_dma_mask, 1113b1940451SAlex Maftei (amaftei) efx->type->mem_map_size(efx)); 1114874aeea5SJeff Kirsher if (rc) 1115874aeea5SJeff Kirsher goto fail2; 1116874aeea5SJeff Kirsher 11178a531400SJon Cooper rc = efx_pci_probe_post_io(efx); 11188a531400SJon Cooper if (rc) { 11198a531400SJon Cooper /* On failure, retry once immediately. 11208a531400SJon Cooper * If we aborted probe due to a scheduled reset, dismiss it. 11218a531400SJon Cooper */ 11228a531400SJon Cooper efx->reset_pending = 0; 11238a531400SJon Cooper rc = efx_pci_probe_post_io(efx); 11248a531400SJon Cooper if (rc) { 11258a531400SJon Cooper /* On another failure, retry once more 11268a531400SJon Cooper * after a 50-305ms delay. 11278a531400SJon Cooper */ 11288a531400SJon Cooper unsigned char r; 11298a531400SJon Cooper 11308a531400SJon Cooper get_random_bytes(&r, 1); 11318a531400SJon Cooper msleep((unsigned int)r + 50); 11328a531400SJon Cooper efx->reset_pending = 0; 11338a531400SJon Cooper rc = efx_pci_probe_post_io(efx); 11348a531400SJon Cooper } 11358a531400SJon Cooper } 1136fadac6aaSBen Hutchings if (rc) 1137874aeea5SJeff Kirsher goto fail3; 1138874aeea5SJeff Kirsher 1139874aeea5SJeff Kirsher netif_dbg(efx, probe, efx->net_dev, "initialisation successful\n"); 1140874aeea5SJeff Kirsher 11417c43161cSBen Hutchings /* Try to create MTDs, but allow this to fail */ 1142874aeea5SJeff Kirsher rtnl_lock(); 11437c43161cSBen Hutchings rc = efx_mtd_probe(efx); 1144874aeea5SJeff Kirsher rtnl_unlock(); 114509a04204SBert Kenward if (rc && rc != -EPERM) 11467c43161cSBen Hutchings netif_warn(efx, probe, efx->net_dev, 11477c43161cSBen Hutchings "failed to create MTDs (%d)\n", rc); 11487c43161cSBen Hutchings 114905cfee98SMartin Habets (void)pci_enable_pcie_error_reporting(pci_dev); 1150626950dbSAlexandre Rames 1151e5fbd977SJon Cooper if (efx->type->udp_tnl_push_ports) 1152e5fbd977SJon Cooper efx->type->udp_tnl_push_ports(efx); 1153e5fbd977SJon Cooper 1154874aeea5SJeff Kirsher return 0; 1155874aeea5SJeff Kirsher 1156874aeea5SJeff Kirsher fail3: 115766a65128SEdward Cree efx_fini_io(efx); 1158874aeea5SJeff Kirsher fail2: 1159874aeea5SJeff Kirsher efx_fini_struct(efx); 1160874aeea5SJeff Kirsher fail1: 1161874aeea5SJeff Kirsher WARN_ON(rc > 0); 1162874aeea5SJeff Kirsher netif_dbg(efx, drv, efx->net_dev, "initialisation failed. rc=%d\n", rc); 1163874aeea5SJeff Kirsher free_netdev(net_dev); 1164874aeea5SJeff Kirsher return rc; 1165874aeea5SJeff Kirsher } 1166874aeea5SJeff Kirsher 1167834e23ddSShradha Shah /* efx_pci_sriov_configure returns the actual number of Virtual Functions 1168834e23ddSShradha Shah * enabled on success 1169834e23ddSShradha Shah */ 1170834e23ddSShradha Shah #ifdef CONFIG_SFC_SRIOV 1171834e23ddSShradha Shah static int efx_pci_sriov_configure(struct pci_dev *dev, int num_vfs) 1172834e23ddSShradha Shah { 1173834e23ddSShradha Shah int rc; 1174834e23ddSShradha Shah struct efx_nic *efx = pci_get_drvdata(dev); 1175834e23ddSShradha Shah 1176834e23ddSShradha Shah if (efx->type->sriov_configure) { 1177834e23ddSShradha Shah rc = efx->type->sriov_configure(efx, num_vfs); 1178834e23ddSShradha Shah if (rc) 1179834e23ddSShradha Shah return rc; 1180834e23ddSShradha Shah else 1181834e23ddSShradha Shah return num_vfs; 1182834e23ddSShradha Shah } else 1183834e23ddSShradha Shah return -EOPNOTSUPP; 1184834e23ddSShradha Shah } 1185834e23ddSShradha Shah #endif 1186834e23ddSShradha Shah 1187874aeea5SJeff Kirsher static int efx_pm_freeze(struct device *dev) 1188874aeea5SJeff Kirsher { 11893e03a8baSChuhong Yuan struct efx_nic *efx = dev_get_drvdata(dev); 1190874aeea5SJeff Kirsher 119161da026dSBen Hutchings rtnl_lock(); 119261da026dSBen Hutchings 11936032fb56SBen Hutchings if (efx->state != STATE_DISABLED) { 1194f16aeea0SBen Hutchings efx->state = STATE_UNINIT; 1195874aeea5SJeff Kirsher 1196c2f3b8e3SDaniel Pieczko efx_device_detach_sync(efx); 1197874aeea5SJeff Kirsher 1198874aeea5SJeff Kirsher efx_stop_all(efx); 1199d8291187SBen Hutchings efx_disable_interrupts(efx); 12006032fb56SBen Hutchings } 1201874aeea5SJeff Kirsher 120261da026dSBen Hutchings rtnl_unlock(); 120361da026dSBen Hutchings 1204874aeea5SJeff Kirsher return 0; 1205874aeea5SJeff Kirsher } 1206874aeea5SJeff Kirsher 1207874aeea5SJeff Kirsher static int efx_pm_thaw(struct device *dev) 1208874aeea5SJeff Kirsher { 1209261e4d96SJon Cooper int rc; 12103e03a8baSChuhong Yuan struct efx_nic *efx = dev_get_drvdata(dev); 1211874aeea5SJeff Kirsher 121261da026dSBen Hutchings rtnl_lock(); 121361da026dSBen Hutchings 12146032fb56SBen Hutchings if (efx->state != STATE_DISABLED) { 1215261e4d96SJon Cooper rc = efx_enable_interrupts(efx); 1216261e4d96SJon Cooper if (rc) 1217261e4d96SJon Cooper goto fail; 1218874aeea5SJeff Kirsher 1219874aeea5SJeff Kirsher mutex_lock(&efx->mac_lock); 1220c77289b4SEdward Cree efx_mcdi_port_reconfigure(efx); 1221874aeea5SJeff Kirsher mutex_unlock(&efx->mac_lock); 1222874aeea5SJeff Kirsher 1223874aeea5SJeff Kirsher efx_start_all(efx); 1224874aeea5SJeff Kirsher 12259c568fd8SPeter Dunning efx_device_attach_if_not_resetting(efx); 1226874aeea5SJeff Kirsher 1227f16aeea0SBen Hutchings efx->state = STATE_READY; 1228874aeea5SJeff Kirsher 1229874aeea5SJeff Kirsher efx->type->resume_wol(efx); 12306032fb56SBen Hutchings } 1231874aeea5SJeff Kirsher 123261da026dSBen Hutchings rtnl_unlock(); 123361da026dSBen Hutchings 1234874aeea5SJeff Kirsher /* Reschedule any quenched resets scheduled during efx_pm_freeze() */ 123582c64484SAlex Maftei (amaftei) efx_queue_reset_work(efx); 1236874aeea5SJeff Kirsher 1237874aeea5SJeff Kirsher return 0; 1238261e4d96SJon Cooper 1239261e4d96SJon Cooper fail: 1240261e4d96SJon Cooper rtnl_unlock(); 1241261e4d96SJon Cooper 1242261e4d96SJon Cooper return rc; 1243874aeea5SJeff Kirsher } 1244874aeea5SJeff Kirsher 1245874aeea5SJeff Kirsher static int efx_pm_poweroff(struct device *dev) 1246874aeea5SJeff Kirsher { 1247874aeea5SJeff Kirsher struct pci_dev *pci_dev = to_pci_dev(dev); 1248874aeea5SJeff Kirsher struct efx_nic *efx = pci_get_drvdata(pci_dev); 1249874aeea5SJeff Kirsher 1250874aeea5SJeff Kirsher efx->type->fini(efx); 1251874aeea5SJeff Kirsher 1252874aeea5SJeff Kirsher efx->reset_pending = 0; 1253874aeea5SJeff Kirsher 1254874aeea5SJeff Kirsher pci_save_state(pci_dev); 1255874aeea5SJeff Kirsher return pci_set_power_state(pci_dev, PCI_D3hot); 1256874aeea5SJeff Kirsher } 1257874aeea5SJeff Kirsher 1258874aeea5SJeff Kirsher /* Used for both resume and restore */ 1259874aeea5SJeff Kirsher static int efx_pm_resume(struct device *dev) 1260874aeea5SJeff Kirsher { 1261874aeea5SJeff Kirsher struct pci_dev *pci_dev = to_pci_dev(dev); 1262874aeea5SJeff Kirsher struct efx_nic *efx = pci_get_drvdata(pci_dev); 1263874aeea5SJeff Kirsher int rc; 1264874aeea5SJeff Kirsher 1265874aeea5SJeff Kirsher rc = pci_set_power_state(pci_dev, PCI_D0); 1266874aeea5SJeff Kirsher if (rc) 1267874aeea5SJeff Kirsher return rc; 1268874aeea5SJeff Kirsher pci_restore_state(pci_dev); 1269874aeea5SJeff Kirsher rc = pci_enable_device(pci_dev); 1270874aeea5SJeff Kirsher if (rc) 1271874aeea5SJeff Kirsher return rc; 1272874aeea5SJeff Kirsher pci_set_master(efx->pci_dev); 1273874aeea5SJeff Kirsher rc = efx->type->reset(efx, RESET_TYPE_ALL); 1274874aeea5SJeff Kirsher if (rc) 1275874aeea5SJeff Kirsher return rc; 1276193f2003SBert Kenward down_write(&efx->filter_sem); 1277874aeea5SJeff Kirsher rc = efx->type->init(efx); 1278193f2003SBert Kenward up_write(&efx->filter_sem); 1279874aeea5SJeff Kirsher if (rc) 1280874aeea5SJeff Kirsher return rc; 1281261e4d96SJon Cooper rc = efx_pm_thaw(dev); 1282261e4d96SJon Cooper return rc; 1283874aeea5SJeff Kirsher } 1284874aeea5SJeff Kirsher 1285874aeea5SJeff Kirsher static int efx_pm_suspend(struct device *dev) 1286874aeea5SJeff Kirsher { 1287874aeea5SJeff Kirsher int rc; 1288874aeea5SJeff Kirsher 1289874aeea5SJeff Kirsher efx_pm_freeze(dev); 1290874aeea5SJeff Kirsher rc = efx_pm_poweroff(dev); 1291874aeea5SJeff Kirsher if (rc) 1292874aeea5SJeff Kirsher efx_pm_resume(dev); 1293874aeea5SJeff Kirsher return rc; 1294874aeea5SJeff Kirsher } 1295874aeea5SJeff Kirsher 129618e83e4cSBen Hutchings static const struct dev_pm_ops efx_pm_ops = { 1297874aeea5SJeff Kirsher .suspend = efx_pm_suspend, 1298874aeea5SJeff Kirsher .resume = efx_pm_resume, 1299874aeea5SJeff Kirsher .freeze = efx_pm_freeze, 1300874aeea5SJeff Kirsher .thaw = efx_pm_thaw, 1301874aeea5SJeff Kirsher .poweroff = efx_pm_poweroff, 1302874aeea5SJeff Kirsher .restore = efx_pm_resume, 1303874aeea5SJeff Kirsher }; 1304874aeea5SJeff Kirsher 1305874aeea5SJeff Kirsher static struct pci_driver efx_pci_driver = { 1306874aeea5SJeff Kirsher .name = KBUILD_MODNAME, 1307874aeea5SJeff Kirsher .id_table = efx_pci_table, 1308874aeea5SJeff Kirsher .probe = efx_pci_probe, 1309874aeea5SJeff Kirsher .remove = efx_pci_remove, 1310874aeea5SJeff Kirsher .driver.pm = &efx_pm_ops, 1311626950dbSAlexandre Rames .err_handler = &efx_err_handlers, 1312834e23ddSShradha Shah #ifdef CONFIG_SFC_SRIOV 1313834e23ddSShradha Shah .sriov_configure = efx_pci_sriov_configure, 1314834e23ddSShradha Shah #endif 1315874aeea5SJeff Kirsher }; 1316874aeea5SJeff Kirsher 1317874aeea5SJeff Kirsher /************************************************************************** 1318874aeea5SJeff Kirsher * 1319874aeea5SJeff Kirsher * Kernel module interface 1320874aeea5SJeff Kirsher * 1321874aeea5SJeff Kirsher *************************************************************************/ 1322874aeea5SJeff Kirsher 1323874aeea5SJeff Kirsher static int __init efx_init_module(void) 1324874aeea5SJeff Kirsher { 1325874aeea5SJeff Kirsher int rc; 1326874aeea5SJeff Kirsher 132760bd2a2dSEdward Cree printk(KERN_INFO "Solarflare NET driver\n"); 1328874aeea5SJeff Kirsher 1329874aeea5SJeff Kirsher rc = register_netdevice_notifier(&efx_netdev_notifier); 1330874aeea5SJeff Kirsher if (rc) 1331874aeea5SJeff Kirsher goto err_notifier; 1332874aeea5SJeff Kirsher 13337fa8d547SShradha Shah #ifdef CONFIG_SFC_SRIOV 1334cd2d5b52SBen Hutchings rc = efx_init_sriov(); 1335cd2d5b52SBen Hutchings if (rc) 1336cd2d5b52SBen Hutchings goto err_sriov; 13377fa8d547SShradha Shah #endif 1338cd2d5b52SBen Hutchings 133982c64484SAlex Maftei (amaftei) rc = efx_create_reset_workqueue(); 134082c64484SAlex Maftei (amaftei) if (rc) 1341874aeea5SJeff Kirsher goto err_reset; 1342874aeea5SJeff Kirsher 1343874aeea5SJeff Kirsher rc = pci_register_driver(&efx_pci_driver); 1344874aeea5SJeff Kirsher if (rc < 0) 1345874aeea5SJeff Kirsher goto err_pci; 1346874aeea5SJeff Kirsher 134751b35a45SEdward Cree rc = pci_register_driver(&ef100_pci_driver); 134851b35a45SEdward Cree if (rc < 0) 134951b35a45SEdward Cree goto err_pci_ef100; 135051b35a45SEdward Cree 1351874aeea5SJeff Kirsher return 0; 1352874aeea5SJeff Kirsher 135351b35a45SEdward Cree err_pci_ef100: 135451b35a45SEdward Cree pci_unregister_driver(&efx_pci_driver); 1355874aeea5SJeff Kirsher err_pci: 135682c64484SAlex Maftei (amaftei) efx_destroy_reset_workqueue(); 1357874aeea5SJeff Kirsher err_reset: 13587fa8d547SShradha Shah #ifdef CONFIG_SFC_SRIOV 1359cd2d5b52SBen Hutchings efx_fini_sriov(); 1360cd2d5b52SBen Hutchings err_sriov: 13617fa8d547SShradha Shah #endif 1362874aeea5SJeff Kirsher unregister_netdevice_notifier(&efx_netdev_notifier); 1363874aeea5SJeff Kirsher err_notifier: 1364874aeea5SJeff Kirsher return rc; 1365874aeea5SJeff Kirsher } 1366874aeea5SJeff Kirsher 1367874aeea5SJeff Kirsher static void __exit efx_exit_module(void) 1368874aeea5SJeff Kirsher { 1369874aeea5SJeff Kirsher printk(KERN_INFO "Solarflare NET driver unloading\n"); 1370874aeea5SJeff Kirsher 137151b35a45SEdward Cree pci_unregister_driver(&ef100_pci_driver); 1372874aeea5SJeff Kirsher pci_unregister_driver(&efx_pci_driver); 137382c64484SAlex Maftei (amaftei) efx_destroy_reset_workqueue(); 13747fa8d547SShradha Shah #ifdef CONFIG_SFC_SRIOV 1375cd2d5b52SBen Hutchings efx_fini_sriov(); 13767fa8d547SShradha Shah #endif 1377874aeea5SJeff Kirsher unregister_netdevice_notifier(&efx_netdev_notifier); 1378874aeea5SJeff Kirsher 1379874aeea5SJeff Kirsher } 1380874aeea5SJeff Kirsher 1381874aeea5SJeff Kirsher module_init(efx_init_module); 1382874aeea5SJeff Kirsher module_exit(efx_exit_module); 1383874aeea5SJeff Kirsher 1384874aeea5SJeff Kirsher MODULE_AUTHOR("Solarflare Communications and " 1385874aeea5SJeff Kirsher "Michael Brown <mbrown@fensystems.co.uk>"); 13866a350fdbSBen Hutchings MODULE_DESCRIPTION("Solarflare network driver"); 1387874aeea5SJeff Kirsher MODULE_LICENSE("GPL"); 1388874aeea5SJeff Kirsher MODULE_DEVICE_TABLE(pci, efx_pci_table); 1389