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 'wangxun-improvement'

Jiawen Wu says:

====================
Wangxun improvement

This patch series cleans up the code and enhances the implementation.
====================

Link: https://patch.msgid.link/20260407025616.33652-1-jiawenwu@trustnetic.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 17ad4759 436e9e48

+200 -132
+35 -2
drivers/net/ethernet/wangxun/libwx/wx_ethtool.c
··· 211 211 212 212 hwstats = &wx->stats; 213 213 stats->tx_pause_frames = hwstats->lxontxc + hwstats->lxofftxc; 214 - stats->rx_pause_frames = hwstats->lxonoffrxc; 214 + stats->rx_pause_frames = hwstats->lxonrxc + hwstats->lxoffrxc; 215 215 } 216 216 EXPORT_SYMBOL(wx_get_pause_stats); 217 217 ··· 261 261 return phylink_ethtool_ksettings_set(wx->phylink, cmd); 262 262 } 263 263 EXPORT_SYMBOL(wx_set_link_ksettings); 264 + 265 + void wx_get_wol(struct net_device *netdev, 266 + struct ethtool_wolinfo *wol) 267 + { 268 + struct wx *wx = netdev_priv(netdev); 269 + 270 + if (!wx->wol_hw_supported) 271 + return; 272 + wol->supported = WAKE_MAGIC; 273 + wol->wolopts = 0; 274 + if (wx->wol & WX_PSR_WKUP_CTL_MAG) 275 + wol->wolopts |= WAKE_MAGIC; 276 + } 277 + EXPORT_SYMBOL(wx_get_wol); 278 + 279 + int wx_set_wol(struct net_device *netdev, 280 + struct ethtool_wolinfo *wol) 281 + { 282 + struct wx *wx = netdev_priv(netdev); 283 + struct pci_dev *pdev = wx->pdev; 284 + 285 + if (!wx->wol_hw_supported) 286 + return -EOPNOTSUPP; 287 + 288 + wx->wol = 0; 289 + if (wol->wolopts & WAKE_MAGIC) 290 + wx->wol = WX_PSR_WKUP_CTL_MAG; 291 + wr32(wx, WX_PSR_WKUP_CTL, wx->wol); 292 + device_set_wakeup_enable(&pdev->dev, !!(wx->wol)); 293 + 294 + return 0; 295 + } 296 + EXPORT_SYMBOL(wx_set_wol); 264 297 265 298 void wx_get_pauseparam(struct net_device *netdev, 266 299 struct ethtool_pauseparam *pause) ··· 555 522 556 523 wx->ring_feature[RING_F_RSS].limit = count; 557 524 558 - return 0; 525 + return wx->setup_tc(dev, netdev_get_num_tc(dev)); 559 526 } 560 527 EXPORT_SYMBOL(wx_set_channels); 561 528
+4
drivers/net/ethernet/wangxun/libwx/wx_ethtool.h
··· 18 18 struct ethtool_link_ksettings *cmd); 19 19 int wx_set_link_ksettings(struct net_device *netdev, 20 20 const struct ethtool_link_ksettings *cmd); 21 + void wx_get_wol(struct net_device *netdev, 22 + struct ethtool_wolinfo *wol); 23 + int wx_set_wol(struct net_device *netdev, 24 + struct ethtool_wolinfo *wol); 21 25 void wx_get_pauseparam(struct net_device *netdev, 22 26 struct ethtool_pauseparam *pause); 23 27 int wx_set_pauseparam(struct net_device *netdev,
+59 -7
drivers/net/ethernet/wangxun/libwx/wx_hw.c
··· 2513 2513 return -ENOMEM; 2514 2514 } 2515 2515 2516 + spin_lock_init(&wx->hw_stats_lock); 2517 + mutex_init(&wx->reset_lock); 2516 2518 bitmap_zero(wx->state, WX_STATE_NBITS); 2517 2519 bitmap_zero(wx->flags, WX_PF_FLAGS_NBITS); 2518 2520 wx->misc_irq_domain = false; ··· 2774 2772 } 2775 2773 } 2776 2774 2775 + if (rx_pause && tx_pause) 2776 + wx->fc.mode = wx_fc_full; 2777 + else if (rx_pause) 2778 + wx->fc.mode = wx_fc_rx_pause; 2779 + else if (tx_pause) 2780 + wx->fc.mode = wx_fc_tx_pause; 2781 + else 2782 + wx->fc.mode = wx_fc_none; 2783 + 2777 2784 /* Disable any previous flow control settings */ 2778 2785 mflcn_reg = rd32(wx, WX_MAC_RX_FLOW_CTRL); 2779 2786 mflcn_reg &= ~WX_MAC_RX_FLOW_CTRL_RFE; ··· 2801 2790 2802 2791 /* Set up and enable Rx high/low water mark thresholds, enable XON. */ 2803 2792 if (tx_pause && wx->fc.high_water) { 2804 - fcrtl = (wx->fc.low_water << 10) | WX_RDB_RFCL_XONE; 2793 + fcrtl = (wx->fc.low_water << 10); 2794 + if (wx->mac.type != wx_mac_sp) 2795 + fcrtl |= WX_RDB_RFCL_XONE; 2805 2796 wr32(wx, WX_RDB_RFCL, fcrtl); 2806 2797 fcrth = (wx->fc.high_water << 10) | WX_RDB_RFCH_XOFFE; 2807 2798 } else { ··· 2844 2831 } 2845 2832 EXPORT_SYMBOL(wx_fc_enable); 2846 2833 2834 + static void wx_update_xoff_rx_lfc(struct wx *wx) 2835 + { 2836 + struct wx_hw_stats *hwstats = &wx->stats; 2837 + 2838 + if (wx->fc.mode != wx_fc_full && 2839 + wx->fc.mode != wx_fc_rx_pause) 2840 + return; 2841 + 2842 + if (wx->mac.type >= wx_mac_aml) 2843 + hwstats->lxoffrxc += rd32_wrap(wx, WX_MAC_LXOFFRXC_AML, 2844 + &wx->last_stats.lxoffrxc); 2845 + else 2846 + hwstats->lxoffrxc += rd64(wx, WX_MAC_LXOFFRXC); 2847 + } 2848 + 2847 2849 /** 2848 2850 * wx_update_stats - Update the board statistics counters. 2849 2851 * @wx: board private structure ··· 2871 2843 u64 hw_csum_rx_good = 0, hw_csum_rx_error = 0; 2872 2844 u64 restart_queue = 0, tx_busy = 0; 2873 2845 u32 i; 2846 + 2847 + if (!netif_running(wx->netdev) || 2848 + test_bit(WX_STATE_RESETTING, wx->state)) 2849 + return; 2850 + 2851 + spin_lock(&wx->hw_stats_lock); 2874 2852 2875 2853 /* gather some stats to the wx struct that are per queue */ 2876 2854 for (i = 0; i < wx->num_rx_queues; i++) { ··· 2913 2879 wx->restart_queue = restart_queue; 2914 2880 wx->tx_busy = tx_busy; 2915 2881 2882 + wx_update_xoff_rx_lfc(wx); 2883 + 2916 2884 hwstats->gprc += rd32(wx, WX_RDM_PKT_CNT); 2917 2885 hwstats->gptc += rd32(wx, WX_TDM_PKT_CNT); 2918 2886 hwstats->gorc += rd64(wx, WX_RDM_BYTE_CNT_LSB); ··· 2929 2893 hwstats->mptc += rd64(wx, WX_TX_MC_FRAMES_GOOD_L); 2930 2894 hwstats->roc += rd32(wx, WX_RX_OVERSIZE_FRAMES_GOOD); 2931 2895 hwstats->ruc += rd32(wx, WX_RX_UNDERSIZE_FRAMES_GOOD); 2932 - hwstats->lxonoffrxc += rd32(wx, WX_MAC_LXONOFFRXC); 2896 + if (wx->mac.type >= wx_mac_aml) 2897 + hwstats->lxonrxc += rd32_wrap(wx, WX_MAC_LXONRXC_AML, 2898 + &wx->last_stats.lxonrxc); 2899 + else 2900 + hwstats->lxonrxc += rd32(wx, WX_MAC_LXONRXC); 2933 2901 hwstats->lxontxc += rd32(wx, WX_RDB_LXONTXC); 2934 2902 hwstats->lxofftxc += rd32(wx, WX_RDB_LXOFFTXC); 2935 2903 hwstats->o2bgptc += rd32(wx, WX_TDM_OS2BMC_CNT); ··· 2947 2907 hwstats->fdirmiss += rd32(wx, WX_RDB_FDIR_MISS); 2948 2908 } 2949 2909 2950 - /* qmprc is not cleared on read, manual reset it */ 2951 - hwstats->qmprc = 0; 2952 2910 for (i = wx->num_vfs * wx->num_rx_queues_per_pool; 2953 2911 i < wx->mac.max_rx_queues; i++) 2954 - hwstats->qmprc += rd32(wx, WX_PX_MPRC(i)); 2912 + hwstats->qmprc += rd32_wrap(wx, WX_PX_MPRC(i), 2913 + &wx->last_stats.qmprc[i]); 2914 + 2915 + spin_unlock(&wx->hw_stats_lock); 2955 2916 } 2956 2917 EXPORT_SYMBOL(wx_update_stats); 2957 2918 ··· 2967 2926 { 2968 2927 u16 i = 0; 2969 2928 2970 - for (i = 0; i < wx->mac.max_rx_queues; i++) 2929 + for (i = wx->num_vfs * wx->num_rx_queues_per_pool; 2930 + i < wx->mac.max_rx_queues; i++) { 2971 2931 wr32(wx, WX_PX_MPRC(i), 0); 2932 + wx->last_stats.qmprc[i] = 0; 2933 + } 2972 2934 2973 2935 rd32(wx, WX_RDM_PKT_CNT); 2974 2936 rd32(wx, WX_TDM_PKT_CNT); ··· 2990 2946 rd64(wx, WX_RX_LEN_ERROR_FRAMES_L); 2991 2947 rd32(wx, WX_RDB_LXONTXC); 2992 2948 rd32(wx, WX_RDB_LXOFFTXC); 2993 - rd32(wx, WX_MAC_LXONOFFRXC); 2949 + if (wx->mac.type >= wx_mac_aml) { 2950 + wr32(wx, WX_MAC_LXONRXC_AML, 0); 2951 + wr32(wx, WX_MAC_LXOFFRXC_AML, 0); 2952 + wx->last_stats.lxonrxc = 0; 2953 + wx->last_stats.lxoffrxc = 0; 2954 + } else { 2955 + rd32(wx, WX_MAC_LXONRXC); 2956 + rd64(wx, WX_MAC_LXOFFRXC); 2957 + } 2994 2958 } 2995 2959 EXPORT_SYMBOL(wx_clear_hw_cntrs); 2996 2960
+36 -17
drivers/net/ethernet/wangxun/libwx/wx_type.h
··· 79 79 #define WX_RX_LEN_ERROR_FRAMES_L 0x11978 80 80 #define WX_RX_UNDERSIZE_FRAMES_GOOD 0x11938 81 81 #define WX_RX_OVERSIZE_FRAMES_GOOD 0x1193C 82 - #define WX_MAC_LXONOFFRXC 0x11E0C 82 + #define WX_MAC_LXOFFRXC 0x11988 83 + #define WX_MAC_LXONRXC 0x11E0C 84 + #define WX_MAC_LXOFFRXC_AML 0x11F80 85 + #define WX_MAC_LXONRXC_AML 0x11F84 83 86 84 87 /*********************** Receive DMA registers **************************/ 85 88 #define WX_RDM_VF_RE(_i) (0x12004 + ((_i) * 4)) ··· 1151 1148 WX_ISB_MAX 1152 1149 }; 1153 1150 1151 + /* Flow Control Settings */ 1152 + enum wx_fc_mode { 1153 + wx_fc_none = 0, 1154 + wx_fc_rx_pause, 1155 + wx_fc_tx_pause, 1156 + wx_fc_full 1157 + }; 1158 + 1154 1159 struct wx_fc_info { 1155 1160 u32 high_water; /* Flow Ctrl High-water */ 1156 1161 u32 low_water; /* Flow Ctrl Low-water */ 1162 + enum wx_fc_mode mode; /* Flow Control Mode */ 1157 1163 }; 1158 1164 1159 1165 /* Statistics counters collected by the MAC */ ··· 1179 1167 u64 mptc; 1180 1168 u64 roc; 1181 1169 u64 ruc; 1182 - u64 lxonoffrxc; 1170 + u64 lxonrxc; 1171 + u64 lxoffrxc; 1183 1172 u64 lxontxc; 1184 1173 u64 lxofftxc; 1185 1174 u64 o2bgptc; ··· 1193 1180 u64 qmprc; 1194 1181 u64 fdirmatch; 1195 1182 u64 fdirmiss; 1183 + }; 1184 + 1185 + struct wx_last_stats { 1186 + u32 qmprc[128]; 1187 + u32 lxoffrxc; 1188 + u32 lxonrxc; 1196 1189 }; 1197 1190 1198 1191 enum wx_state { ··· 1373 1354 bool default_up; 1374 1355 1375 1356 struct wx_hw_stats stats; 1357 + struct wx_last_stats last_stats; 1358 + spinlock_t hw_stats_lock; /* spinlock for accessing to hw stats */ 1376 1359 u64 tx_busy; 1377 1360 u64 non_eop_descs; 1378 1361 u64 restart_queue; ··· 1421 1400 1422 1401 struct timer_list service_timer; 1423 1402 struct work_struct service_task; 1403 + struct mutex reset_lock; /* mutex for reset */ 1424 1404 }; 1425 1405 1426 1406 #define WX_INTR_ALL (~0ULL) ··· 1484 1462 return wr32(wx, reg + 0xB500, value); 1485 1463 } 1486 1464 1465 + static inline u32 1466 + rd32_wrap(struct wx *wx, u32 reg, u32 *last) 1467 + { 1468 + u32 val, delta; 1469 + 1470 + val = rd32(wx, reg); 1471 + delta = val - *last; 1472 + *last = val; 1473 + 1474 + return delta; 1475 + } 1476 + 1487 1477 /* On some domestic CPU platforms, sometimes IO is not synchronized with 1488 1478 * flushing memory, here use readl() to flush PCI read and write. 1489 1479 */ ··· 1510 1476 static inline struct wx *phylink_to_wx(struct phylink_config *config) 1511 1477 { 1512 1478 return container_of(config, struct wx, phylink_config); 1513 - } 1514 - 1515 - static inline int wx_set_state_reset(struct wx *wx) 1516 - { 1517 - u8 timeout = 50; 1518 - 1519 - while (test_and_set_bit(WX_STATE_RESETTING, wx->state)) { 1520 - timeout--; 1521 - if (!timeout) 1522 - return -EBUSY; 1523 - 1524 - usleep_range(1000, 2000); 1525 - } 1526 - 1527 - return 0; 1528 1479 } 1529 1480 1530 1481 static inline unsigned int wx_rx_pg_order(struct wx_ring *ring)
+6 -3
drivers/net/ethernet/wangxun/libwx/wx_vf_common.c
··· 48 48 struct wx *wx = pci_get_drvdata(pdev); 49 49 struct net_device *netdev; 50 50 51 - cancel_work_sync(&wx->service_task); 52 51 netdev = wx->netdev; 53 52 unregister_netdev(netdev); 53 + timer_shutdown_sync(&wx->service_timer); 54 + cancel_work_sync(&wx->service_task); 54 55 kfree(wx->vfinfo); 55 56 kfree(wx->rss_key); 56 57 kfree(wx->mac_table); ··· 340 339 341 340 static void wxvf_reinit_locked(struct wx *wx) 342 341 { 343 - while (test_and_set_bit(WX_STATE_RESETTING, wx->state)) 344 - usleep_range(1000, 2000); 342 + mutex_lock(&wx->reset_lock); 343 + set_bit(WX_STATE_RESETTING, wx->state); 344 + 345 345 wxvf_down(wx); 346 346 wx_free_irq(wx); 347 347 wx_configure_vf(wx); 348 348 wx_request_msix_irqs_vf(wx); 349 349 wxvf_up_complete(wx); 350 350 clear_bit(WX_STATE_RESETTING, wx->state); 351 + mutex_unlock(&wx->reset_lock); 351 352 } 352 353 353 354 static void wxvf_reset_subtask(struct wx *wx)
+6 -51
drivers/net/ethernet/wangxun/ngbe/ngbe_ethtool.c
··· 12 12 #include "ngbe_ethtool.h" 13 13 #include "ngbe_type.h" 14 14 15 - static void ngbe_get_wol(struct net_device *netdev, 16 - struct ethtool_wolinfo *wol) 17 - { 18 - struct wx *wx = netdev_priv(netdev); 19 - 20 - if (!wx->wol_hw_supported) 21 - return; 22 - wol->supported = WAKE_MAGIC; 23 - wol->wolopts = 0; 24 - if (wx->wol & WX_PSR_WKUP_CTL_MAG) 25 - wol->wolopts |= WAKE_MAGIC; 26 - } 27 - 28 - static int ngbe_set_wol(struct net_device *netdev, 29 - struct ethtool_wolinfo *wol) 30 - { 31 - struct wx *wx = netdev_priv(netdev); 32 - struct pci_dev *pdev = wx->pdev; 33 - 34 - if (!wx->wol_hw_supported) 35 - return -EOPNOTSUPP; 36 - 37 - wx->wol = 0; 38 - if (wol->wolopts & WAKE_MAGIC) 39 - wx->wol = WX_PSR_WKUP_CTL_MAG; 40 - netdev->ethtool->wol_enabled = !!(wx->wol); 41 - wr32(wx, WX_PSR_WKUP_CTL, wx->wol); 42 - device_set_wakeup_enable(&pdev->dev, netdev->ethtool->wol_enabled); 43 - 44 - return 0; 45 - } 46 - 47 15 static int ngbe_set_ringparam(struct net_device *netdev, 48 16 struct ethtool_ringparam *ring, 49 17 struct kernel_ethtool_ringparam *kernel_ring, ··· 32 64 new_rx_count == wx->rx_ring_count) 33 65 return 0; 34 66 35 - err = wx_set_state_reset(wx); 36 - if (err) 37 - return err; 67 + mutex_lock(&wx->reset_lock); 68 + set_bit(WX_STATE_RESETTING, wx->state); 38 69 39 70 if (!netif_running(wx->netdev)) { 40 71 for (i = 0; i < wx->num_tx_queues; i++) ··· 64 97 65 98 clear_reset: 66 99 clear_bit(WX_STATE_RESETTING, wx->state); 100 + mutex_unlock(&wx->reset_lock); 67 101 return err; 68 - } 69 - 70 - static int ngbe_set_channels(struct net_device *dev, 71 - struct ethtool_channels *ch) 72 - { 73 - int err; 74 - 75 - err = wx_set_channels(dev, ch); 76 - if (err < 0) 77 - return err; 78 - 79 - /* use setup TC to update any traffic class queue mapping */ 80 - return ngbe_setup_tc(dev, netdev_get_num_tc(dev)); 81 102 } 82 103 83 104 static const struct ethtool_ops ngbe_ethtool_ops = { ··· 77 122 .get_link_ksettings = wx_get_link_ksettings, 78 123 .set_link_ksettings = wx_set_link_ksettings, 79 124 .nway_reset = wx_nway_reset, 80 - .get_wol = ngbe_get_wol, 81 - .set_wol = ngbe_set_wol, 125 + .get_wol = wx_get_wol, 126 + .set_wol = wx_set_wol, 82 127 .get_sset_count = wx_get_sset_count, 83 128 .get_strings = wx_get_strings, 84 129 .get_ethtool_stats = wx_get_ethtool_stats, ··· 91 136 .get_coalesce = wx_get_coalesce, 92 137 .set_coalesce = wx_set_coalesce, 93 138 .get_channels = wx_get_channels, 94 - .set_channels = ngbe_set_channels, 139 + .set_channels = wx_set_channels, 95 140 .get_rxfh_fields = wx_get_rxfh_fields, 96 141 .set_rxfh_fields = wx_set_rxfh_fields, 97 142 .get_rxfh_indir_size = wx_rss_indir_size,
+43 -9
drivers/net/ethernet/wangxun/ngbe/ngbe_main.c
··· 57 57 58 58 wx->mac.type = wx_mac_em; 59 59 type_mask = (u16)(wx->subsystem_device_id & NGBE_OEM_MASK); 60 - ncsi_mask = wx->subsystem_device_id & NGBE_NCSI_MASK; 61 - wol_mask = wx->subsystem_device_id & NGBE_WOL_MASK; 60 + ncsi_mask = wx->subsystem_device_id & WX_NCSI_MASK; 61 + wol_mask = wx->subsystem_device_id & WX_WOL_MASK; 62 62 63 63 val = rd32(wx, WX_CFG_PORT_ST); 64 64 wx->mac_type = (val & BIT(7)) >> 7 ? 65 65 em_mac_type_rgmii : 66 66 em_mac_type_mdi; 67 67 68 - wx->wol_hw_supported = (wol_mask == NGBE_WOL_SUP) ? 1 : 0; 69 - wx->ncsi_enabled = (ncsi_mask == NGBE_NCSI_MASK || 68 + wx->wol_hw_supported = (wol_mask == WX_WOL_SUP) ? 1 : 0; 69 + wx->ncsi_enabled = (ncsi_mask == WX_NCSI_SUP || 70 70 type_mask == NGBE_SUBID_OCP_CARD) ? 1 : 0; 71 71 72 72 switch (type_mask) { ··· 136 136 set_bit(0, &wx->fwd_bitmask); 137 137 138 138 return 0; 139 + } 140 + 141 + /** 142 + * ngbe_service_task - manages and runs subtasks 143 + * @work: pointer to work_struct containing our data 144 + **/ 145 + static void ngbe_service_task(struct work_struct *work) 146 + { 147 + struct wx *wx = container_of(work, struct wx, service_task); 148 + 149 + wx_update_stats(wx); 150 + 151 + wx_service_event_complete(wx); 152 + } 153 + 154 + static void ngbe_init_service(struct wx *wx) 155 + { 156 + timer_setup(&wx->service_timer, wx_service_timer, 0); 157 + INIT_WORK(&wx->service_task, ngbe_service_task); 158 + clear_bit(WX_STATE_SERVICE_SCHED, wx->state); 139 159 } 140 160 141 161 /** ··· 388 368 wx_napi_disable_all(wx); 389 369 netif_tx_stop_all_queues(netdev); 390 370 netif_tx_disable(netdev); 371 + 372 + timer_delete_sync(&wx->service_timer); 373 + cancel_work_sync(&wx->service_task); 374 + 391 375 if (wx->gpio_ctrl) 392 376 ngbe_sfp_modules_txrx_powerctl(wx, false); 393 377 wx_irq_disable(wx); ··· 431 407 wx_napi_enable_all(wx); 432 408 /* enable transmits */ 433 409 netif_tx_start_all_queues(wx->netdev); 410 + mod_timer(&wx->service_timer, jiffies); 434 411 435 412 /* clear any pending interrupts, may auto mask */ 436 413 rd32(wx, WX_PX_IC(0)); ··· 545 520 if (wufc) { 546 521 wx_set_rx_mode(netdev); 547 522 wx_configure_rx(wx); 548 - wr32(wx, NGBE_PSR_WKUP_CTL, wufc); 523 + wr32(wx, WX_PSR_WKUP_CTL, wufc); 549 524 } else { 550 - wr32(wx, NGBE_PSR_WKUP_CTL, 0); 525 + wr32(wx, WX_PSR_WKUP_CTL, 0); 551 526 } 552 527 pci_wake_from_d3(pdev, !!wufc); 553 528 *enable_wake = !!wufc; ··· 767 742 768 743 wx->wol = 0; 769 744 if (wx->wol_hw_supported) 770 - wx->wol = NGBE_PSR_WKUP_CTL_MAG; 745 + wx->wol = WX_PSR_WKUP_CTL_MAG; 771 746 772 747 netdev->ethtool->wol_enabled = !!(wx->wol); 773 - wr32(wx, NGBE_PSR_WKUP_CTL, wx->wol); 748 + wr32(wx, WX_PSR_WKUP_CTL, wx->wol); 774 749 device_set_wakeup_enable(&pdev->dev, wx->wol); 775 750 776 751 /* Save off EEPROM version number and Option Rom version which ··· 795 770 eth_hw_addr_set(netdev, wx->mac.perm_addr); 796 771 wx_mac_set_default_filter(wx, wx->mac.perm_addr); 797 772 773 + ngbe_init_service(wx); 774 + 798 775 err = wx_init_interrupt_scheme(wx); 799 776 if (err) 800 - goto err_free_mac_table; 777 + goto err_cancel_service; 801 778 802 779 /* phy Interface Configuration */ 803 780 err = ngbe_mdio_init(wx); ··· 819 792 wx_control_hw(wx, false); 820 793 err_clear_interrupt_scheme: 821 794 wx_clear_interrupt_scheme(wx); 795 + err_cancel_service: 796 + timer_delete_sync(&wx->service_timer); 797 + cancel_work_sync(&wx->service_task); 822 798 err_free_mac_table: 823 799 kfree(wx->rss_key); 824 800 kfree(wx->mac_table); ··· 850 820 netdev = wx->netdev; 851 821 wx_disable_sriov(wx); 852 822 unregister_netdev(netdev); 823 + 824 + timer_shutdown_sync(&wx->service_timer); 825 + cancel_work_sync(&wx->service_task); 826 + 853 827 phylink_destroy(wx->phylink); 854 828 pci_release_selected_regions(pdev, 855 829 pci_select_bars(pdev, IORESOURCE_MEM));
-17
drivers/net/ethernet/wangxun/ngbe/ngbe_type.h
··· 37 37 38 38 #define NGBE_OEM_MASK 0x00FF 39 39 40 - #define NGBE_NCSI_SUP 0x8000 41 - #define NGBE_NCSI_MASK 0x8000 42 - #define NGBE_WOL_SUP 0x4000 43 - #define NGBE_WOL_MASK 0x4000 44 - 45 40 /**************** EM Registers ****************************/ 46 41 /* chip control Registers */ 47 42 #define NGBE_MIS_PRB_CTL 0x10010 ··· 87 92 #define NGBE_PHY_CONFIG(reg_offset) (0x14000 + ((reg_offset) * 4)) 88 93 #define NGBE_CFG_LAN_SPEED 0x14440 89 94 #define NGBE_CFG_PORT_ST 0x14404 90 - 91 - /* Wake up registers */ 92 - #define NGBE_PSR_WKUP_CTL 0x15B80 93 - /* Wake Up Filter Control Bit */ 94 - #define NGBE_PSR_WKUP_CTL_LNKC BIT(0) /* Link Status Change Wakeup Enable*/ 95 - #define NGBE_PSR_WKUP_CTL_MAG BIT(1) /* Magic Packet Wakeup Enable */ 96 - #define NGBE_PSR_WKUP_CTL_EX BIT(2) /* Directed Exact Wakeup Enable */ 97 - #define NGBE_PSR_WKUP_CTL_MC BIT(3) /* Directed Multicast Wakeup Enable*/ 98 - #define NGBE_PSR_WKUP_CTL_BC BIT(4) /* Broadcast Wakeup Enable */ 99 - #define NGBE_PSR_WKUP_CTL_ARP BIT(5) /* ARP Request Packet Wakeup Enable*/ 100 - #define NGBE_PSR_WKUP_CTL_IPV4 BIT(6) /* Directed IPv4 Pkt Wakeup Enable */ 101 - #define NGBE_PSR_WKUP_CTL_IPV6 BIT(7) /* Directed IPv6 Pkt Wakeup Enable */ 102 95 103 96 #define NGBE_FW_EEPROM_CHECKSUM_CMD 0xE9 104 97 #define NGBE_FW_NVM_DATA_OFFSET 3
+4 -17
drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c
··· 56 56 new_rx_count == wx->rx_ring_count) 57 57 return 0; 58 58 59 - err = wx_set_state_reset(wx); 60 - if (err) 61 - return err; 59 + mutex_lock(&wx->reset_lock); 60 + set_bit(WX_STATE_RESETTING, wx->state); 62 61 63 62 if (!netif_running(wx->netdev)) { 64 63 for (i = 0; i < wx->num_tx_queues; i++) ··· 87 88 88 89 clear_reset: 89 90 clear_bit(WX_STATE_RESETTING, wx->state); 91 + mutex_unlock(&wx->reset_lock); 90 92 return err; 91 - } 92 - 93 - static int txgbe_set_channels(struct net_device *dev, 94 - struct ethtool_channels *ch) 95 - { 96 - int err; 97 - 98 - err = wx_set_channels(dev, ch); 99 - if (err < 0) 100 - return err; 101 - 102 - /* use setup TC to update any traffic class queue mapping */ 103 - return txgbe_setup_tc(dev, netdev_get_num_tc(dev)); 104 93 } 105 94 106 95 static int txgbe_get_ethtool_fdir_entry(struct txgbe *txgbe, ··· 574 587 .get_coalesce = wx_get_coalesce, 575 588 .set_coalesce = wx_set_coalesce, 576 589 .get_channels = wx_get_channels, 577 - .set_channels = txgbe_set_channels, 590 + .set_channels = wx_set_channels, 578 591 .get_rxnfc = txgbe_get_rxnfc, 579 592 .set_rxnfc = txgbe_set_rxnfc, 580 593 .get_rx_ring_count = txgbe_get_rx_ring_count,
+7 -9
drivers/net/ethernet/wangxun/txgbe/txgbe_main.c
··· 130 130 131 131 txgbe_module_detection_subtask(wx); 132 132 txgbe_link_config_subtask(wx); 133 + wx_update_stats(wx); 133 134 134 135 wx_service_event_complete(wx); 135 136 } ··· 599 598 600 599 static void txgbe_reinit_locked(struct wx *wx) 601 600 { 602 - int err = 0; 603 - 604 601 netif_trans_update(wx->netdev); 605 602 606 - err = wx_set_state_reset(wx); 607 - if (err) { 608 - wx_err(wx, "wait device reset timeout\n"); 609 - return; 610 - } 603 + mutex_lock(&wx->reset_lock); 604 + set_bit(WX_STATE_RESETTING, wx->state); 611 605 612 606 txgbe_down(wx); 613 607 txgbe_up(wx); 614 608 615 609 clear_bit(WX_STATE_RESETTING, wx->state); 610 + mutex_unlock(&wx->reset_lock); 616 611 } 617 612 618 613 void txgbe_do_reset(struct net_device *netdev) ··· 947 950 struct txgbe *txgbe = wx->priv; 948 951 struct net_device *netdev; 949 952 950 - cancel_work_sync(&wx->service_task); 951 - 952 953 netdev = wx->netdev; 953 954 wx_disable_sriov(wx); 954 955 unregister_netdev(netdev); 956 + 957 + timer_shutdown_sync(&wx->service_timer); 958 + cancel_work_sync(&wx->service_task); 955 959 956 960 txgbe_remove_phy(txgbe); 957 961 wx_free_isb_resources(wx);