probe

1

/**
 * ixgbe_probe - Device Initialization Routine
 * @pdev: PCI device information struct
 * @ent: entry in ixgbe_pci_tbl
 *
 * Returns 0 on success, negative on failure
 *
 * ixgbe_probe initializes an adapter identified by a pci_dev structure.
 * The OS initialization, configuring of the adapter private structure,
 * and a hardware reset occur.
 **/
static int __devinit ixgbe_probe(struct pci_dev *pdev,
                 const struct pci_device_id *ent)
{
    struct net_device *netdev;
    struct ixgbe_adapter *adapter = NULL;
    struct ixgbe_hw *hw = NULL;
    static int cards_found;
    int i, err, pci_using_dac;
#ifdef HAVE_TX_MQ         // 多队列发送
    unsigned int indices;
#endif
    u8 part_str[IXGBE_PBANUM_LENGTH];
    enum ixgbe_mac_type mac_type = ixgbe_mac_unknown;
#ifdef IXGBE_FCOE
    u16 device_caps;
#endif

    err = pci_enable_device_mem(pdev);
    if (err)
        return err;

    if (!dma_set_mask(pci_dev_to_dev(pdev), DMA_BIT_MASK(64)) &&
        !dma_set_coherent_mask(pci_dev_to_dev(pdev), DMA_BIT_MASK(64))) {
        pci_using_dac = 1;// dac?
// netdevice.h
// #define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
    } else {
        err = dma_set_mask(pci_dev_to_dev(pdev), DMA_BIT_MASK(32));
        if (err) {
            err = dma_set_coherent_mask(pci_dev_to_dev(pdev),
                                              DMA_BIT_MASK(32));
            if (err) {
                dev_err(pci_dev_to_dev(pdev), "No usable DMA "
                        "configuration, aborting\n");
                goto err_dma;
            }
        }
        pci_using_dac = 0;
    }

    err = pci_request_selected_regions(pdev, pci_select_bars(pdev,
                       IORESOURCE_MEM), ixgbe_driver_name);
    if (err) {
        dev_err(pci_dev_to_dev(pdev),
            "pci_request_selected_regions failed 0x%x\n", err);
        goto err_pci_reg;
    }

    /*
     * The mac_type is needed before we have the adapter is  set up
     * so rather than maintain two devID -> MAC tables we dummy up
     * an ixgbe_hw stuct and use ixgbe_set_mac_type.
     */
    hw = vmalloc(sizeof(struct ixgbe_hw));
    if (!hw) {
        printk(KERN_INFO "Unable to allocate memory for early mac "
            "check\n");
    } else {
        hw->vendor_id = pdev->vendor;
        hw->device_id = pdev->device;
        ixgbe_set_mac_type(hw);
        mac_type = hw->mac.type;
        vfree(hw);
    }

    /*
     * Workaround of Silicon errata on 82598. Disable LOs in the PCI switch
     * port to which the 82598 is connected to prevent duplicate
     * completions caused by LOs.  We need the mac type so that we only
     * do this on 82598 devices, ixgbe_set_mac_type does this for us if
     * we set it's device ID.
     */
    if (mac_type == ixgbe_mac_82598EB)
        pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S);

    pci_enable_pcie_error_reporting(pdev);

    pci_set_master(pdev);

#ifdef HAVE_TX_MQ
    indices = num_possible_cpus();// 支持HT,可能是num_online_cpu()的两倍，尽管bios没有开启HT
    if (mac_type == ixgbe_mac_unknown)
        indices = max_t(unsigned int, IXGBE_MAX_RSS_INDICES,
                IXGBE_MAX_FDIR_INDICES);
    else if (mac_type == ixgbe_mac_82598EB)
        indices = min_t(unsigned int, indices, IXGBE_MAX_RSS_INDICES);
    else
        indices = min_t(unsigned int, indices, IXGBE_MAX_FDIR_INDICES);
    indices = max_t(unsigned int, indices, IXGBE_MAX_DCB_INDICES);
#ifdef IXGBE_FCOE
    indices += min_t(unsigned int, num_possible_cpus(),
              IXGBE_MAX_FCOE_INDICES);
#endif
    netdev = alloc_etherdev_mq(sizeof(struct ixgbe_adapter), indices);
#else
    netdev = alloc_etherdev(sizeof(struct ixgbe_adapter));
#endif
    if (!netdev) {
        err = -ENOMEM;
        goto err_alloc_etherdev;
    }

    SET_NETDEV_DEV(netdev, &pdev->dev);

    adapter = netdev_priv(netdev);
    pci_set_drvdata(pdev, adapter);

    adapter->netdev = netdev;
    adapter->pdev = pdev;
    hw = &adapter->hw;
    hw->back = adapter;
    adapter->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
// msg_enable的作用？
// ixgbe_ethtool_ops
// .get_msglevel           = ixgbe_get_msglevel,
// .set_msglevel           = ixgbe_set_msglevel,

#ifdef HAVE_DEVICE_NUMA_NODE // NUMA暂时放过
    DPRINTK(TX_ERR, INFO, "my (original) node was: %d\n",
            dev_to_node(&pdev->dev));
#endif /* HAVE_DEVICE_NUMA_NODE */

#ifdef HAVE_PCI_ERS
    /*
     * call save state here in standalone driver because it relies on
     * adapter struct to exist, and needs to call netdev_priv
     */
    pci_save_state(pdev);

#endif
    hw->hw_addr = ioremap(pci_resource_start(pdev, 0),
                  pci_resource_len(pdev, 0)); // 可以使用内存地址访问寄存器了
    if (!hw->hw_addr) {
        err = -EIO;
        goto err_ioremap;
    }

    ixgbe_assign_netdev_ops(netdev);

    strcpy(netdev->name, pci_name(pdev));

    adapter->bd_number = cards_found;// 网卡芯片数量

    /* setup the private structure */
    err = ixgbe_sw_init(adapter); // 这个下次再细看
    if (err)
        goto err_sw_init;

    /* Make it possible the adapter to be woken up via WOL */
    // wol没有细看
    if (adapter->hw.mac.type == ixgbe_mac_82599EB)
        IXGBE_WRITE_REG(&adapter->hw, IXGBE_WUS, ~0);


    /*
     * If we have a fan, this is as early we know, warn if we
     * have had a failure.
     */ // 风扇相关的功能?
    if (adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE) {
        u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
        if (esdp & IXGBE_ESDP_SDP1)
            DPRINTK(PROBE, CRIT,
                "Fan has stopped, replace the adapter\n");
    }

    /* reset_hw fills in the perm_addr as well */
    hw->phy.reset_if_overtemp = true;
    err = hw->mac.ops.reset_hw(hw); // mac的reset做了些什么
    hw->phy.reset_if_overtemp = false; // 为什么又该为false
    if (err == IXGBE_ERR_SFP_NOT_PRESENT &&
        hw->mac.type == ixgbe_mac_82598EB) {
        err = 0;
    } else if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
        DPRINTK(PROBE, ERR, "failed to load because an "
                "unsupported SFP+ module type was detected.\n"
                "Reload the driver after installing a "
                "supported module.\n");
        goto err_sw_init;
    } else if (err) {
        DPRINTK(PROBE, ERR, "HW Init failed: %d\n", err);
        goto err_sw_init;
    }

    /*
     * check_options must be called before setup_link to set up
     * hw->fc completely
     */
    ixgbe_check_options(adapter);// 检查insmod时传入的参数

    DPRINTK(TX_ERR, INFO, "my (preferred) node is: %d\n", adapter->node);

    if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) // 虚拟化不看了
        ixgbe_probe_vf(adapter);

#ifdef MAX_SKB_FRAGS // 定义了，但具体是多少呢？
#ifdef NETIF_F_HW_VLAN_TX
    netdev->features = NETIF_F_SG |   // sg具体到代码是指什么？支持skb的frags、dma_maps？
               NETIF_F_IP_CSUM |        // 网卡计算IP校验和？还是软件计算？
               NETIF_F_HW_VLAN_TX |     // /* Transmit VLAN hw acceleration */
               NETIF_F_HW_VLAN_RX |     // /* Receive VLAN hw acceleration */
               NETIF_F_HW_VLAN_FILTER;  // /* Receive filtering on VLAN */

#else
    netdev->features = NETIF_F_SG | NETIF_F_IP_CSUM;

#endif
#ifdef NETIF_F_IPV6_CSUM
    netdev->features |= NETIF_F_IPV6_CSUM;
#endif
#ifdef NETIF_F_TSO
    netdev->features |= NETIF_F_TSO;
#ifdef NETIF_F_TSO6
    netdev->features |= NETIF_F_TSO6;
#endif /* NETIF_F_TSO6 */
#endif /* NETIF_F_TSO */
#ifdef NETIF_F_GRO
    netdev->features |= NETIF_F_GRO;
#endif /* NETIF_F_GRO */

    if (adapter->hw.mac.type == ixgbe_mac_82599EB)
        netdev->features |= NETIF_F_SCTP_CSUM;

#ifdef HAVE_NETDEV_VLAN_FEATURES
#ifdef NETIF_F_TSO
    netdev->vlan_features |= NETIF_F_TSO;
#ifdef NETIF_F_TSO6
    netdev->vlan_features |= NETIF_F_TSO6;
#endif /* NETIF_F_TSO6 */
#endif /* NETIF_F_TSO */
    netdev->vlan_features |= NETIF_F_IP_CSUM;
#ifdef NETIF_F_IPV6_CSUM
    netdev->vlan_features |= NETIF_F_IPV6_CSUM;
#endif
    netdev->vlan_features |= NETIF_F_SG;

#endif /* HAVE_NETDEV_VLAN_FEATURES */
#ifdef NETIF_F_NTUPLE
    /*
     * If perfect filters were enabled in check_options(), enable them
     * on the netdevice too.
     */
    if (adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE)
        netdev->features |= NETIF_F_NTUPLE;
#endif /* NETIF_F_NTUPLE */
    if (adapter->flags & IXGBE_FLAG_VMDQ_ENABLED)
        adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
    if (adapter->flags & IXGBE_FLAG_DCB_ENABLED)
        adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
    if (adapter->flags & IXGBE_FLAG_VMDQ_ENABLED) {
        adapter->flags &= ~(IXGBE_FLAG_FDIR_HASH_CAPABLE
                    | IXGBE_FLAG_FDIR_PERFECT_CAPABLE);
#ifdef NETIF_F_NTUPLE
        /* clear n-tuple support in the netdev unconditionally */
        netdev->features &= ~NETIF_F_NTUPLE;
#endif /* NETIF_F_NTUPLE */
    }

    if (adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE) {
        netdev->features |= NETIF_F_LRO;
        adapter->flags2 &= ~IXGBE_FLAG2_SWLRO_ENABLED;
        if (adapter->rx_itr_setting == 0 ||
            adapter->rx_itr_setting > IXGBE_MAX_RSC_INT_RATE) {
            adapter->flags2 &= ~IXGBE_FLAG2_RSC_ENABLED;
            DPRINTK(PROBE, INFO,
                 "InterruptThrottleRate set too high, disabling RSC\n");
        } else {
            adapter->flags2 |= IXGBE_FLAG2_RSC_ENABLED;
        }
    } else {
#ifndef IXGBE_NO_LRO
        netdev->features |= NETIF_F_LRO;
        adapter->flags2 |= IXGBE_FLAG2_SWLRO_ENABLED;
#endif
        adapter->flags2 &= ~IXGBE_FLAG2_RSC_ENABLED;
    }
#ifdef CONFIG_DCB
    netdev->dcbnl_ops = &dcbnl_ops;
#endif

#ifdef IXGBE_FCOE  // FCOE Fiber Connect over Ethernet
#ifdef NETIF_F_FSO
    if (adapter->flags & IXGBE_FLAG_FCOE_CAPABLE) {
        ixgbe_get_device_caps(hw, &device_caps);
        if (device_caps & IXGBE_DEVICE_CAPS_FCOE_OFFLOADS) {
            adapter->flags &= ~IXGBE_FLAG_FCOE_ENABLED;
            adapter->flags &= ~IXGBE_FLAG_FCOE_CAPABLE;
            DPRINTK(PROBE, INFO, "FCoE offload feature "
                "is not available. Disabling FCoE "
                "offload feature\n");
        }
#ifndef HAVE_NETDEV_OPS_FCOE_ENABLE
        else {
            adapter->flags |= IXGBE_FLAG_FCOE_ENABLED;
            adapter->ring_feature[RING_F_FCOE].indices =
                    IXGBE_FCRETA_SIZE;
            netdev->features |= NETIF_F_FSO;
            netdev->features |= NETIF_F_FCOE_CRC;
            netdev->features |= NETIF_F_FCOE_MTU;
            netdev->fcoe_ddp_xid = IXGBE_FCOE_DDP_MAX - 1;
            DPRINTK(PROBE, INFO, "Enabling FCoE offload "
                "feature\n");
        }
#endif /* HAVE_NETDEV_OPS_FCOE_ENABLE */
    }
#ifdef HAVE_NETDEV_VLAN_FEATURES
    if (adapter->flags & IXGBE_FLAG_FCOE_CAPABLE) {
        netdev->vlan_features |= NETIF_F_FSO;
        netdev->vlan_features |= NETIF_F_FCOE_CRC;
        netdev->vlan_features |= NETIF_F_FCOE_MTU;
    }
#endif /* HAVE_NETDEV_VLAN_FEATURES */
#endif /* NETIF_F_FSO */
#endif /* IXGBE_FCOE */
    if (pci_using_dac) {
        netdev->features |= NETIF_F_HIGHDMA;
#ifdef HAVE_NETDEV_VLAN_FEATURES
        netdev->vlan_features |= NETIF_F_HIGHDMA;
#endif /* HAVE_NETDEV_VLAN_FEATURES */
    }

#endif /* MAX_SKB_FRAGS */
    /* make sure the EEPROM is good */
    if (hw->eeprom.ops.validate_checksum &&
        (hw->eeprom.ops.validate_checksum(hw, NULL) < 0)) {
        DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
        err = -EIO;
        goto err_sw_init;
    }

    memcpy(netdev->dev_addr, hw->mac.perm_addr, netdev->addr_len);
#ifdef ETHTOOL_GPERMADDR
    memcpy(netdev->perm_addr, hw->mac.perm_addr, netdev->addr_len);

    if (ixgbe_validate_mac_addr(netdev->perm_addr)) {
        DPRINTK(PROBE, INFO, "invalid MAC address\n");
        err = -EIO;
        goto err_sw_init;
    }
#else
    if (ixgbe_validate_mac_addr(netdev->dev_addr)) {
        DPRINTK(PROBE, INFO, "invalid MAC address\n");
        err = -EIO;
        goto err_sw_init;
    }
#endif

    /* power down the optics */
    if (hw->phy.multispeed_fiber)
        ixgbe_disable_tx_laser(hw);

    setup_timer(&adapter->service_timer, &ixgbe_service_timer,
                (unsigned long) adapter);
    // 用于启动ixgbe_service_task

    INIT_WORK(&adapter->service_task, ixgbe_service_task);
    // 后台操作都放在ixgbe_service_task
    clear_bit(__IXGBE_SERVICE_SCHED, &adapter->state);

     // 在这里获取msix中断号

    err = ixgbe_init_interrupt_scheme(adapter);
    if (err)
        goto err_sw_init;

    /* WOL not supported for all but the following */
    adapter->wol = 0;
    switch (pdev->device) {
    case IXGBE_DEV_ID_82599_SFP:
        /* Only this subdevice supports WOL */
        if (pdev->subsystem_device == IXGBE_SUBDEV_ID_82599_SFP)
            adapter->wol = (IXGBE_WUFC_MAG | IXGBE_WUFC_EX |
                            IXGBE_WUFC_MC | IXGBE_WUFC_BC);
        break;
    case IXGBE_DEV_ID_82599_COMBO_BACKPLANE:
        /* All except this subdevice support WOL */
        if (pdev->subsystem_device != IXGBE_SUBDEV_ID_82599_KX4_KR_MEZZ)
            adapter->wol = (IXGBE_WUFC_MAG | IXGBE_WUFC_EX |
                            IXGBE_WUFC_MC | IXGBE_WUFC_BC);
        break;
    case IXGBE_DEV_ID_82599_KX4:
        adapter->wol = (IXGBE_WUFC_MAG | IXGBE_WUFC_EX |
                        IXGBE_WUFC_MC | IXGBE_WUFC_BC);
        break;
    }
    device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);

    /* save off EEPROM version number */
    ixgbe_read_eeprom(hw, 0x29, &adapter->eeprom_version);

    /* reset the hardware with the new settings */
    err = hw->mac.ops.start_hw(hw);
    if (err == IXGBE_ERR_EEPROM_VERSION) {
        /* We are running on a pre-production device, log a warning */
        DPRINTK(PROBE, INFO, "This device is a pre-production adapter/"
                "LOM.  Please be aware there may be issues associated "
                "with your hardware.  If you are experiencing problems "
                "please contact your Intel or hardware representative "
                "who provided you with this hardware.\n");
    }
    /* pick up the PCI bus settings for reporting later */
    if (hw->mac.ops.get_bus_info)
        hw->mac.ops.get_bus_info(hw);


    strcpy(netdev->name, "eth%d");
    err = register_netdev(netdev);    // 注册net_device
    if (err)
        goto err_register;

    adapter->netdev_registered = true;
    /* carrier off reporting is important to ethtool even BEFORE open */
    netif_carrier_off(netdev);
    /* keep stopping all the transmit queues for older kernels */
    netif_tx_stop_all_queues(netdev);

    if (adapter->flags & IXGBE_FLAG_DCA_CAPABLE) {
        err = dca_add_requester(&pdev->dev);
        switch (err) {
        case 0:
            adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
            ixgbe_setup_dca(adapter);
            break;
        /* -19 is returned from the kernel when no provider is found */
        case -19:
            DPRINTK(PROBE, INFO, "No DCA provider found.  Please "
                    "start ioatdma for DCA functionality.\n");
            break;
        default:
            DPRINTK(PROBE, INFO, "DCA registration failed: %d\n",
                    err);
            break;
        }
    }

    /* print all messages at the end so that we use our eth%d name */
    /* print bus type/speed/width info */
    DPRINTK(PROBE, INFO, "(PCI Express:%s:%s) ",
        (hw->bus.speed == ixgbe_bus_speed_5000 ? "5.0Gb/s" :
         hw->bus.speed == ixgbe_bus_speed_2500 ? "2.5Gb/s" :
         "Unknown"),
        (hw->bus.width == ixgbe_bus_width_pcie_x8 ? "Width x8" :
         hw->bus.width == ixgbe_bus_width_pcie_x4 ? "Width x4" :
         hw->bus.width == ixgbe_bus_width_pcie_x1 ? "Width x1" :
         "Unknown"));

    /* print the MAC address */
    for (i = 0; i < 6; i++)
        printk("%2.2x%c", netdev->dev_addr[i], i == 5 ? '\n' : ':');

    /* Frist try to read PBA as a string */
    err = ixgbe_read_pba_string(hw, part_str, IXGBE_PBANUM_LENGTH);
    if (err)
        strcpy(part_str, "Unknown");
    if (ixgbe_is_sfp(hw) && hw->phy.sfp_type != ixgbe_sfp_type_not_present)
        DPRINTK(PROBE, INFO, "MAC: %d, PHY: %d, SFP+: %d, PBA No: %s\n",
                hw->mac.type, hw->phy.type, hw->phy.sfp_type,
                part_str);
    else
        DPRINTK(PROBE, INFO, "MAC: %d, PHY: %d, PBA No: %s\n",
                hw->mac.type, hw->phy.type, part_str);

    if (((hw->bus.speed == ixgbe_bus_speed_2500) &&
         (hw->bus.width <= ixgbe_bus_width_pcie_x4)) ||
        (hw->bus.width <= ixgbe_bus_width_pcie_x2)) {
        DPRINTK(PROBE, WARNING, "PCI-Express bandwidth available for "
            "this card is not sufficient for optimal "
            "performance.\n");
        DPRINTK(PROBE, WARNING, "For optimal performance a x8 "
            "PCI-Express slot is required.\n");
    }

#ifdef NETIF_F_GRO
    if (adapter->netdev->features & NETIF_F_GRO)
        DPRINTK(PROBE, INFO, "GRO is enabled\n");
    else if (adapter->flags2 & IXGBE_FLAG2_SWLRO_ENABLED)
#else
    if (adapter->flags2 & IXGBE_FLAG2_SWLRO_ENABLED)
#endif
        DPRINTK(PROBE, INFO, "Internal LRO is enabled \n");
    else
        DPRINTK(PROBE, INFO, "LRO is disabled \n");

    if (adapter->flags2 & IXGBE_FLAG2_RSC_ENABLED)
        DPRINTK(PROBE, INFO, "HW RSC is enabled \n");
#ifdef CONFIG_PCI_IOV
    if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) {
        DPRINTK(PROBE, INFO, "IOV is enabled with %d VFs\n",
            adapter->num_vfs);
        for (i = 0; i < adapter->num_vfs; i++)
            ixgbe_vf_configuration(pdev, (i | 0x10000000));
    }
#endif

#if defined(HAVE_NETDEV_STORAGE_ADDRESS) && defined(NETDEV_HW_ADDR_T_SAN)
    /* add san mac addr to netdev */
    ixgbe_add_sanmac_netdev(netdev);

#endif /* (HAVE_NETDEV_STORAGE_ADDRESS) && (NETDEV_HW_ADDR_T_SAN) */
    DPRINTK(PROBE, INFO, "Intel(R) 10 Gigabit Network Connection\n");
    cards_found++;
    return 0;

err_register:
    ixgbe_clear_interrupt_scheme(adapter);
    ixgbe_release_hw_control(adapter);
err_sw_init:
    if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED)
        ixgbe_disable_sriov(adapter);
    adapter->flags2 &= ~IXGBE_FLAG2_SEARCH_FOR_SFP;
    iounmap(hw->hw_addr);
err_ioremap:
    free_netdev(netdev);
err_alloc_etherdev:
    pci_release_selected_regions(pdev,
                     pci_select_bars(pdev, IORESOURCE_MEM));
err_pci_reg:
err_dma:

    pci_disable_device(pdev);
    return err;
}