• 了解ixgbe网卡驱动— 驱动注册（纯代码分享）

    1 ixgbe 网卡注册驱动

    和大部分设备驱动一样，网卡驱动是作为一个 module 注册到 kernel 的
    通过 module_init() -> ixgbe_init_module() -> pci_register_driver() 注册 ixgbe_driver
    通过 module_exit() -> ixgbe_exit_module() -> pci_unregister_driver() 注销 ixgbe_driver

    1.1 ixgbe_driver 类

    1. static struct pci_driver ixgbe_driver = {
    2. 	.name     = ixgbe_driver_name,
    3. 	.id_table = ixgbe_pci_tbl,
    4. 	.probe    = ixgbe_probe,// 系统探测到ixgbe网卡后调用ixgbe_probe()
    5. 	.remove   = ixgbe_remove,
    6. #ifdef CONFIG_PM
    7. 	.suspend  = ixgbe_suspend,
    8. 	.resume   = ixgbe_resume,
    9. #endif
    10. 	.shutdown = ixgbe_shutdown,
    11. 	.sriov_configure = ixgbe_pci_sriov_configure,
    12. 	.err_handler = &ixgbe_err_handler
    13. };

    1.2 ixgbe_driver 注册/注销

    1. /**
    2.  * ixgbe_init_module - Driver Registration Routine
    3.  *
    4.  * ixgbe_init_module is the first routine called when the driver is
    5.  * loaded. All it does is register with the PCI subsystem.
    6.  **/
    7. static int __init ixgbe_init_module(void)
    8. {
    9. 	int ret;
    10. 	pr_info("%s - version %s\n", ixgbe_driver_string, ixgbe_driver_version);
    11. 	pr_info("%s\n", ixgbe_copyright);
    12.  
    13. 	ixgbe_wq = create_singlethread_workqueue(ixgbe_driver_name);
    14. 	if (!ixgbe_wq) {
    15. 		pr_err("%s: Failed to create workqueue\n", ixgbe_driver_name);
    16. 		return -ENOMEM;
    17. 	}
    18.  
    19. 	ixgbe_dbg_init();
    20.  
    21. 	ret = pci_register_driver(&ixgbe_driver); //注册ixgbe_driver
    22. 	if (ret) {
    23. 		destroy_workqueue(ixgbe_wq);
    24. 		ixgbe_dbg_exit();
    25. 		return ret;
    26. 	}
    27.  
    28. #ifdef CONFIG_IXGBE_DCA
    29. 	dca_register_notify(&dca_notifier);
    30. #endif
    31.  
    32. 	return 0;
    33. }
    34.  
    35. module_init(ixgbe_init_module);
    36.  
    37. /**
    38.  * ixgbe_exit_module - Driver Exit Cleanup Routine
    39.  *
    40.  * ixgbe_exit_module is called just before the driver is removed
    41.  * from memory.
    42.  **/
    43. static void __exit ixgbe_exit_module(void)
    44. {
    45. #ifdef CONFIG_IXGBE_DCA
    46. 	dca_unregister_notify(&dca_notifier);
    47. #endif
    48. 	pci_unregister_driver(&ixgbe_driver); //注销 ixgbe_driver
    49.  
    50. 	ixgbe_dbg_exit();
    51. 	if (ixgbe_wq) {
    52. 		destroy_workqueue(ixgbe_wq);
    53. 		ixgbe_wq = NULL;
    54. 	}
    55. }
    56.  
    57. module_exit(ixgbe_exit_module);

    2 ixgbe 的 PCI 注册驱动流程 pci_register_driver()

    1. pci_register_driver() ->
    2. __pci_register_driver() ->
    3. driver_register() ->
    4. bus_add_driver() ->
    5. driver_attach() ->
    6. bus_for_each_dev() ->
    7. __driver_attach() ->
    8. driver_probe_device() ->
    9. really_probe() ->
    10. pci_device_probe() ->
    11. __pci_device_probe() ->
    12. pci_call_probe() ->
    13. local_pci_probe()
    14.  
    15. static long local_pci_probe(void *_ddi)
    16. {
    17. 	...
    18. 	rc = pci_drv->probe(pci_dev, ddi->id); // 系统探测到设备后调用设备驱动的probe
    19. 	...
    20. }
    【文章福利】小编推荐自己的Linux内核技术交流群： 【977878001】整理一些个人觉得比较好得学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100进群领取，额外赠送一份 价值699的内核资料包（含视频教程、电子书、实战项目及代码）

    内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

    学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

    3 ixgbe 网卡探测 ixgbe_probe()【核心】

    1. /**
    2.  * ixgbe_probe - Device Initialization Routine
    3.  * @pdev: PCI device information struct
    4.  * @ent: entry in ixgbe_pci_tbl
    5.  *
    6.  * Returns 0 on success, negative on failure
    7.  *
    8.  * ixgbe_probe initializes an adapter identified by a pci_dev structure.
    9.  * The OS initialization, configuring of the adapter private structure,
    10.  * and a hardware reset occur.
    11.  **/
    12. static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
    13. {
    14. 	struct net_device *netdev;
    15. 	struct ixgbe_adapter *adapter = NULL;
    16. 	struct ixgbe_hw *hw;
    17. 	const struct ixgbe_info *ii = ixgbe_info_tbl[ent->driver_data];//根据网卡型号（82598/82599）选择ixgbe_info
    18. 	int i, err, pci_using_dac, expected_gts;
    19. 	unsigned int indices = MAX_TX_QUEUES;
    20. 	u8 part_str[IXGBE_PBANUM_LENGTH];
    21. 	bool disable_dev = false;
    22. #ifdef IXGBE_FCOE
    23. 	u16 device_caps;
    24. #endif
    25. 	u32 eec;
    26.  
    27. 	/* Catch broken hardware that put the wrong VF device ID in
    28. 	 * the PCIe SR-IOV capability.
    29. 	 */
    30. 	if (pdev->is_virtfn) {
    31. 		WARN(1, KERN_ERR "%s (%hx:%hx) should not be a VF!\n",
    32. 		     pci_name(pdev), pdev->vendor, pdev->device);
    33. 		return -EINVAL;
    34. 	}
    35.  
    36. 	/* pci_enable_device_mem() -> __pci_enable_device_flags() -> do_pci_enable_device()
    37. 		-> pcibios_enable_device() -> pci_enable_resources() -> pci_write_config_word()
    38. 		向配置寄存器Command（0x04）中写入 PCI_COMMAND_MEMORY（0x2），允许网卡驱动访问网卡的Memory空间 */
    39. 	err = pci_enable_device_mem(pdev);
    40. 	if (err)
    41. 		return err;
    42.  
    43.    /* pci_set_dma_mask() -> dma_set_mask() -> dma_supported()
    44.       检查并设置PCI总线地址位数 */
    45. 	if (!dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) {
    46. 		pci_using_dac = 1;
    47. 	} else {
    48. 		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
    49. 		if (err) {
    50. 			dev_err(&pdev->dev,
    51. 				"No usable DMA configuration, aborting\n");
    52. 			goto err_dma;
    53. 		}
    54. 		pci_using_dac = 0;
    55. 	}
    56.  
    57.  
    58.    /* pci_request_mem_regions() -> pci_request_selected_regions() -> __pci_request_selected_regions()
    59. 		-> __pci_request_region()-> request_region()/__request_mem_region()
    60. 		-> __request_region() -> __request_resource()
    61.       登记BAR中的总线地址（将resource插入iomem_resource资源树） */
    62. 	err = pci_request_mem_regions(pdev, ixgbe_driver_name);
    63. 	if (err) {
    64. 		dev_err(&pdev->dev,
    65. 			"pci_request_selected_regions failed 0x%x\n", err);
    66. 		goto err_pci_reg;
    67. 	}
    68.  
    69. 	pci_enable_pcie_error_reporting(pdev);
    70. 	
    71. 	/* pci_set_master() -> __pci_set_master() -> pci_write_config_word()
    72.        向配置寄存器Command（0x04）中写入PCI_COMMAND_MASTER（0x4），允许网卡申请PCI总线控制权 */
    73. 	pci_set_master(pdev);
    74. 	
    75.  
    76.    /* pci_save_state() -> pci_read_config_dword()
    77.       读取并保存配置空间到dev->saved_config_space */	
    78. 	pci_save_state(pdev);
    79.  
    80. 	if (ii->mac == ixgbe_mac_82598EB) {
    81. #ifdef CONFIG_IXGBE_DCB
    82. 		/* 8 TC w/ 4 queues per TC */
    83. 		indices = 4 * MAX_TRAFFIC_CLASS;
    84. #else
    85. 		indices = IXGBE_MAX_RSS_INDICES;
    86. #endif
    87. 	}
    88.  
    89. 	// 分配net_device和ixgbe_adapter，发送队列数为 indices
    90. 	netdev = alloc_etherdev_mq(sizeof(struct ixgbe_adapter), indices);
    91. 	if (!netdev) {
    92. 		err = -ENOMEM;
    93. 		goto err_alloc_etherdev;
    94. 	}
    95.  
    96. 	SET_NETDEV_DEV(netdev, &pdev->dev);
    97.  
    98. 	adapter = netdev_priv(netdev); //得到ixgbe_adapter的指针
    99.  
    100. 	adapter->netdev = netdev;
    101. 	adapter->pdev = pdev;
    102. 	hw = &adapter->hw;	//得到ixgbe_hw的指针
    103. 	hw->back = adapter;
    104. 	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
    105.  
    106.  
    107.    // 将BAR0中的总线地址映射成内存地址，赋给hw->hw_addr，允许网卡驱动通过hw->hw_addr访问网卡的BAR0对应的Memory空间
    108. 	hw->hw_addr = ioremap(pci_resource_start(pdev, 0),
    109. 			      pci_resource_len(pdev, 0));
    110. 	adapter->io_addr = hw->hw_addr;
    111. 	if (!hw->hw_addr) {
    112. 		err = -EIO;
    113. 		goto err_ioremap;
    114. 	}
    115.  
    116. 	netdev->netdev_ops = &ixgbe_netdev_ops;// 注册ixgbe_netdev_ops
    117. 	ixgbe_set_ethtool_ops(netdev);
    118. 	netdev->watchdog_timeo = 5 * HZ;
    119. 	strlcpy(netdev->name, pci_name(pdev), sizeof(netdev->name));
    120.  
    121. 	/* Setup hw api */
    122. 	hw->mac.ops   = *ii->mac_ops;
    123. 	hw->mac.type  = ii->mac;
    124. 	hw->mvals     = ii->mvals;
    125. 	if (ii->link_ops)
    126. 		hw->link.ops  = *ii->link_ops;
    127.  
    128. 	/* EEPROM */
    129. 	hw->eeprom.ops = *ii->eeprom_ops;
    130. 	eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw));// 读取BAR0对应的Memory空间的IXGBE_EEC
    131. 	if (ixgbe_removed(hw->hw_addr)) {
    132. 		err = -EIO;
    133. 		goto err_ioremap;
    134. 	}
    135. 	/* If EEPROM is valid (bit 8 = 1), use default otherwise use bit bang */
    136. 	if (!(eec & BIT(8)))
    137. 		hw->eeprom.ops.read = &ixgbe_read_eeprom_bit_bang_generic;
    138.  
    139. 	/* PHY */
    140. 	hw->phy.ops = *ii->phy_ops;
    141. 	hw->phy.sfp_type = ixgbe_sfp_type_unknown;
    142. 	/* ixgbe_identify_phy_generic will set prtad and mmds properly */
    143. 	hw->phy.mdio.prtad = MDIO_PRTAD_NONE;
    144. 	hw->phy.mdio.mmds = 0;
    145. 	hw->phy.mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
    146. 	hw->phy.mdio.dev = netdev;
    147. 	hw->phy.mdio.mdio_read = ixgbe_mdio_read;
    148. 	hw->phy.mdio.mdio_write = ixgbe_mdio_write;
    149.  
    150. 	/* setup the private structure */
    151.     /* 初始化ixgbe_adapter：
    152.       设置adapter->tx/rx_ring_count为1024（默认1024，最小64，最大4096）
    153.       设置adapter->ring_feature[RING_F_RSS].indices为min(CPU数, IXGBE_MAX_RSS_INDICES(16))
    154.       设置adapter->ring_feature[RING_F_FDIR].indices为IXGBE_MAX_FDIR_INDICES(64)
    155.       设置adapter->flags的IXGBE_FLAG_RSS_ENABLED和IXGBE_FLAG_FDIR_HASH_CAPABLE */
    156. 	err = ixgbe_sw_init(adapter, ii);
    157. 	if (err)
    158. 		goto err_sw_init;
    159.  
    160. 	/* Make sure the SWFW semaphore is in a valid state */
    161. 	if (hw->mac.ops.init_swfw_sync)
    162. 		hw->mac.ops.init_swfw_sync(hw);
    163.  
    164. 	/* Make it possible the adapter to be woken up via WOL */
    165. 	switch (adapter->hw.mac.type) {
    166. 	case ixgbe_mac_82599EB:
    167. 	case ixgbe_mac_X540:
    168. 	case ixgbe_mac_X550:
    169. 	case ixgbe_mac_X550EM_x:
    170. 	case ixgbe_mac_x550em_a:
    171. 		IXGBE_WRITE_REG(&adapter->hw, IXGBE_WUS, ~0);
    172. 		break;
    173. 	default:
    174. 		break;
    175. 	}
    176.  
    177. 	/*
    178. 	 * If there is a fan on this device and it has failed log the
    179. 	 * failure.
    180. 	 */
    181. 	if (adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE) {
    182. 		u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
    183. 		if (esdp & IXGBE_ESDP_SDP1)
    184. 			e_crit(probe, "Fan has stopped, replace the adapter\n");
    185. 	}
    186.  
    187. 	if (allow_unsupported_sfp)
    188. 		hw->allow_unsupported_sfp = allow_unsupported_sfp;
    189.  
    190. 	/* reset_hw fills in the perm_addr as well */
    191. 	hw->phy.reset_if_overtemp = true;
    192.  
    193.    /* ixgbe_reset_hw_82599() -> ixgbe_get_mac_addr_generic()
    194.       读取eeprom中的mac地址，写入hw->mac.perm_addr */
    195. 	err = hw->mac.ops.reset_hw(hw);
    196.  
    197. 	hw->phy.reset_if_overtemp = false;
    198. 	ixgbe_set_eee_capable(adapter);
    199. 	if (err == IXGBE_ERR_SFP_NOT_PRESENT) {
    200. 		err = 0;
    201. 	} else if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
    202. 		e_dev_err("failed to load because an unsupported SFP+ or QSFP module type was detected.\n");
    203. 		e_dev_err("Reload the driver after installing a supported module.\n");
    204. 		goto err_sw_init;
    205. 	} else if (err) {
    206. 		e_dev_err("HW Init failed: %d\n", err);
    207. 		goto err_sw_init;
    208. 	}
    209.  
    210. #ifdef CONFIG_PCI_IOV
    211. 	/* SR-IOV not supported on the 82598 */
    212. 	if (adapter->hw.mac.type == ixgbe_mac_82598EB)
    213. 		goto skip_sriov;
    214. 	/* Mailbox */
    215. 	ixgbe_init_mbx_params_pf(hw);
    216. 	hw->mbx.ops = ii->mbx_ops;
    217. 	pci_sriov_set_totalvfs(pdev, IXGBE_MAX_VFS_DRV_LIMIT);
    218. 	ixgbe_enable_sriov(adapter, max_vfs);
    219. skip_sriov:
    220.  
    221. #endif
    222. 	netdev->features = NETIF_F_SG |
    223. 			   NETIF_F_TSO |
    224. 			   NETIF_F_TSO6 |
    225. 			   NETIF_F_RXHASH |
    226. 			   NETIF_F_RXCSUM |
    227. 			   NETIF_F_HW_CSUM;
    228.  
    229. #define IXGBE_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \
    230. 				    NETIF_F_GSO_GRE_CSUM | \
    231. 				    NETIF_F_GSO_IPXIP4 | \
    232. 				    NETIF_F_GSO_IPXIP6 | \
    233. 				    NETIF_F_GSO_UDP_TUNNEL | \
    234. 				    NETIF_F_GSO_UDP_TUNNEL_CSUM)
    235.  
    236. 	netdev->gso_partial_features = IXGBE_GSO_PARTIAL_FEATURES;
    237. 	netdev->features |= NETIF_F_GSO_PARTIAL |
    238. 			    IXGBE_GSO_PARTIAL_FEATURES;
    239.  
    240. 	if (hw->mac.type >= ixgbe_mac_82599EB)
    241. 		netdev->features |= NETIF_F_SCTP_CRC;
    242.  
    243. 	/* copy netdev features into list of user selectable features */
    244. 	netdev->hw_features |= netdev->features |
    245. 			       NETIF_F_HW_VLAN_CTAG_FILTER |
    246. 			       NETIF_F_HW_VLAN_CTAG_RX |
    247. 			       NETIF_F_HW_VLAN_CTAG_TX |
    248. 			       NETIF_F_RXALL |
    249. 			       NETIF_F_HW_L2FW_DOFFLOAD;
    250.  
    251. 	if (hw->mac.type >= ixgbe_mac_82599EB)
    252. 		netdev->hw_features |= NETIF_F_NTUPLE |
    253. 				       NETIF_F_HW_TC;
    254.  
    255. 	if (pci_using_dac)
    256. 		netdev->features |= NETIF_F_HIGHDMA;
    257.  
    258. 	netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID;
    259. 	netdev->hw_enc_features |= netdev->vlan_features;
    260. 	netdev->mpls_features |= NETIF_F_SG |
    261. 				 NETIF_F_TSO |
    262. 				 NETIF_F_TSO6 |
    263. 				 NETIF_F_HW_CSUM;
    264. 	netdev->mpls_features |= IXGBE_GSO_PARTIAL_FEATURES;
    265.  
    266. 	/* set this bit last since it cannot be part of vlan_features */
    267. 	netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER |
    268. 			    NETIF_F_HW_VLAN_CTAG_RX |
    269. 			    NETIF_F_HW_VLAN_CTAG_TX;
    270.  
    271. 	netdev->priv_flags |= IFF_UNICAST_FLT;
    272. 	netdev->priv_flags |= IFF_SUPP_NOFCS;
    273.  
    274. 	/* MTU range: 68 - 9710 */
    275. 	netdev->min_mtu = ETH_MIN_MTU;
    276. 	netdev->max_mtu = IXGBE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN);
    277.  
    278. #ifdef CONFIG_IXGBE_DCB
    279. 	if (adapter->flags & IXGBE_FLAG_DCB_CAPABLE)
    280. 		netdev->dcbnl_ops = &ixgbe_dcbnl_ops;
    281. #endif
    282.  
    283. #ifdef IXGBE_FCOE
    284. 	if (adapter->flags & IXGBE_FLAG_FCOE_CAPABLE) {
    285. 		unsigned int fcoe_l;
    286.  
    287. 		if (hw->mac.ops.get_device_caps) {
    288. 			hw->mac.ops.get_device_caps(hw, &device_caps);
    289. 			if (device_caps & IXGBE_DEVICE_CAPS_FCOE_OFFLOADS)
    290. 				adapter->flags &= ~IXGBE_FLAG_FCOE_CAPABLE;
    291. 		}
    292.  
    293.  
    294. 		fcoe_l = min_t(int, IXGBE_FCRETA_SIZE, num_online_cpus());
    295. 		adapter->ring_feature[RING_F_FCOE].limit = fcoe_l;
    296.  
    297. 		netdev->features |= NETIF_F_FSO |
    298. 				    NETIF_F_FCOE_CRC;
    299.  
    300. 		netdev->vlan_features |= NETIF_F_FSO |
    301. 					 NETIF_F_FCOE_CRC |
    302. 					 NETIF_F_FCOE_MTU;
    303. 	}
    304. #endif /* IXGBE_FCOE */
    305.  
    306. 	if (adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE)
    307. 		netdev->hw_features |= NETIF_F_LRO;
    308. 	if (adapter->flags2 & IXGBE_FLAG2_RSC_ENABLED)
    309. 		netdev->features |= NETIF_F_LRO;
    310.  
    311. 	/* make sure the EEPROM is good */
    312. 	if (hw->eeprom.ops.validate_checksum(hw, NULL) < 0) {
    313. 		e_dev_err("The EEPROM Checksum Is Not Valid\n");
    314. 		err = -EIO;
    315. 		goto err_sw_init;
    316. 	}
    317.  
    318. 	eth_platform_get_mac_address(&adapter->pdev->dev,
    319. 				     adapter->hw.mac.perm_addr);
    320.  
    321. 	memcpy(netdev->dev_addr, hw->mac.perm_addr, netdev->addr_len);
    322.  
    323. 	if (!is_valid_ether_addr(netdev->dev_addr)) {
    324. 		e_dev_err("invalid MAC address\n");
    325. 		err = -EIO;
    326. 		goto err_sw_init;
    327. 	}
    328.  
    329. 	/* Set hw->mac.addr to permanent MAC address */
    330. 	ether_addr_copy(hw->mac.addr, hw->mac.perm_addr);
    331. 	ixgbe_mac_set_default_filter(adapter);
    332.  
    333. 	setup_timer(&adapter->service_timer, &ixgbe_service_timer,
    334. 		    (unsigned long) adapter);
    335.  
    336. 	if (ixgbe_removed(hw->hw_addr)) {
    337. 		err = -EIO;
    338. 		goto err_sw_init;
    339. 	}
    340. 	INIT_WORK(&adapter->service_task, ixgbe_service_task);
    341. 	set_bit(__IXGBE_SERVICE_INITED, &adapter->state);
    342. 	clear_bit(__IXGBE_SERVICE_SCHED, &adapter->state);
    343.  
    344.    /* ixgbe_init_interrupt_scheme() -> ixgbe_set_num_queues() -> ixgbe_set_fdir_queues()/ixgbe_set_rss_queues()
    345.                                        ixgbe_set_interrupt_capability() -> ixgbe_acquire_msix_vectors() -> pci_enable_msix()
    346.                                        ixgbe_alloc_q_vectors()
    347.       根据FDIR/RSS设置adapter->num_tx/rx_queues
    348.       向PCI子系统请求中断
    349.       设置poll函数，分配ixgbe_q_vector，初始化napi并加入napi_list
    350.       分配发送/接收ring数组 */
    351. 	err = ixgbe_init_interrupt_scheme(adapter);
    352. 	if (err)
    353. 		goto err_sw_init;
    354.  
    355. 	for (i = 0; i < adapter->num_rx_queues; i++)
    356. 		u64_stats_init(&adapter->rx_ring[i]->syncp);
    357. 	for (i = 0; i < adapter->num_tx_queues; i++)
    358. 		u64_stats_init(&adapter->tx_ring[i]->syncp);
    359. 	for (i = 0; i < adapter->num_xdp_queues; i++)
    360. 		u64_stats_init(&adapter->xdp_ring[i]->syncp);
    361.  
    362. 	/* WOL not supported for all devices */
    363. 	adapter->wol = 0;
    364. 	hw->eeprom.ops.read(hw, 0x2c, &adapter->eeprom_cap);
    365. 	hw->wol_enabled = ixgbe_wol_supported(adapter, pdev->device,
    366. 						pdev->subsystem_device);
    367. 	if (hw->wol_enabled)
    368. 		adapter->wol = IXGBE_WUFC_MAG;
    369.  
    370. 	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
    371.  
    372. 	/* save off EEPROM version number */
    373. 	hw->eeprom.ops.read(hw, 0x2e, &adapter->eeprom_verh);
    374. 	hw->eeprom.ops.read(hw, 0x2d, &adapter->eeprom_verl);
    375.  
    376. 	/* pick up the PCI bus settings for reporting later */
    377. 	if (ixgbe_pcie_from_parent(hw))
    378. 		ixgbe_get_parent_bus_info(adapter);
    379. 	else
    380. 		 hw->mac.ops.get_bus_info(hw);
    381.  
    382. 	/* calculate the expected PCIe bandwidth required for optimal
    383. 	 * performance. Note that some older parts will never have enough
    384. 	 * bandwidth due to being older generation PCIe parts. We clamp these
    385. 	 * parts to ensure no warning is displayed if it can't be fixed.
    386. 	 */
    387. 	switch (hw->mac.type) {
    388. 	case ixgbe_mac_82598EB:
    389. 		expected_gts = min(ixgbe_enumerate_functions(adapter) * 10, 16);
    390. 		break;
    391. 	default:
    392. 		expected_gts = ixgbe_enumerate_functions(adapter) * 10;
    393. 		break;
    394. 	}
    395.  
    396. 	/* don't check link if we failed to enumerate functions */
    397. 	if (expected_gts > 0)
    398. 		ixgbe_check_minimum_link(adapter, expected_gts);
    399.  
    400. 	err = ixgbe_read_pba_string_generic(hw, part_str, sizeof(part_str));
    401. 	if (err)
    402. 		strlcpy(part_str, "Unknown", sizeof(part_str));
    403. 	if (ixgbe_is_sfp(hw) && hw->phy.sfp_type != ixgbe_sfp_type_not_present)
    404. 		e_dev_info("MAC: %d, PHY: %d, SFP+: %d, PBA No: %s\n",
    405. 			   hw->mac.type, hw->phy.type, hw->phy.sfp_type,
    406. 			   part_str);
    407. 	else
    408. 		e_dev_info("MAC: %d, PHY: %d, PBA No: %s\n",
    409. 			   hw->mac.type, hw->phy.type, part_str);
    410.  
    411. 	e_dev_info("%pM\n", netdev->dev_addr);
    412.  
    413. 	/* reset the hardware with the new settings */
    414. 	err = hw->mac.ops.start_hw(hw);
    415. 	if (err == IXGBE_ERR_EEPROM_VERSION) {
    416. 		/* We are running on a pre-production device, log a warning */
    417. 		e_dev_warn("This device is a pre-production adapter/LOM. "
    418. 			   "Please be aware there may be issues associated "
    419. 			   "with your hardware.  If you are experiencing "
    420. 			   "problems please contact your Intel or hardware "
    421. 			   "representative who provided you with this "
    422. 			   "hardware.\n");
    423. 	}
    424. 	strcpy(netdev->name, "eth%d");
    425. 	pci_set_drvdata(pdev, adapter);
    426. 	err = register_netdev(netdev);// 注册netdev
    427. 	if (err)
    428. 		goto err_register;
    429.  
    430.  
    431. 	/* power down the optics for 82599 SFP+ fiber */
    432. 	if (hw->mac.ops.disable_tx_laser)
    433. 		hw->mac.ops.disable_tx_laser(hw);
    434.  
    435. 	/* carrier off reporting is important to ethtool even BEFORE open */
    436. 	netif_carrier_off(netdev);
    437.  
    438. #ifdef CONFIG_IXGBE_DCA
    439. 	if (dca_add_requester(&pdev->dev) == 0) {
    440. 		adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
    441. 		ixgbe_setup_dca(adapter);
    442. 	}
    443. #endif
    444. 	if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) {
    445. 		e_info(probe, "IOV is enabled with %d VFs\n", adapter->num_vfs);
    446. 		for (i = 0; i < adapter->num_vfs; i++)
    447. 			ixgbe_vf_configuration(pdev, (i | 0x10000000));
    448. 	}
    449.  
    450. 	/* firmware requires driver version to be 0xFFFFFFFF
    451. 	 * since os does not support feature
    452. 	 */
    453. 	if (hw->mac.ops.set_fw_drv_ver)
    454. 		hw->mac.ops.set_fw_drv_ver(hw, 0xFF, 0xFF, 0xFF, 0xFF,
    455. 					   sizeof(ixgbe_driver_version) - 1,
    456. 					   ixgbe_driver_version);
    457.  
    458. 	/* add san mac addr to netdev */
    459. 	ixgbe_add_sanmac_netdev(netdev);
    460.  
    461. 	e_dev_info("%s\n", ixgbe_default_device_descr);
    462.  
    463. #ifdef CONFIG_IXGBE_HWMON
    464. 	if (ixgbe_sysfs_init(adapter))
    465. 		e_err(probe, "failed to allocate sysfs resources\n");
    466. #endif /* CONFIG_IXGBE_HWMON */
    467.  
    468. 	ixgbe_dbg_adapter_init(adapter);
    469.  
    470. 	/* setup link for SFP devices with MNG FW, else wait for IXGBE_UP */
    471. 	if (ixgbe_mng_enabled(hw) && ixgbe_is_sfp(hw) && hw->mac.ops.setup_link)
    472. 		hw->mac.ops.setup_link(hw,
    473. 			IXGBE_LINK_SPEED_10GB_FULL | IXGBE_LINK_SPEED_1GB_FULL,
    474. 			true);
    475.  
    476. 	return 0;
    477.  
    478. err_register:
    479. 	ixgbe_release_hw_control(adapter);
    480. 	ixgbe_clear_interrupt_scheme(adapter);
    481. err_sw_init:
    482. 	ixgbe_disable_sriov(adapter);
    483. 	adapter->flags2 &= ~IXGBE_FLAG2_SEARCH_FOR_SFP;
    484. 	iounmap(adapter->io_addr);
    485. 	kfree(adapter->jump_tables[0]);
    486. 	kfree(adapter->mac_table);
    487. 	kfree(adapter->rss_key);
    488. err_ioremap:
    489. 	disable_dev = !test_and_set_bit(__IXGBE_DISABLED, &adapter->state);
    490. 	free_netdev(netdev);
    491. err_alloc_etherdev:
    492. 	pci_release_mem_regions(pdev);
    493. err_pci_reg:
    494. err_dma:
    495. 	if (!adapter || disable_dev)
    496. 		pci_disable_device(pdev);
    497. 	return err;
    498. }

    3.1 ixgbe_info 选取

    根据网卡型号（82598/82599/540/550）在 ixgbe_info_tbl 列表中选择 ixgbe_info

    1. const struct ixgbe_info *ii = ixgbe_info_tbl[ent->driver_data];
    2.  
    3. static const struct ixgbe_info *ixgbe_info_tbl[] = {
    4. 	[board_82598]		= &ixgbe_82598_info,
    5. 	[board_82599]		= &ixgbe_82599_info,
    6. 	[board_X540]		= &ixgbe_X540_info,
    7. 	[board_X550]		= &ixgbe_X550_info,
    8. 	[board_X550EM_x]	= &ixgbe_X550EM_x_info,
    9. 	[board_x550em_x_fw]	= &ixgbe_x550em_x_fw_info,
    10. 	[board_x550em_a]	= &ixgbe_x550em_a_info,
    11. 	[board_x550em_a_fw]	= &ixgbe_x550em_a_fw_info,
    12. };
    13.   
    14. enum ixgbe_boards {
    15. 	board_82598,
    16. 	board_82599,
    17. 	board_X540,
    18. 	board_X550,
    19. 	board_X550EM_x,
    20. 	board_x550em_x_fw,
    21. 	board_x550em_a,
    22. 	board_x550em_a_fw,
    23. };
    24.  
    25. const struct ixgbe_info ixgbe_82599_info = {
    26. 	.mac                    = ixgbe_mac_82599EB,
    27. 	.get_invariants         = &ixgbe_get_invariants_82599,
    28. 	.mac_ops                = &mac_ops_82599,
    29. 	.eeprom_ops             = &eeprom_ops_82599,
    30. 	.phy_ops                = &phy_ops_82599,
    31. 	.mbx_ops                = &mbx_ops_generic,
    32. 	.mvals                  = ixgbe_mvals_8259X,
    33. };

    3.2 net_device/ixgbe_adapter 分配

    1. netdev = alloc_etherdev_mq(sizeof(struct ixgbe_adapter), MAX_TX_QUEUES);
    2.  
    3. struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count)
    4. {
    5.    return alloc_netdev_mq(sizeof_priv, "eth%d", ether_setup, queue_count);
    6. }
    7.  
    8. struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
    9.       void (*setup)(struct net_device *), unsigned int queue_count)
    10. {
    11.    struct netdev_queue *tx;
    12.    struct net_device *dev;
    13.    size_t alloc_size;
    14.    struct net_device *p;
    15.  
    16.    BUG_ON(strlen(name) >= sizeof(dev->name));
    17.  
    18.    alloc_size = sizeof(struct net_device); // net_device的大小
    19.    if (sizeof_priv) {
    20.       /* ensure 32-byte alignment of private area */
    21.       alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
    22.       alloc_size += sizeof_priv; // 加上private data的大小
    23.    }
    24.    /* ensure 32-byte alignment of whole construct */
    25.    alloc_size += NETDEV_ALIGN - 1;
    26.  
    27.    p = kzalloc(alloc_size, GFP_KERNEL); // 分配net_device和private data
    28.    if (!p) {
    29.       printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
    30.       return NULL;
    31.    }
    32.  
    33.    // 分配queue_count个netdev_queue（发送队列数组），一个发送队列对应一个netdev_queue
    34.    tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
    35.    if (!tx) {
    36.       printk(KERN_ERR "alloc_netdev: Unable to allocate "
    37.              "tx qdiscs.\n");
    38.       goto free_p;
    39.    }
    40.  
    41.    dev = PTR_ALIGN(p, NETDEV_ALIGN);
    42.    dev->padded = (char *)dev - (char *)p;
    43.  
    44.    if (dev_addr_init(dev))
    45.       goto free_tx;
    46.  
    47.    dev_unicast_init(dev);
    48.  
    49.    dev_net_set(dev, &init_net);
    50.  
    51.    dev->_tx = tx; // 保存发送队列数组
    52.    dev->num_tx_queues = queue_count; // 设置发送队列数
    53.    dev->real_num_tx_queues = queue_count; // 设置实际发送队列数
    54.  
    55.    dev->gso_max_size = GSO_MAX_SIZE;
    56.  
    57.    netdev_init_queues(dev); // 设置dev->_tx[i]->dev和dev->rx_queue->dev为dev
    58.  
    59.    INIT_LIST_HEAD(&dev->napi_list);
    60.    dev->priv_flags = IFF_XMIT_DST_RELEASE;
    61.    setup(dev); // 以太网为ether_setup()
    62.    strcpy(dev->name, name);
    63.    return dev;
    64.  
    65. free_tx:
    66.    kfree(tx);
    67.  
    68. free_p:
    69.    kfree(p);
    70.    return NULL;
    71. }
    72.  
    73. static void netdev_init_queues(struct net_device *dev)
    74. {
    75.    netdev_init_one_queue(dev, &dev->rx_queue, NULL);
    76.    netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
    77.    spin_lock_init(&dev->tx_global_lock);
    78. }
    79.  
    80. static void netdev_init_one_queue(struct net_device *dev,
    81.               struct netdev_queue *queue,
    82.               void *_unused)
    83. {
    84.    queue->dev = dev;
    85. }
    86.  
    87. static inline void netdev_for_each_tx_queue(struct net_device *dev,
    88.                    void (*f)(struct net_device *,
    89.                         struct netdev_queue *,
    90.                         void *),
    91.                    void *arg)
    92. {
    93.    unsigned int i;
    94.  
    95.    for (i = 0; i < dev->num_tx_queues; i++)
    96.       f(dev, &dev->_tx[i], arg);
    97. }
    98.  
    99. void ether_setup(struct net_device *dev)
    100. {
    101.    dev->header_ops       = &eth_header_ops;
    102.    dev->type     = ARPHRD_ETHER; // 以太网格式
    103.    dev->hard_header_len   = ETH_HLEN; // 14
    104.    dev->mtu      = ETH_DATA_LEN; // 1500
    105.    dev->addr_len     = ETH_ALEN; // 6
    106.    dev->tx_queue_len  = 1000;    /* Ethernet wants good queues */
    107.    dev->flags    = IFF_BROADCAST|IFF_MULTICAST;
    108.  
    109.    memset(dev->broadcast, 0xFF, ETH_ALEN);
    110.  
    111. }

    3.3 读取eeprom中的mac地址，写入hw->mac.perm_addr

    1. struct ixgbe_info ixgbe_82599_info = {
    2.    .mac                    = ixgbe_mac_82599EB,
    3.    .get_invariants         = &ixgbe_get_invariants_82599,
    4.    .mac_ops                = &mac_ops_82599,
    5.    .eeprom_ops             = &eeprom_ops_82599,
    6.    .phy_ops                = &phy_ops_82599,
    7. };
    8.  
    9. static struct ixgbe_mac_operations mac_ops_82599 = {
    10.    .init_hw                = &ixgbe_init_hw_generic,
    11.    .reset_hw               = &ixgbe_reset_hw_82599,
    12.    .start_hw               = &ixgbe_start_hw_82599,
    13.    .clear_hw_cntrs         = &ixgbe_clear_hw_cntrs_generic,
    14.    .get_media_type         = &ixgbe_get_media_type_82599,
    15.    .get_supported_physical_layer = &ixgbe_get_supported_physical_layer_82599,
    16.    .enable_rx_dma          = &ixgbe_enable_rx_dma_82599,
    17.    .get_mac_addr           = &ixgbe_get_mac_addr_generic,
    18.    .get_san_mac_addr       = &ixgbe_get_san_mac_addr_82599,
    19.    .get_device_caps        = &ixgbe_get_device_caps_82599,
    20.    .stop_adapter           = &ixgbe_stop_adapter_generic,
    21.    .get_bus_info           = &ixgbe_get_bus_info_generic,
    22.    .set_lan_id             = &ixgbe_set_lan_id_multi_port_pcie,
    23.    .read_analog_reg8       = &ixgbe_read_analog_reg8_82599,
    24.    .write_analog_reg8      = &ixgbe_write_analog_reg8_82599,
    25.    .setup_link             = &ixgbe_setup_mac_link_82599,
    26.    .check_link             = &ixgbe_check_mac_link_82599,
    27.    .get_link_capabilities  = &ixgbe_get_link_capabilities_82599,
    28.    .led_on                 = &ixgbe_led_on_generic,
    29.    .led_off                = &ixgbe_led_off_generic,
    30.    .blink_led_start        = &ixgbe_blink_led_start_generic,
    31.    .blink_led_stop         = &ixgbe_blink_led_stop_generic,
    32.    .set_rar                = &ixgbe_set_rar_generic,
    33.    .clear_rar              = &ixgbe_clear_rar_generic,
    34.    .set_vmdq               = &ixgbe_set_vmdq_82599,
    35.    .clear_vmdq             = &ixgbe_clear_vmdq_82599,
    36.    .init_rx_addrs          = &ixgbe_init_rx_addrs_generic,
    37.    .update_uc_addr_list    = &ixgbe_update_uc_addr_list_generic,
    38.    .update_mc_addr_list    = &ixgbe_update_mc_addr_list_generic,
    39.    .enable_mc              = &ixgbe_enable_mc_generic,
    40.    .disable_mc             = &ixgbe_disable_mc_generic,
    41.    .clear_vfta             = &ixgbe_clear_vfta_82599,
    42.    .set_vfta               = &ixgbe_set_vfta_82599,
    43.    .fc_enable               = &ixgbe_fc_enable_generic,
    44.    .init_uta_tables        = &ixgbe_init_uta_tables_82599,
    45.    .setup_sfp              = &ixgbe_setup_sfp_modules_82599,
    46. };
    47.  
    48. static s32 ixgbe_reset_hw_82599(struct ixgbe_hw *hw)
    49. {
    50.    s32 status = 0;
    51.    u32 ctrl, ctrl_ext;
    52.    u32 i;
    53.    u32 autoc;
    54.    u32 autoc2;
    55.  
    56.    /* Call adapter stop to disable tx/rx and clear interrupts */
    57.    hw->mac.ops.stop_adapter(hw);
    58.  
    59.    /* PHY ops must be identified and initialized prior to reset */
    60.  
    61.    /* Init PHY and function pointers, perform SFP setup */
    62.    status = hw->phy.ops.init(hw);
    63.  
    64.    if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
    65.       goto reset_hw_out;
    66.  
    67.    /* Setup SFP module if there is one present. */
    68.    if (hw->phy.sfp_setup_needed) {
    69.       status = hw->mac.ops.setup_sfp(hw);
    70.       hw->phy.sfp_setup_needed = false;
    71.    }
    72.  
    73.    /* Reset PHY */
    74.    if (hw->phy.reset_disable == false && hw->phy.ops.reset != NULL)
    75.       hw->phy.ops.reset(hw);
    76.  
    77.    /*
    78.     * Prevent the PCI-E bus from from hanging by disabling PCI-E master
    79.     * access and verify no pending requests before reset
    80.     */
    81.    status = ixgbe_disable_pcie_master(hw);
    82.    if (status != 0) {
    83.       status = IXGBE_ERR_MASTER_REQUESTS_PENDING;
    84.       hw_dbg(hw, "PCI-E Master disable polling has failed.\n");
    85.    }
    86.  
    87.    /*
    88.     * Issue global reset to the MAC.  This needs to be a SW reset.
    89.     * If link reset is used, it might reset the MAC when mng is using it
    90.     */
    91.    ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
    92.    IXGBE_WRITE_REG(hw, IXGBE_CTRL, (ctrl | IXGBE_CTRL_RST));
    93.    IXGBE_WRITE_FLUSH(hw);
    94.  
    95.    /* Poll for reset bit to self-clear indicating reset is complete */
    96.    for (i = 0; i < 10; i++) {
    97.       udelay(1);
    98.       ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
    99.       if (!(ctrl & IXGBE_CTRL_RST))
    100.          break;
    101.    }
    102.    if (ctrl & IXGBE_CTRL_RST) {
    103.       status = IXGBE_ERR_RESET_FAILED;
    104.       hw_dbg(hw, "Reset polling failed to complete.\n");
    105.    }
    106.    /* Clear PF Reset Done bit so PF/VF Mail Ops can work */
    107.    ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT);
    108.    ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD;
    109.    IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
    110.  
    111.    msleep(50);
    112.  
    113.  
    114.  
    115.    /*
    116.     * Store the original AUTOC/AUTOC2 values if they have not been
    117.     * stored off yet.  Otherwise restore the stored original
    118.     * values since the reset operation sets back to defaults.
    119.     */
    120.    autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
    121.    autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
    122.    if (hw->mac.orig_link_settings_stored == false) {
    123.       hw->mac.orig_autoc = autoc;
    124.       hw->mac.orig_autoc2 = autoc2;
    125.       hw->mac.orig_link_settings_stored = true;
    126.    } else {
    127.       if (autoc != hw->mac.orig_autoc)
    128.          IXGBE_WRITE_REG(hw, IXGBE_AUTOC, (hw->mac.orig_autoc |
    129.                          IXGBE_AUTOC_AN_RESTART));
    130.  
    131.       if ((autoc2 & IXGBE_AUTOC2_UPPER_MASK) !=
    132.           (hw->mac.orig_autoc2 & IXGBE_AUTOC2_UPPER_MASK)) {
    133.          autoc2 &= ~IXGBE_AUTOC2_UPPER_MASK;
    134.          autoc2 |= (hw->mac.orig_autoc2 &
    135.                     IXGBE_AUTOC2_UPPER_MASK);
    136.          IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2);
    137.       }
    138.    }
    139.  
    140.    /*
    141.     * Store MAC address from RAR0, clear receive address registers, and
    142.     * clear the multicast table.  Also reset num_rar_entries to 128,
    143.     * since we modify this value when programming the SAN MAC address.
    144.     */
    145.    hw->mac.num_rar_entries = 128;
    146.    hw->mac.ops.init_rx_addrs(hw);
    147.  
    148.    /* Store the permanent mac address */
    149.    hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr); // 读取eeprom中的mac地址，写入hw->mac.perm_addr
    150.  
    151.    /* Store the permanent SAN mac address */
    152.    hw->mac.ops.get_san_mac_addr(hw, hw->mac.san_addr);
    153.  
    154.    /* Add the SAN MAC address to the RAR only if it's a valid address */
    155.    if (ixgbe_validate_mac_addr(hw->mac.san_addr) == 0) {
    156.       hw->mac.ops.set_rar(hw, hw->mac.num_rar_entries - 1,
    157.                           hw->mac.san_addr, 0, IXGBE_RAH_AV);
    158.  
    159.       /* Reserve the last RAR for the SAN MAC address */
    160.       hw->mac.num_rar_entries--;
    161.    }
    162.  
    163. reset_hw_out:
    164.    return status;
    165. }
    166.  
    167. s32 ixgbe_get_mac_addr_generic(struct ixgbe_hw *hw, u8 *mac_addr)
    168. {
    169.    u32 rar_high;
    170.    u32 rar_low;
    171.    u16 i;
    172.  
    173.    rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(0));
    174.    rar_low = IXGBE_READ_REG(hw, IXGBE_RAL(0));
    175.  
    176.    for (i = 0; i < 4; i++)
    177.       mac_addr[i] = (u8)(rar_low >> (i*8));
    178.  
    179.    for (i = 0; i < 2; i++)
    180.       mac_addr[i+4] = (u8)(rar_high >> (i*8));
    181.  
    182.    return 0;
    183. }
    184.  
    185. #define IXGBE_RAL(_i)   (((_i) <= 15) ? (0x05400 + ((_i) * 8)) : \
    186.                          (0x0A200 + ((_i) * 8)))
    187. #define IXGBE_RAH(_i)   (((_i) <= 15) ? (0x05404 + ((_i) * 8)) : \
    188.                          (0x0A204 + ((_i) * 8)))

    3.4 ixgbe_init_interrupt_scheme()

    1. /**
    2.  * ixgbe_init_interrupt_scheme - Determine proper interrupt scheme
    3.  * @adapter: board private structure to initialize
    4.  *
    5.  * We determine which interrupt scheme to use based on...
    6.  * - Kernel support (MSI, MSI-X)
    7.  *   - which can be user-defined (via MODULE_PARAM)
    8.  * - Hardware queue count (num_*_queues)
    9.  *   - defined by miscellaneous hardware support/features (RSS, etc.)
    10.  **/
    11. int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter)
    12. {
    13. 	int err;
    14.  
    15. 	/* Number of supported queues */
    16. 	ixgbe_set_num_queues(adapter); //根据FDIR/RSS设置adapter->num_tx/rx_queues
    17.  
    18. 	/* Set interrupt mode */
    19. 	ixgbe_set_interrupt_capability(adapter); //向PCI子系统请求中断
    20.  
    21. 	err = ixgbe_alloc_q_vectors(adapter);	//设置poll函数，分配ixgbe_q_vector，初始化napi并加入napi_list
    22. 	if (err) {
    23. 		e_dev_err("Unable to allocate memory for queue vectors\n");
    24. 		goto err_alloc_q_vectors;
    25. 	}
    26.  
    27. 	ixgbe_cache_ring_register(adapter);// 分配发送/接收ring数组
    28.  
    29. 	e_dev_info("Multiqueue %s: Rx Queue count = %u, Tx Queue count = %u XDP Queue count = %u\n",
    30. 		   (adapter->num_rx_queues > 1) ? "Enabled" : "Disabled",
    31. 		   adapter->num_rx_queues, adapter->num_tx_queues,
    32. 		   adapter->num_xdp_queues);
    33.  
    34. 	set_bit(__IXGBE_DOWN, &adapter->state);
    35.  
    36. 	return 0;
    37.  
    38. err_alloc_q_vectors:
    39. 	ixgbe_reset_interrupt_capability(adapter);
    40. 	return err;
    41. }

    3.4.1 设置收发队列 ixgbe_set_num_queues()

    1. /**
    2.  * ixgbe_set_num_queues - Allocate queues for device, feature dependent
    3.  * @adapter: board private structure to initialize
    4.  *
    5.  * This is the top level queue allocation routine.  The order here is very
    6.  * important, starting with the "most" number of features turned on at once,
    7.  * and ending with the smallest set of features.  This way large combinations
    8.  * can be allocated if they're turned on, and smaller combinations are the
    9.  * fallthrough conditions.
    10.  *
    11.  **/
    12. static void ixgbe_set_num_queues(struct ixgbe_adapter *adapter)
    13. {
    14. 	/* Start with base case */
    15. 	adapter->num_rx_queues = 1;
    16. 	adapter->num_tx_queues = 1;
    17. 	adapter->num_xdp_queues = 0;
    18. 	adapter->num_rx_pools = adapter->num_rx_queues;
    19. 	adapter->num_rx_queues_per_pool = 1;
    20.  
    21. #ifdef CONFIG_IXGBE_DCB
    22. 	if (ixgbe_set_dcb_sriov_queues(adapter))
    23. 		return;
    24.  
    25. 	if (ixgbe_set_dcb_queues(adapter))
    26. 		return;
    27.  
    28. #endif
    29. 	if (ixgbe_set_sriov_queues(adapter))
    30. 		return;
    31.  
    32. 	ixgbe_set_rss_queues(adapter);
    33. }

    3.4.2 向PCI子系统请求中断 ixgbe_set_interrupt_capability()

    1. /**
    2.  * ixgbe_set_interrupt_capability - set MSI-X or MSI if supported
    3.  * @adapter: board private structure to initialize
    4.  *
    5.  * Attempt to configure the interrupts using the best available
    6.  * capabilities of the hardware and the kernel.
    7.  **/
    8. static void ixgbe_set_interrupt_capability(struct ixgbe_adapter *adapter)
    9. {
    10. 	int err;
    11.  
    12. 	/* We will try to get MSI-X interrupts first */
    13. 	if (!ixgbe_acquire_msix_vectors(adapter))
    14. 		return;
    15.  
    16. 	/* At this point, we do not have MSI-X capabilities. We need to
    17. 	 * reconfigure or disable various features which require MSI-X
    18. 	 * capability.
    19. 	 */
    20.  
    21. 	/* Disable DCB unless we only have a single traffic class */
    22. 	if (netdev_get_num_tc(adapter->netdev) > 1) {
    23. 		e_dev_warn("Number of DCB TCs exceeds number of available queues. Disabling DCB support.\n");
    24. 		netdev_reset_tc(adapter->netdev);
    25.  
    26. 		if (adapter->hw.mac.type == ixgbe_mac_82598EB)
    27. 			adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
    28.  
    29. 		adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
    30. 		adapter->temp_dcb_cfg.pfc_mode_enable = false;
    31. 		adapter->dcb_cfg.pfc_mode_enable = false;
    32. 	}
    33.  
    34. 	adapter->dcb_cfg.num_tcs.pg_tcs = 1;
    35. 	adapter->dcb_cfg.num_tcs.pfc_tcs = 1;
    36.  
    37. 	/* Disable SR-IOV support */
    38. 	e_dev_warn("Disabling SR-IOV support\n");
    39. 	ixgbe_disable_sriov(adapter);
    40.  
    41. 	/* Disable RSS */
    42. 	e_dev_warn("Disabling RSS support\n");
    43. 	adapter->ring_feature[RING_F_RSS].limit = 1;
    44.  
    45. 	/* recalculate number of queues now that many features have been
    46. 	 * changed or disabled.
    47. 	 */
    48. 	ixgbe_set_num_queues(adapter);
    49. 	adapter->num_q_vectors = 1;
    50.  
    51. 	err = pci_enable_msi(adapter->pdev);  //向PCI子系统请求1个msi中断
    52. 	if (err)
    53. 		e_dev_warn("Failed to allocate MSI interrupt, falling back to legacy. Error: %d\n",
    54. 			   err);
    55. 	else
    56. 		adapter->flags |= IXGBE_FLAG_MSI_ENABLED;
    57. }

    3.4.3 申请中断向量表 ixgbe_alloc_q_vectors

    1. /**
    2.  * ixgbe_alloc_q_vectors - Allocate memory for interrupt vectors
    3.  * @adapter: board private structure to initialize
    4.  *
    5.  * We allocate one q_vector per queue interrupt.  If allocation fails we
    6.  * return -ENOMEM.
    7.  **/
    8. static int ixgbe_alloc_q_vectors(struct ixgbe_adapter *adapter)
    9. {
    10. 	int q_vectors = adapter->num_q_vectors;
    11. 	int rxr_remaining = adapter->num_rx_queues;
    12. 	int txr_remaining = adapter->num_tx_queues;
    13. 	int xdp_remaining = adapter->num_xdp_queues;
    14. 	int rxr_idx = 0, txr_idx = 0, xdp_idx = 0, v_idx = 0;
    15. 	int err;
    16.  
    17. 	/* only one q_vector if MSI-X is disabled. */
    18.     // 使用MSIX（Message Signaled Interrupt-X）
    19.     // 去掉绑定ixgbe0所在NUMA的所有CPU的msix中断（LSC等）
    20. 	if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
    21. 		q_vectors = 1;
    22.  
    23. 	if (q_vectors >= (rxr_remaining + txr_remaining + xdp_remaining)) {
    24. 		for (; rxr_remaining; v_idx++) {
    25. 			err = ixgbe_alloc_q_vector(adapter, q_vectors, v_idx,
    26. 						   0, 0, 0, 0, 1, rxr_idx); //分配ixgbe_q_vector
    27.  
    28. 			if (err)
    29. 				goto err_out;
    30.  
    31. 			/* update counts and index */
    32. 			rxr_remaining--;
    33. 			rxr_idx++;
    34. 		}
    35. 	}
    36.  
    37. 	for (; v_idx < q_vectors; v_idx++) {
    38. 		int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);
    39. 		int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);
    40. 		int xqpv = DIV_ROUND_UP(xdp_remaining, q_vectors - v_idx);
    41.  
    42. 		err = ixgbe_alloc_q_vector(adapter, q_vectors, v_idx,
    43. 					   tqpv, txr_idx,
    44. 					   xqpv, xdp_idx,
    45. 					   rqpv, rxr_idx);
    46.  
    47. 		if (err)
    48. 			goto err_out;
    49.  
    50. 		/* update counts and index */
    51. 		rxr_remaining -= rqpv;
    52. 		txr_remaining -= tqpv;
    53. 		xdp_remaining -= xqpv;
    54. 		rxr_idx++;
    55. 		txr_idx++;
    56. 		xdp_idx += xqpv;
    57. 	}
    58.  
    59. 	return 0;
    60.  
    61. err_out:
    62. 	adapter->num_tx_queues = 0;
    63. 	adapter->num_xdp_queues = 0;
    64. 	adapter->num_rx_queues = 0;
    65. 	adapter->num_q_vectors = 0;
    66.  
    67. 	while (v_idx--)
    68. 		ixgbe_free_q_vector(adapter, v_idx);
    69.  
    70. 	return -ENOMEM;
    71. }

    中断向量表分配 ixgbe_alloc_q_vector，NAPI的模式的 poll 函数（ixgbe_poll:一次读取64个数据包）注册

    1.  /**
    2.  * ixgbe_alloc_q_vector - Allocate memory for a single interrupt vector
    3.  * @adapter: board private structure to initialize
    4.  * @v_count: q_vectors allocated on adapter, used for ring interleaving
    5.  * @v_idx: index of vector in adapter struct
    6.  * @txr_count: total number of Tx rings to allocate
    7.  * @txr_idx: index of first Tx ring to allocate
    8.  * @xdp_count: total number of XDP rings to allocate
    9.  * @xdp_idx: index of first XDP ring to allocate
    10.  * @rxr_count: total number of Rx rings to allocate
    11.  * @rxr_idx: index of first Rx ring to allocate
    12.  *
    13.  * We allocate one q_vector.  If allocation fails we return -ENOMEM.
    14.  **/
    15. static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter,
    16. 				int v_count, int v_idx,
    17. 				int txr_count, int txr_idx,
    18. 				int xdp_count, int xdp_idx,
    19. 				int rxr_count, int rxr_idx)
    20. {
    21. 	struct ixgbe_q_vector *q_vector;
    22. 	struct ixgbe_ring *ring;
    23. 	int node = NUMA_NO_NODE;
    24. 	int cpu = -1;
    25. 	int ring_count, size;
    26. 	u8 tcs = netdev_get_num_tc(adapter->netdev);
    27.  
    28. 	ring_count = txr_count + rxr_count + xdp_count;
    29. 	size = sizeof(struct ixgbe_q_vector) +
    30. 	       (sizeof(struct ixgbe_ring) * ring_count);
    31.  
    32. 	/* customize cpu for Flow Director mapping */
    33. 	if ((tcs <= 1) && !(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED)) {
    34. 		u16 rss_i = adapter->ring_feature[RING_F_RSS].indices;
    35. 		if (rss_i > 1 && adapter->atr_sample_rate) {
    36. 			if (cpu_online(v_idx)) {
    37. 				cpu = v_idx;
    38. 				node = cpu_to_node(cpu);
    39. 			}
    40. 		}
    41. 	}
    42.  
    43. 	/* allocate q_vector and rings */
    44. 	q_vector = kzalloc_node(size, GFP_KERNEL, node);
    45. 	if (!q_vector)
    46. 		q_vector = kzalloc(size, GFP_KERNEL);
    47. 	if (!q_vector)
    48. 		return -ENOMEM;
    49.  
    50. 	/* setup affinity mask and node */
    51. 	if (cpu != -1)
    52. 		cpumask_set_cpu(cpu, &q_vector->affinity_mask);
    53. 	q_vector->numa_node = node;
    54.  
    55. #ifdef CONFIG_IXGBE_DCA
    56. 	/* initialize CPU for DCA */
    57. 	q_vector->cpu = -1;
    58.  
    59. #endif
    60.  
    61.     /* 初始化q_vector->napi并加入adapter->netdev的napi_list，
    62.        其中poll函数为ixgbe_clean_rxtx_many()/ixgbe_poll()，一次poll的最大报文数为64 */
    63.  
    64. 	/* initialize NAPI */
    65. 	netif_napi_add(adapter->netdev, &q_vector->napi,
    66. 		       ixgbe_poll, 64);
    67.  
    68.  
    69.  
    70. 	/* tie q_vector and adapter together */
    71. 	adapter->q_vector[v_idx] = q_vector;// 地址赋给adapter->q_vector[q_idx]
    72. 	q_vector->adapter = adapter;
    73. 	q_vector->v_idx = v_idx;
    74.  
    75. 	/* initialize work limits */
    76. 	q_vector->tx.work_limit = adapter->tx_work_limit;
    77.  
    78. 	/* initialize pointer to rings */
    79. 	ring = q_vector->ring;
    80.  
    81. 	/* intialize ITR */
    82. 	if (txr_count && !rxr_count) {
    83. 		/* tx only vector */
    84. 		if (adapter->tx_itr_setting == 1)
    85. 			q_vector->itr = IXGBE_12K_ITR;
    86. 		else
    87. 			q_vector->itr = adapter->tx_itr_setting;
    88. 	} else {
    89. 		/* rx or rx/tx vector */
    90. 		if (adapter->rx_itr_setting == 1)
    91. 			q_vector->itr = IXGBE_20K_ITR;
    92. 		else
    93. 			q_vector->itr = adapter->rx_itr_setting;
    94. 	}
    95.  
    96. 	while (txr_count) {
    97. 		/* assign generic ring traits */
    98. 		ring->dev = &adapter->pdev->dev;
    99. 		ring->netdev = adapter->netdev;
    100.  
    101. 		/* configure backlink on ring */
    102. 		ring->q_vector = q_vector;
    103.  
    104. 		/* update q_vector Tx values */
    105. 		ixgbe_add_ring(ring, &q_vector->tx);
    106.  
    107. 		/* apply Tx specific ring traits */
    108. 		ring->count = adapter->tx_ring_count;
    109. 		if (adapter->num_rx_pools > 1)
    110. 			ring->queue_index =
    111. 				txr_idx % adapter->num_rx_queues_per_pool;
    112. 		else
    113. 			ring->queue_index = txr_idx;
    114.  
    115. 		/* assign ring to adapter */
    116. 		WRITE_ONCE(adapter->tx_ring[txr_idx], ring);
    117.  
    118. 		/* update count and index */
    119. 		txr_count--;
    120. 		txr_idx += v_count;
    121.  
    122. 		/* push pointer to next ring */
    123. 		ring++;
    124. 	}
    125.  
    126. 	while (xdp_count) {
    127. 		/* assign generic ring traits */
    128. 		ring->dev = &adapter->pdev->dev;
    129. 		ring->netdev = adapter->netdev;
    130.  
    131. 		/* configure backlink on ring */
    132. 		ring->q_vector = q_vector;
    133.  
    134. 		/* update q_vector Tx values */
    135. 		ixgbe_add_ring(ring, &q_vector->tx);
    136.  
    137. 		/* apply Tx specific ring traits */
    138. 		ring->count = adapter->tx_ring_count;
    139. 		ring->queue_index = xdp_idx;
    140. 		set_ring_xdp(ring);
    141.  
    142. 		/* assign ring to adapter */
    143. 		WRITE_ONCE(adapter->xdp_ring[xdp_idx], ring);
    144.  
    145. 		/* update count and index */
    146. 		xdp_count--;
    147. 		xdp_idx++;
    148.  
    149. 		/* push pointer to next ring */
    150. 		ring++;
    151. 	}
    152.  
    153. 	while (rxr_count) {
    154. 		/* assign generic ring traits */
    155. 		ring->dev = &adapter->pdev->dev;
    156. 		ring->netdev = adapter->netdev;
    157.  
    158. 		/* configure backlink on ring */
    159. 		ring->q_vector = q_vector;
    160.  
    161. 		/* update q_vector Rx values */
    162. 		ixgbe_add_ring(ring, &q_vector->rx);
    163.  
    164. 		/*
    165. 		 * 82599 errata, UDP frames with a 0 checksum
    166. 		 * can be marked as checksum errors.
    167. 		 */
    168. 		if (adapter->hw.mac.type == ixgbe_mac_82599EB)
    169. 			set_bit(__IXGBE_RX_CSUM_UDP_ZERO_ERR, &ring->state);
    170.  
    171. #ifdef IXGBE_FCOE
    172. 		if (adapter->netdev->features & NETIF_F_FCOE_MTU) {
    173. 			struct ixgbe_ring_feature *f;
    174. 			f = &adapter->ring_feature[RING_F_FCOE];
    175. 			if ((rxr_idx >= f->offset) &&
    176. 			    (rxr_idx < f->offset + f->indices))
    177. 				set_bit(__IXGBE_RX_FCOE, &ring->state);
    178. 		}
    179.  
    180. #endif /* IXGBE_FCOE */
    181. 		/* apply Rx specific ring traits */
    182. 		ring->count = adapter->rx_ring_count;
    183. 		if (adapter->num_rx_pools > 1)
    184. 			ring->queue_index =
    185. 				rxr_idx % adapter->num_rx_queues_per_pool;
    186. 		else
    187. 			ring->queue_index = rxr_idx;
    188.  
    189. 		/* assign ring to adapter */
    190. 		WRITE_ONCE(adapter->rx_ring[rxr_idx], ring);
    191.  
    192. 		/* update count and index */
    193. 		rxr_count--;
    194. 		rxr_idx += v_count;
    195.  
    196. 		/* push pointer to next ring */
    197. 		ring++;
    198. 	}
    199.  
    200. 	return 0;
    201. }

    3.4.4 rx/tx 中的描述符 fd 分配注册 ixgbe_cache_ring_register

    1. /**
    2.  * ixgbe_cache_ring_register - Descriptor ring to register mapping
    3.  * @adapter: board private structure to initialize
    4.  *
    5.  * Once we know the feature-set enabled for the device, we'll cache
    6.  * the register offset the descriptor ring is assigned to.
    7.  *
    8.  * Note, the order the various feature calls is important.  It must start with
    9.  * the "most" features enabled at the same time, then trickle down to the
    10.  * least amount of features turned on at once.
    11.  **/
    12. static void ixgbe_cache_ring_register(struct ixgbe_adapter *adapter)
    13. {
    14. 	/* start with default case */
    15. 	adapter->rx_ring[0]->reg_idx = 0;
    16. 	adapter->tx_ring[0]->reg_idx = 0;
    17.  
    18. #ifdef CONFIG_IXGBE_DCB
    19. 	if (ixgbe_cache_ring_dcb_sriov(adapter))
    20. 		return;
    21.  
    22. 	if (ixgbe_cache_ring_dcb(adapter))
    23. 		return;
    24.  
    25. #endif
    26. 	if (ixgbe_cache_ring_sriov(adapter))
    27. 		return;
    28.  
    29. 	ixgbe_cache_ring_rss(adapter);
    30. }

     

  • 相关阅读:
    MySQL数据类型之JSON
    2022亚太C题详细思路
    鸿鹄工程项目管理系统em Spring Cloud+Spring Boot+前后端分离构建工程项目管理系统
    阿里影业+大麦，开启大文娱新纪元？
    基于python-CNN深度学习的食物识别-含数据集+pyqt界面
    1000+已成功入职的软件测试工程师简历范文模板（含真实简历），教你软件测试工程师简历如何编写？
    半年总结 -要有松弛感的慢生活
    StringUtils 系列之 StringUtils.isBlank() 和 StringUtils.isNotBlank() 的区别、CollectionUtils.isEmpty()
    浅谈Java内部锁synchronized
    Java用log4j写日志
  • 原文地址：https://blog.csdn.net/m0_74282605/article/details/127936488