drivers/net/ethernet/intel/fm10k/fm10k_pci.c

   1 /* Intel Ethernet Switch Host Interface Driver
   2  * Copyright(c) 2013 - 2014 Intel Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * The full GNU General Public License is included in this distribution in
  14  * the file called "COPYING".
  15  *
  16  * Contact Information:
  17  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  18  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  19  */
  20
  21 #include <linux/module.h>
  22
  23 #include "fm10k.h"
  24
  25 static const struct fm10k_info *fm10k_info_tbl[] = {
  26         [fm10k_device_pf] = &fm10k_pf_info,
  27 };
  28
  29 /**
  30  * fm10k_pci_tbl - PCI Device ID Table
  31  *
  32  * Wildcard entries (PCI_ANY_ID) should come last
  33  * Last entry must be all 0s
  34  *
  35  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  36  *   Class, Class Mask, private data (not used) }
  37  */
  38 static const struct pci_device_id fm10k_pci_tbl[] = {
  39         { PCI_VDEVICE(INTEL, FM10K_DEV_ID_PF), fm10k_device_pf },
  40         /* required last entry */
  41         { 0, }
  42 };
  43 MODULE_DEVICE_TABLE(pci, fm10k_pci_tbl);
  44
  45 u16 fm10k_read_pci_cfg_word(struct fm10k_hw *hw, u32 reg)
  46 {
  47         struct fm10k_intfc *interface = hw->back;
  48         u16 value = 0;
  49
  50         if (FM10K_REMOVED(hw->hw_addr))
  51                 return ~value;
  52
  53         pci_read_config_word(interface->pdev, reg, &value);
  54         if (value == 0xFFFF)
  55                 fm10k_write_flush(hw);
  56
  57         return value;
  58 }
  59
  60 u32 fm10k_read_reg(struct fm10k_hw *hw, int reg)
  61 {
  62         u32 __iomem *hw_addr = ACCESS_ONCE(hw->hw_addr);
  63         u32 value = 0;
  64
  65         if (FM10K_REMOVED(hw_addr))
  66                 return ~value;
  67
  68         value = readl(&hw_addr[reg]);
  69         if (!(~value) && (!reg || !(~readl(hw_addr)))) {
  70                 struct fm10k_intfc *interface = hw->back;
  71                 struct net_device *netdev = interface->netdev;
  72
  73                 hw->hw_addr = NULL;
  74                 netif_device_detach(netdev);
  75                 netdev_err(netdev, "PCIe link lost, device now detached\n");
  76         }
  77
  78         return value;
  79 }
  80
  81 static int fm10k_hw_ready(struct fm10k_intfc *interface)
  82 {
  83         struct fm10k_hw *hw = &interface->hw;
  84
  85         fm10k_write_flush(hw);
  86
  87         return FM10K_REMOVED(hw->hw_addr) ? -ENODEV : 0;
  88 }
  89
  90 void fm10k_up(struct fm10k_intfc *interface)
  91 {
  92         struct fm10k_hw *hw = &interface->hw;
  93
  94         /* Enable Tx/Rx DMA */
  95         hw->mac.ops.start_hw(hw);
  96
  97         /* configure interrupts */
  98         hw->mac.ops.update_int_moderator(hw);
  99
 100         /* clear down bit to indicate we are ready to go */
 101         clear_bit(__FM10K_DOWN, &interface->state);
 102
 103         /* re-establish Rx filters */
 104         fm10k_restore_rx_state(interface);
 105
 106         /* enable transmits */
 107         netif_tx_start_all_queues(interface->netdev);
 108 }
 109
 110 void fm10k_down(struct fm10k_intfc *interface)
 111 {
 112         struct net_device *netdev = interface->netdev;
 113         struct fm10k_hw *hw = &interface->hw;
 114
 115         /* signal that we are down to the interrupt handler and service task */
 116         set_bit(__FM10K_DOWN, &interface->state);
 117
 118         /* call carrier off first to avoid false dev_watchdog timeouts */
 119         netif_carrier_off(netdev);
 120
 121         /* disable transmits */
 122         netif_tx_stop_all_queues(netdev);
 123         netif_tx_disable(netdev);
 124
 125         /* reset Rx filters */
 126         fm10k_reset_rx_state(interface);
 127
 128         /* allow 10ms for device to quiesce */
 129         usleep_range(10000, 20000);
 130
 131         /* Disable DMA engine for Tx/Rx */
 132         hw->mac.ops.stop_hw(hw);
 133 }
 134
 135 /**
 136  * fm10k_sw_init - Initialize general software structures
 137  * @interface: host interface private structure to initialize
 138  *
 139  * fm10k_sw_init initializes the interface private data structure.
 140  * Fields are initialized based on PCI device information and
 141  * OS network device settings (MTU size).
 142  **/
 143 static int fm10k_sw_init(struct fm10k_intfc *interface,
 144                          const struct pci_device_id *ent)
 145 {
 146         static const u32 seed[FM10K_RSSRK_SIZE] = { 0xda565a6d, 0xc20e5b25,
 147                                                     0x3d256741, 0xb08fa343,
 148                                                     0xcb2bcad0, 0xb4307bae,
 149                                                     0xa32dcb77, 0x0cf23080,
 150                                                     0x3bb7426a, 0xfa01acbe };
 151         const struct fm10k_info *fi = fm10k_info_tbl[ent->driver_data];
 152         struct fm10k_hw *hw = &interface->hw;
 153         struct pci_dev *pdev = interface->pdev;
 154         struct net_device *netdev = interface->netdev;
 155         unsigned int rss;
 156         int err;
 157
 158         /* initialize back pointer */
 159         hw->back = interface;
 160         hw->hw_addr = interface->uc_addr;
 161
 162         /* PCI config space info */
 163         hw->vendor_id = pdev->vendor;
 164         hw->device_id = pdev->device;
 165         hw->revision_id = pdev->revision;
 166         hw->subsystem_vendor_id = pdev->subsystem_vendor;
 167         hw->subsystem_device_id = pdev->subsystem_device;
 168
 169         /* Setup hw api */
 170         memcpy(&hw->mac.ops, fi->mac_ops, sizeof(hw->mac.ops));
 171         hw->mac.type = fi->mac;
 172
 173         /* Set common capability flags and settings */
 174         rss = min_t(int, FM10K_MAX_RSS_INDICES, num_online_cpus());
 175         interface->ring_feature[RING_F_RSS].limit = rss;
 176         fi->get_invariants(hw);
 177
 178         /* pick up the PCIe bus settings for reporting later */
 179         if (hw->mac.ops.get_bus_info)
 180                 hw->mac.ops.get_bus_info(hw);
 181
 182         /* limit the usable DMA range */
 183         if (hw->mac.ops.set_dma_mask)
 184                 hw->mac.ops.set_dma_mask(hw, dma_get_mask(&pdev->dev));
 185
 186         /* update netdev with DMA restrictions */
 187         if (dma_get_mask(&pdev->dev) > DMA_BIT_MASK(32)) {
 188                 netdev->features |= NETIF_F_HIGHDMA;
 189                 netdev->vlan_features |= NETIF_F_HIGHDMA;
 190         }
 191
 192         /* reset and initialize the hardware so it is in a known state */
 193         err = hw->mac.ops.reset_hw(hw) ? : hw->mac.ops.init_hw(hw);
 194         if (err) {
 195                 dev_err(&pdev->dev, "init_hw failed: %d\n", err);
 196                 return err;
 197         }
 198
 199         /* initialize hardware statistics */
 200         hw->mac.ops.update_hw_stats(hw, &interface->stats);
 201
 202         /* Start with random Ethernet address */
 203         eth_random_addr(hw->mac.addr);
 204
 205         /* Initialize MAC address from hardware */
 206         err = hw->mac.ops.read_mac_addr(hw);
 207         if (err) {
 208                 dev_warn(&pdev->dev,
 209                          "Failed to obtain MAC address defaulting to random\n");
 210                 /* tag address assignment as random */
 211                 netdev->addr_assign_type |= NET_ADDR_RANDOM;
 212         }
 213
 214         memcpy(netdev->dev_addr, hw->mac.addr, netdev->addr_len);
 215         memcpy(netdev->perm_addr, hw->mac.addr, netdev->addr_len);
 216
 217         if (!is_valid_ether_addr(netdev->perm_addr)) {
 218                 dev_err(&pdev->dev, "Invalid MAC Address\n");
 219                 return -EIO;
 220         }
 221
 222         /* Only the PF can support VXLAN and NVGRE offloads */
 223         if (hw->mac.type != fm10k_mac_pf) {
 224                 netdev->hw_enc_features = 0;
 225                 netdev->features &= ~NETIF_F_GSO_UDP_TUNNEL;
 226                 netdev->hw_features &= ~NETIF_F_GSO_UDP_TUNNEL;
 227         }
 228
 229         /* initialize vxlan_port list */
 230         INIT_LIST_HEAD(&interface->vxlan_port);
 231
 232         /* initialize RSS key */
 233         memcpy(interface->rssrk, seed, sizeof(seed));
 234
 235         /* Start off interface as being down */
 236         set_bit(__FM10K_DOWN, &interface->state);
 237
 238         return 0;
 239 }
 240
 241 static void fm10k_slot_warn(struct fm10k_intfc *interface)
 242 {
 243         struct device *dev = &interface->pdev->dev;
 244         struct fm10k_hw *hw = &interface->hw;
 245
 246         if (hw->mac.ops.is_slot_appropriate(hw))
 247                 return;
 248
 249         dev_warn(dev,
 250                  "For optimal performance, a %s %s slot is recommended.\n",
 251                  (hw->bus_caps.width == fm10k_bus_width_pcie_x1 ? "x1" :
 252                   hw->bus_caps.width == fm10k_bus_width_pcie_x4 ? "x4" :
 253                   "x8"),
 254                  (hw->bus_caps.speed == fm10k_bus_speed_2500 ? "2.5GT/s" :
 255                   hw->bus_caps.speed == fm10k_bus_speed_5000 ? "5.0GT/s" :
 256                   "8.0GT/s"));
 257         dev_warn(dev,
 258                  "A slot with more lanes and/or higher speed is suggested.\n");
 259 }
 260
 261 /**
 262  * fm10k_probe - Device Initialization Routine
 263  * @pdev: PCI device information struct
 264  * @ent: entry in fm10k_pci_tbl
 265  *
 266  * Returns 0 on success, negative on failure
 267  *
 268  * fm10k_probe initializes an interface identified by a pci_dev structure.
 269  * The OS initialization, configuring of the interface private structure,
 270  * and a hardware reset occur.
 271  **/
 272 static int fm10k_probe(struct pci_dev *pdev,
 273                        const struct pci_device_id *ent)
 274 {
 275         struct net_device *netdev;
 276         struct fm10k_intfc *interface;
 277         struct fm10k_hw *hw;
 278         int err;
 279         u64 dma_mask;
 280
 281         err = pci_enable_device_mem(pdev);
 282         if (err)
 283                 return err;
 284
 285         /* By default fm10k only supports a 48 bit DMA mask */
 286         dma_mask = DMA_BIT_MASK(48) | dma_get_required_mask(&pdev->dev);
 287
 288         if ((dma_mask <= DMA_BIT_MASK(32)) ||
 289             dma_set_mask_and_coherent(&pdev->dev, dma_mask)) {
 290                 dma_mask &= DMA_BIT_MASK(32);
 291
 292                 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 293                 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
 294                 if (err) {
 295                         err = dma_set_coherent_mask(&pdev->dev,
 296                                                     DMA_BIT_MASK(32));
 297                         if (err) {
 298                                 dev_err(&pdev->dev,
 299                                         "No usable DMA configuration, aborting\n");
 300                                 goto err_dma;
 301                         }
 302                 }
 303         }
 304
 305         err = pci_request_selected_regions(pdev,
 306                                            pci_select_bars(pdev,
 307                                                            IORESOURCE_MEM),
 308                                            fm10k_driver_name);
 309         if (err) {
 310                 dev_err(&pdev->dev,
 311                         "pci_request_selected_regions failed 0x%x\n", err);
 312                 goto err_pci_reg;
 313         }
 314
 315         pci_set_master(pdev);
 316         pci_save_state(pdev);
 317
 318         netdev = fm10k_alloc_netdev();
 319         if (!netdev) {
 320                 err = -ENOMEM;
 321                 goto err_alloc_netdev;
 322         }
 323
 324         SET_NETDEV_DEV(netdev, &pdev->dev);
 325
 326         interface = netdev_priv(netdev);
 327         pci_set_drvdata(pdev, interface);
 328
 329         interface->netdev = netdev;
 330         interface->pdev = pdev;
 331         hw = &interface->hw;
 332
 333         interface->uc_addr = ioremap(pci_resource_start(pdev, 0),
 334                                      FM10K_UC_ADDR_SIZE);
 335         if (!interface->uc_addr) {
 336                 err = -EIO;
 337                 goto err_ioremap;
 338         }
 339
 340         err = fm10k_sw_init(interface, ent);
 341         if (err)
 342                 goto err_sw_init;
 343
 344         /* final check of hardware state before registering the interface */
 345         err = fm10k_hw_ready(interface);
 346         if (err)
 347                 goto err_register;
 348
 349         err = register_netdev(netdev);
 350         if (err)
 351                 goto err_register;
 352
 353         /* carrier off reporting is important to ethtool even BEFORE open */
 354         netif_carrier_off(netdev);
 355
 356         /* stop all the transmit queues from transmitting until link is up */
 357         netif_tx_stop_all_queues(netdev);
 358
 359         /* print bus type/speed/width info */
 360         dev_info(&pdev->dev, "(PCI Express:%s Width: %s Payload: %s)\n",
 361                  (hw->bus.speed == fm10k_bus_speed_8000 ? "8.0GT/s" :
 362                   hw->bus.speed == fm10k_bus_speed_5000 ? "5.0GT/s" :
 363                   hw->bus.speed == fm10k_bus_speed_2500 ? "2.5GT/s" :
 364                   "Unknown"),
 365                  (hw->bus.width == fm10k_bus_width_pcie_x8 ? "x8" :
 366                   hw->bus.width == fm10k_bus_width_pcie_x4 ? "x4" :
 367                   hw->bus.width == fm10k_bus_width_pcie_x1 ? "x1" :
 368                   "Unknown"),
 369                  (hw->bus.payload == fm10k_bus_payload_128 ? "128B" :
 370                   hw->bus.payload == fm10k_bus_payload_256 ? "256B" :
 371                   hw->bus.payload == fm10k_bus_payload_512 ? "512B" :
 372                   "Unknown"));
 373
 374         /* print warning for non-optimal configurations */
 375         fm10k_slot_warn(interface);
 376
 377         return 0;
 378
 379 err_register:
 380 err_sw_init:
 381         iounmap(interface->uc_addr);
 382 err_ioremap:
 383         free_netdev(netdev);
 384 err_alloc_netdev:
 385         pci_release_selected_regions(pdev,
 386                                      pci_select_bars(pdev, IORESOURCE_MEM));
 387 err_pci_reg:
 388 err_dma:
 389         pci_disable_device(pdev);
 390         return err;
 391 }
 392
 393 /**
 394  * fm10k_remove - Device Removal Routine
 395  * @pdev: PCI device information struct
 396  *
 397  * fm10k_remove is called by the PCI subsystem to alert the driver
 398  * that it should release a PCI device.  The could be caused by a
 399  * Hot-Plug event, or because the driver is going to be removed from
 400  * memory.
 401  **/
 402 static void fm10k_remove(struct pci_dev *pdev)
 403 {
 404         struct fm10k_intfc *interface = pci_get_drvdata(pdev);
 405         struct net_device *netdev = interface->netdev;
 406
 407         /* free netdev, this may bounce the interrupts due to setup_tc */
 408         if (netdev->reg_state == NETREG_REGISTERED)
 409                 unregister_netdev(netdev);
 410
 411         iounmap(interface->uc_addr);
 412
 413         free_netdev(netdev);
 414
 415         pci_release_selected_regions(pdev,
 416                                      pci_select_bars(pdev, IORESOURCE_MEM));
 417
 418         pci_disable_device(pdev);
 419 }
 420
 421 static struct pci_driver fm10k_driver = {
 422         .name                   = fm10k_driver_name,
 423         .id_table               = fm10k_pci_tbl,
 424         .probe                  = fm10k_probe,
 425         .remove                 = fm10k_remove,
 426 };
 427
 428 /**
 429  * fm10k_register_pci_driver - register driver interface
 430  *
 431  * This funciton is called on module load in order to register the driver.
 432  **/
 433 int fm10k_register_pci_driver(void)
 434 {
 435         return pci_register_driver(&fm10k_driver);
 436 }
 437
 438 /**
 439  * fm10k_unregister_pci_driver - unregister driver interface
 440  *
 441  * This funciton is called on module unload in order to remove the driver.
 442  **/
 443 void fm10k_unregister_pci_driver(void)
 444 {
 445         pci_unregister_driver(&fm10k_driver);
 446 }