tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch '200GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/tnguy/net-queue

Tony Nguyen says:

====================
Intel Wired LAN Driver Updates 2026-02-19 (idpf, ice, i40e, ixgbevf, e1000e)

For idpf:
Li Li moves the check for software marker to occur after incrementing
next to clean to avoid re-encountering the same packet. He also adds a
couple of checks to prevent NULL pointer dereferences and NULLs rss_key,
after free, in error path so that later checks are properly evaluated.

Brian Vazquez adjusts IRQ naming to have correlation with netdev naming.

Sreedevi removes validation of action type as part of ntuple rule
deletion.

For ice:
Aaron Ma breaks RDMA initialization into two steps and adjusts calls so
that VSIs are entirely configured before plugging.

Michal Schmidt fixes initialization of loopback VSI to have proper
resources allocated to allow for loopback testing to occur.

For i40e:
Thomas Gleixner fixes a leak of preempt count by replacing get_cpu()
with smp_processor_id().

For ixgbevf:
Jedrzej adds a check for mailbox version before attempting to call an
associated link state call that is supported in that mailbox version.

For e1000e:
Vitaly clears power gating feature for Panther Lake systems to avoid
packet issues.

* '200GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/tnguy/net-queue:
e1000e: clear DPG_EN after reset to avoid autonomous power-gating
e1000e: introduce new board type for Panther Lake PCH
ixgbevf: fix link setup issue
i40e: Fix preempt count leak in napi poll tracepoint
ice: fix crash in ethtool offline loopback test
ice: recap the VSI and QoS info after rebuild
idpf: Fix flow rule delete failure due to invalid validation
idpf: change IRQ naming to match netdev and ethtool queue numbering
idpf: nullify pointers after they are freed
idpf: skip deallocating txq group's txqs if it is NULL
idpf: skip deallocating bufq_sets from rx_qgrp if it is NULL
idpf: increment completion queue next_to_clean in sw marker wait routine

====================

Link: https://patch.msgid.link/20260225211546.1949260-1-anthony.l.nguyen@intel.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 6df0022b 1cc93c48

+114 -38
+1
drivers/net/ethernet/intel/e1000e/defines.h
··· 33 33 34 34 /* Extended Device Control */ 35 35 #define E1000_CTRL_EXT_LPCD 0x00000004 /* LCD Power Cycle Done */ 36 + #define E1000_CTRL_EXT_DPG_EN 0x00000008 /* Dynamic Power Gating Enable */ 36 37 #define E1000_CTRL_EXT_SDP3_DATA 0x00000080 /* Value of SW Definable Pin 3 */ 37 38 #define E1000_CTRL_EXT_FORCE_SMBUS 0x00000800 /* Force SMBus mode */ 38 39 #define E1000_CTRL_EXT_EE_RST 0x00002000 /* Reinitialize from EEPROM */
+3 -1
drivers/net/ethernet/intel/e1000e/e1000.h
··· 117 117 board_pch_cnp, 118 118 board_pch_tgp, 119 119 board_pch_adp, 120 - board_pch_mtp 120 + board_pch_mtp, 121 + board_pch_ptp 121 122 }; 122 123 123 124 struct e1000_ps_page { ··· 528 527 extern const struct e1000_info e1000_pch_tgp_info; 529 528 extern const struct e1000_info e1000_pch_adp_info; 530 529 extern const struct e1000_info e1000_pch_mtp_info; 530 + extern const struct e1000_info e1000_pch_ptp_info; 531 531 extern const struct e1000_info e1000_es2_info; 532 532 533 533 void e1000e_ptp_init(struct e1000_adapter *adapter);
-2
drivers/net/ethernet/intel/e1000e/hw.h
··· 118 118 #define E1000_DEV_ID_PCH_ARL_I219_V24 0x57A1 119 119 #define E1000_DEV_ID_PCH_PTP_I219_LM25 0x57B3 120 120 #define E1000_DEV_ID_PCH_PTP_I219_V25 0x57B4 121 - #define E1000_DEV_ID_PCH_PTP_I219_LM26 0x57B5 122 - #define E1000_DEV_ID_PCH_PTP_I219_V26 0x57B6 123 121 #define E1000_DEV_ID_PCH_PTP_I219_LM27 0x57B7 124 122 #define E1000_DEV_ID_PCH_PTP_I219_V27 0x57B8 125 123 #define E1000_DEV_ID_PCH_NVL_I219_LM29 0x57B9
+30 -1
drivers/net/ethernet/intel/e1000e/ich8lan.c
··· 528 528 529 529 phy->id = e1000_phy_unknown; 530 530 531 - if (hw->mac.type == e1000_pch_mtp) { 531 + if (hw->mac.type == e1000_pch_mtp || hw->mac.type == e1000_pch_ptp) { 532 532 phy->retry_count = 2; 533 533 e1000e_enable_phy_retry(hw); 534 534 } ··· 4932 4932 reg |= E1000_KABGTXD_BGSQLBIAS; 4933 4933 ew32(KABGTXD, reg); 4934 4934 4935 + /* The hardware reset value of the DPG_EN bit is 1. 4936 + * Clear DPG_EN to prevent unexpected autonomous power gating. 4937 + */ 4938 + if (hw->mac.type >= e1000_pch_ptp) { 4939 + reg = er32(CTRL_EXT); 4940 + reg &= ~E1000_CTRL_EXT_DPG_EN; 4941 + ew32(CTRL_EXT, reg); 4942 + } 4943 + 4935 4944 return 0; 4936 4945 } 4937 4946 ··· 6200 6191 6201 6192 const struct e1000_info e1000_pch_mtp_info = { 6202 6193 .mac = e1000_pch_mtp, 6194 + .flags = FLAG_IS_ICH 6195 + | FLAG_HAS_WOL 6196 + | FLAG_HAS_HW_TIMESTAMP 6197 + | FLAG_HAS_CTRLEXT_ON_LOAD 6198 + | FLAG_HAS_AMT 6199 + | FLAG_HAS_FLASH 6200 + | FLAG_HAS_JUMBO_FRAMES 6201 + | FLAG_APME_IN_WUC, 6202 + .flags2 = FLAG2_HAS_PHY_STATS 6203 + | FLAG2_HAS_EEE, 6204 + .pba = 26, 6205 + .max_hw_frame_size = 9022, 6206 + .get_variants = e1000_get_variants_ich8lan, 6207 + .mac_ops = &ich8_mac_ops, 6208 + .phy_ops = &ich8_phy_ops, 6209 + .nvm_ops = &spt_nvm_ops, 6210 + }; 6211 + 6212 + const struct e1000_info e1000_pch_ptp_info = { 6213 + .mac = e1000_pch_ptp, 6203 6214 .flags = FLAG_IS_ICH 6204 6215 | FLAG_HAS_WOL 6205 6216 | FLAG_HAS_HW_TIMESTAMP
+7 -8
drivers/net/ethernet/intel/e1000e/netdev.c
··· 55 55 [board_pch_tgp] = &e1000_pch_tgp_info, 56 56 [board_pch_adp] = &e1000_pch_adp_info, 57 57 [board_pch_mtp] = &e1000_pch_mtp_info, 58 + [board_pch_ptp] = &e1000_pch_ptp_info, 58 59 }; 59 60 60 61 struct e1000_reg_info { ··· 7923 7922 { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_V21), board_pch_mtp }, 7924 7923 { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ARL_I219_LM24), board_pch_mtp }, 7925 7924 { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ARL_I219_V24), board_pch_mtp }, 7926 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM25), board_pch_mtp }, 7927 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V25), board_pch_mtp }, 7928 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM26), board_pch_mtp }, 7929 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V26), board_pch_mtp }, 7930 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM27), board_pch_mtp }, 7931 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V27), board_pch_mtp }, 7932 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_LM29), board_pch_mtp }, 7933 - { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_V29), board_pch_mtp }, 7925 + { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM25), board_pch_ptp }, 7926 + { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V25), board_pch_ptp }, 7927 + { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM27), board_pch_ptp }, 7928 + { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V27), board_pch_ptp }, 7929 + { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_LM29), board_pch_ptp }, 7930 + { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_V29), board_pch_ptp }, 7934 7931 7935 7932 { 0, 0, 0, 0, 0, 0, 0 } /* terminate list */ 7936 7933 };
+1 -1
drivers/net/ethernet/intel/i40e/i40e_trace.h
··· 88 88 __entry->rx_clean_complete = rx_clean_complete; 89 89 __entry->tx_clean_complete = tx_clean_complete; 90 90 __entry->irq_num = q->irq_num; 91 - __entry->curr_cpu = get_cpu(); 91 + __entry->curr_cpu = smp_processor_id(); 92 92 __assign_str(qname); 93 93 __assign_str(dev_name); 94 94 __assign_bitmask(irq_affinity, cpumask_bits(&q->affinity_mask),
+1
drivers/net/ethernet/intel/ice/ice.h
··· 987 987 void ice_print_link_msg(struct ice_vsi *vsi, bool isup); 988 988 int ice_plug_aux_dev(struct ice_pf *pf); 989 989 void ice_unplug_aux_dev(struct ice_pf *pf); 990 + void ice_rdma_finalize_setup(struct ice_pf *pf); 990 991 int ice_init_rdma(struct ice_pf *pf); 991 992 void ice_deinit_rdma(struct ice_pf *pf); 992 993 bool ice_is_wol_supported(struct ice_hw *hw);
+4 -1
drivers/net/ethernet/intel/ice/ice_base.c
··· 124 124 if (vsi->type == ICE_VSI_VF) { 125 125 ice_calc_vf_reg_idx(vsi->vf, q_vector); 126 126 goto out; 127 + } else if (vsi->type == ICE_VSI_LB) { 128 + goto skip_alloc; 127 129 } else if (vsi->type == ICE_VSI_CTRL && vsi->vf) { 128 130 struct ice_vsi *ctrl_vsi = ice_get_vf_ctrl_vsi(pf, vsi); 129 131 ··· 664 662 u32 rx_buf_len; 665 663 int err; 666 664 667 - if (ring->vsi->type == ICE_VSI_PF || ring->vsi->type == ICE_VSI_SF) { 665 + if (ring->vsi->type == ICE_VSI_PF || ring->vsi->type == ICE_VSI_SF || 666 + ring->vsi->type == ICE_VSI_LB) { 668 667 if (!xdp_rxq_info_is_reg(&ring->xdp_rxq)) { 669 668 err = __xdp_rxq_info_reg(&ring->xdp_rxq, ring->netdev, 670 669 ring->q_index,
+4
drivers/net/ethernet/intel/ice/ice_ethtool.c
··· 1289 1289 test_vsi->netdev = netdev; 1290 1290 tx_ring = test_vsi->tx_rings[0]; 1291 1291 rx_ring = test_vsi->rx_rings[0]; 1292 + /* Dummy q_vector and napi. Fill the minimum required for 1293 + * ice_rxq_pp_create(). 1294 + */ 1295 + rx_ring->q_vector->napi.dev = netdev; 1292 1296 1293 1297 if (ice_lbtest_prepare_rings(test_vsi)) { 1294 1298 ret = 2;
+34 -10
drivers/net/ethernet/intel/ice/ice_idc.c
··· 361 361 } 362 362 363 363 /** 364 + * ice_rdma_finalize_setup - Complete RDMA setup after VSI is ready 365 + * @pf: ptr to ice_pf 366 + * 367 + * Sets VSI-dependent information and plugs aux device. 368 + * Must be called after ice_init_rdma(), ice_vsi_rebuild(), and 369 + * ice_dcb_rebuild() complete. 370 + */ 371 + void ice_rdma_finalize_setup(struct ice_pf *pf) 372 + { 373 + struct device *dev = ice_pf_to_dev(pf); 374 + struct iidc_rdma_priv_dev_info *privd; 375 + int ret; 376 + 377 + if (!ice_is_rdma_ena(pf) || !pf->cdev_info) 378 + return; 379 + 380 + privd = pf->cdev_info->iidc_priv; 381 + if (!privd || !pf->vsi || !pf->vsi[0] || !pf->vsi[0]->netdev) 382 + return; 383 + 384 + /* Assign VSI info now that VSI is valid */ 385 + privd->netdev = pf->vsi[0]->netdev; 386 + privd->vport_id = pf->vsi[0]->vsi_num; 387 + 388 + /* Update QoS info after DCB has been rebuilt */ 389 + ice_setup_dcb_qos_info(pf, &privd->qos_info); 390 + 391 + ret = ice_plug_aux_dev(pf); 392 + if (ret) 393 + dev_warn(dev, "Failed to plug RDMA aux device: %d\n", ret); 394 + } 395 + 396 + /** 364 397 * ice_init_rdma - initializes PF for RDMA use 365 398 * @pf: ptr to ice_pf 366 399 */ ··· 431 398 } 432 399 433 400 cdev->iidc_priv = privd; 434 - privd->netdev = pf->vsi[0]->netdev; 435 401 436 402 privd->hw_addr = (u8 __iomem *)pf->hw.hw_addr; 437 403 cdev->pdev = pf->pdev; 438 - privd->vport_id = pf->vsi[0]->vsi_num; 439 404 440 405 pf->cdev_info->rdma_protocol |= IIDC_RDMA_PROTOCOL_ROCEV2; 441 - ice_setup_dcb_qos_info(pf, &privd->qos_info); 442 - ret = ice_plug_aux_dev(pf); 443 - if (ret) 444 - goto err_plug_aux_dev; 406 + 445 407 return 0; 446 408 447 - err_plug_aux_dev: 448 - pf->cdev_info->adev = NULL; 449 - xa_erase(&ice_aux_id, pf->aux_idx); 450 409 err_alloc_xa: 451 410 kfree(privd); 452 411 err_privd_alloc: ··· 457 432 if (!ice_is_rdma_ena(pf)) 458 433 return; 459 434 460 - ice_unplug_aux_dev(pf); 461 435 xa_erase(&ice_aux_id, pf->aux_idx); 462 436 kfree(pf->cdev_info->iidc_priv); 463 437 kfree(pf->cdev_info);
+10 -5
drivers/net/ethernet/intel/ice/ice_lib.c
··· 107 107 if (!vsi->rxq_map) 108 108 goto err_rxq_map; 109 109 110 - /* There is no need to allocate q_vectors for a loopback VSI. */ 111 - if (vsi->type == ICE_VSI_LB) 112 - return 0; 113 - 114 110 /* allocate memory for q_vector pointers */ 115 111 vsi->q_vectors = devm_kcalloc(dev, vsi->num_q_vectors, 116 112 sizeof(*vsi->q_vectors), GFP_KERNEL); ··· 237 241 case ICE_VSI_LB: 238 242 vsi->alloc_txq = 1; 239 243 vsi->alloc_rxq = 1; 244 + /* A dummy q_vector, no actual IRQ. */ 245 + vsi->num_q_vectors = 1; 240 246 break; 241 247 default: 242 248 dev_warn(ice_pf_to_dev(pf), "Unknown VSI type %d\n", vsi_type); ··· 2424 2426 } 2425 2427 break; 2426 2428 case ICE_VSI_LB: 2427 - ret = ice_vsi_alloc_rings(vsi); 2429 + ret = ice_vsi_alloc_q_vectors(vsi); 2428 2430 if (ret) 2429 2431 goto unroll_vsi_init; 2432 + 2433 + ret = ice_vsi_alloc_rings(vsi); 2434 + if (ret) 2435 + goto unroll_alloc_q_vector; 2430 2436 2431 2437 ret = ice_vsi_alloc_ring_stats(vsi); 2432 2438 if (ret) 2433 2439 goto unroll_vector_base; 2440 + 2441 + /* Simply map the dummy q_vector to the only rx_ring */ 2442 + vsi->rx_rings[0]->q_vector = vsi->q_vectors[0]; 2434 2443 2435 2444 break; 2436 2445 default:
+6 -1
drivers/net/ethernet/intel/ice/ice_main.c
··· 5138 5138 if (err) 5139 5139 goto err_init_rdma; 5140 5140 5141 + /* Finalize RDMA: VSI already created, assign info and plug device */ 5142 + ice_rdma_finalize_setup(pf); 5143 + 5141 5144 ice_service_task_restart(pf); 5142 5145 5143 5146 clear_bit(ICE_DOWN, pf->state); ··· 5172 5169 5173 5170 devl_assert_locked(priv_to_devlink(pf)); 5174 5171 5172 + ice_unplug_aux_dev(pf); 5175 5173 ice_deinit_rdma(pf); 5176 5174 ice_deinit_features(pf); 5177 5175 ice_tc_indir_block_unregister(vsi); ··· 5599 5595 */ 5600 5596 disabled = ice_service_task_stop(pf); 5601 5597 5598 + ice_unplug_aux_dev(pf); 5602 5599 ice_deinit_rdma(pf); 5603 5600 5604 5601 /* Already suspended?, then there is nothing to do */ ··· 7864 7859 7865 7860 ice_health_clear(pf); 7866 7861 7867 - ice_plug_aux_dev(pf); 7862 + ice_rdma_finalize_setup(pf); 7868 7863 if (ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) 7869 7864 ice_lag_rebuild(pf); 7870 7865
-3
drivers/net/ethernet/intel/idpf/idpf_ethtool.c
··· 307 307 vport_config = vport->adapter->vport_config[np->vport_idx]; 308 308 user_config = &vport_config->user_config; 309 309 310 - if (!idpf_sideband_action_ena(vport, fsp)) 311 - return -EOPNOTSUPP; 312 - 313 310 rule = kzalloc_flex(*rule, rule_info, 1); 314 311 if (!rule) 315 312 return -ENOMEM;
+1
drivers/net/ethernet/intel/idpf/idpf_lib.c
··· 1318 1318 1319 1319 free_rss_key: 1320 1320 kfree(rss_data->rss_key); 1321 + rss_data->rss_key = NULL; 1321 1322 free_qreg_chunks: 1322 1323 idpf_vport_deinit_queue_reg_chunks(adapter->vport_config[idx]); 1323 1324 free_vector_idxs:
+10 -4
drivers/net/ethernet/intel/idpf/idpf_txrx.c
··· 1314 1314 struct idpf_txq_group *txq_grp = &rsrc->txq_grps[i]; 1315 1315 1316 1316 for (unsigned int j = 0; j < txq_grp->num_txq; j++) { 1317 + if (!txq_grp->txqs[j]) 1318 + continue; 1319 + 1317 1320 if (idpf_queue_has(FLOW_SCH_EN, txq_grp->txqs[j])) { 1318 1321 kfree(txq_grp->txqs[j]->refillq); 1319 1322 txq_grp->txqs[j]->refillq = NULL; ··· 1342 1339 */ 1343 1340 static void idpf_rxq_sw_queue_rel(struct idpf_rxq_group *rx_qgrp) 1344 1341 { 1342 + if (!rx_qgrp->splitq.bufq_sets) 1343 + return; 1344 + 1345 1345 for (unsigned int i = 0; i < rx_qgrp->splitq.num_bufq_sets; i++) { 1346 1346 struct idpf_bufq_set *bufq_set = &rx_qgrp->splitq.bufq_sets[i]; 1347 1347 ··· 2342 2336 2343 2337 do { 2344 2338 struct idpf_splitq_4b_tx_compl_desc *tx_desc; 2345 - struct idpf_tx_queue *target; 2339 + struct idpf_tx_queue *target = NULL; 2346 2340 u32 ctype_gen, id; 2347 2341 2348 2342 tx_desc = flow ? &complq->comp[ntc].common : ··· 2362 2356 target = complq->txq_grp->txqs[id]; 2363 2357 2364 2358 idpf_queue_clear(SW_MARKER, target); 2365 - if (target == txq) 2366 - break; 2367 2359 2368 2360 next: 2369 2361 if (unlikely(++ntc == complq->desc_count)) { 2370 2362 ntc = 0; 2371 2363 gen_flag = !gen_flag; 2372 2364 } 2365 + if (target == txq) 2366 + break; 2373 2367 } while (time_before(jiffies, timeout)); 2374 2368 2375 2369 idpf_queue_assign(GEN_CHK, complq, gen_flag); ··· 4065 4059 continue; 4066 4060 4067 4061 name = kasprintf(GFP_KERNEL, "%s-%s-%s-%d", drv_name, if_name, 4068 - vec_name, vidx); 4062 + vec_name, vector); 4069 4063 4070 4064 err = request_irq(irq_num, idpf_vport_intr_clean_queues, 0, 4071 4065 name, q_vector);
+2 -1
drivers/net/ethernet/intel/ixgbevf/vf.c
··· 852 852 if (!mac->get_link_status) 853 853 goto out; 854 854 855 - if (hw->mac.type == ixgbe_mac_e610_vf) { 855 + if (hw->mac.type == ixgbe_mac_e610_vf && 856 + hw->api_version >= ixgbe_mbox_api_16) { 856 857 ret_val = ixgbevf_get_pf_link_state(hw, speed, link_up); 857 858 if (ret_val) 858 859 goto out;