From 5654de14274dcc2c01f952fe29b1712465771461 Mon Sep 17 00:00:00 2001 From: Noah Meyerhans Date: Mon, 28 Oct 2019 11:48:31 -0700 Subject: [PATCH] drivers/net/ethernet/amazon: Backport ENA driver from Linux v5.4rc5 --- debian/changelog | 3 + ...ena-don-t-wake-up-tx-queue-when-down.patch | 49 +++ ..._moder_rx_interval-to-struct-ena_com.patch | 118 ++++++ ...o-dim-algorithm-for-rx-adaptive-inte.patch | 163 ++++++++ ...net-ena-reimplement-set-get_coalesce.patch | 158 ++++++++ ...he-interrupt_moderation-in-driver_su.patch | 63 +++ ...ode-duplication-in-ena_com_update_no.patch | 71 ++++ ...ld-adaptive-interrupt-moderation-cod.patch | 83 ++++ ...na_restore_ethtool_params-and-releva.patch | 59 +++ ...ll-old-adaptive-rx-interrupt-moderat.patch | 361 ++++++++++++++++++ ...ate-of-interrupt-moderation-register.patch | 39 ++ ...ieval-of-nonadaptive-interrupt-moder.patch | 45 +++ ...rrect-update-of-intr_delay_resolutio.patch | 89 +++++ ...t-ena-Select-DIMLIB-for-ENA_ETHERNET.patch | 40 ++ ...4-net-ena-clean-up-indentation-issue.patch | 29 ++ debian/patches/series | 14 + 16 files changed, 1384 insertions(+) create mode 100644 debian/patches/features/all/ena/0001-net-ena-don-t-wake-up-tx-queue-when-down.patch create mode 100644 debian/patches/features/all/ena/0002-net-ena-add-intr_moder_rx_interval-to-struct-ena_com.patch create mode 100644 debian/patches/features/all/ena/0003-net-ena-switch-to-dim-algorithm-for-rx-adaptive-inte.patch create mode 100644 debian/patches/features/all/ena/0004-net-ena-reimplement-set-get_coalesce.patch create mode 100644 debian/patches/features/all/ena/0005-net-ena-enable-the-interrupt_moderation-in-driver_su.patch create mode 100644 debian/patches/features/all/ena/0006-net-ena-remove-code-duplication-in-ena_com_update_no.patch create mode 100644 debian/patches/features/all/ena/0007-net-ena-remove-old-adaptive-interrupt-moderation-cod.patch create mode 100644 debian/patches/features/all/ena/0008-net-ena-remove-ena_restore_ethtool_params-and-releva.patch create mode 100644 debian/patches/features/all/ena/0009-net-ena-remove-all-old-adaptive-rx-interrupt-moderat.patch create mode 100644 debian/patches/features/all/ena/0010-net-ena-fix-update-of-interrupt-moderation-register.patch create mode 100644 debian/patches/features/all/ena/0011-net-ena-fix-retrieval-of-nonadaptive-interrupt-moder.patch create mode 100644 debian/patches/features/all/ena/0012-net-ena-fix-incorrect-update-of-intr_delay_resolutio.patch create mode 100644 debian/patches/features/all/ena/0013-net-ena-Select-DIMLIB-for-ENA_ETHERNET.patch create mode 100644 debian/patches/features/all/ena/0014-net-ena-clean-up-indentation-issue.patch diff --git a/debian/changelog b/debian/changelog index f7d76dd4c1c8..9d89fd90f291 100644 --- a/debian/changelog +++ b/debian/changelog @@ -30,6 +30,9 @@ linux (5.3.7-2) UNRELEASED; urgency=medium * [arm64] udeb: Add i2c-rk3x to i2c-modules * [arm64,armhf] udeb: Add rockchip-io-domain to kernel-image + [ Noah Meyerhans ] + * drivers/net/ethernet/amazon: Backport driver fixes from v5.4-rc5 + -- Ben Hutchings Wed, 23 Oct 2019 18:32:15 +0100 linux (5.3.7-1) unstable; urgency=medium diff --git a/debian/patches/features/all/ena/0001-net-ena-don-t-wake-up-tx-queue-when-down.patch b/debian/patches/features/all/ena/0001-net-ena-don-t-wake-up-tx-queue-when-down.patch new file mode 100644 index 000000000000..6a0c8b722fa7 --- /dev/null +++ b/debian/patches/features/all/ena/0001-net-ena-don-t-wake-up-tx-queue-when-down.patch @@ -0,0 +1,49 @@ +From: Sameeh Jubran +Date: Sun, 15 Sep 2019 17:29:44 +0300 +Subject: [PATCH 01/14] net: ena: don't wake up tx queue when down +Origin: https://git.kernel.org/linus/a53651ec93a8d7ab5b26c5390e0c389048b4b4b6 +Bug-Debian: https://bugs.debian.org/941291 + +There is a race condition that can occur when calling ena_down(). +The ena_clean_tx_irq() - which is a part of the napi handler - +function might wake up the tx queue when the queue is supposed +to be down (during recovery or changing the size of the queues +for example) This causes the ena_start_xmit() function to trigger +and possibly try to access the destroyed queues. + +The race is illustrated below: + +Flow A: Flow B(napi handler) +ena_down() + netif_carrier_off() + netif_tx_disable() + ena_clean_tx_irq() + netif_tx_wake_queue() + ena_napi_disable_all() + ena_destroy_all_io_queues() + +After these flows the tx queue is active and ena_start_xmit() accesses +the destroyed queue which leads to a kernel panic. + +fixes: 1738cd3ed342 (net: ena: Add a driver for Amazon Elastic Network Adapters (ENA)) + +Signed-off-by: Sameeh Jubran +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_netdev.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -823,7 +823,8 @@ static int ena_clean_tx_irq(struct ena_r + above_thresh = + ena_com_sq_have_enough_space(tx_ring->ena_com_io_sq, + ENA_TX_WAKEUP_THRESH); +- if (netif_tx_queue_stopped(txq) && above_thresh) { ++ if (netif_tx_queue_stopped(txq) && above_thresh && ++ test_bit(ENA_FLAG_DEV_UP, &tx_ring->adapter->flags)) { + netif_tx_wake_queue(txq); + u64_stats_update_begin(&tx_ring->syncp); + tx_ring->tx_stats.queue_wakeup++; diff --git a/debian/patches/features/all/ena/0002-net-ena-add-intr_moder_rx_interval-to-struct-ena_com.patch b/debian/patches/features/all/ena/0002-net-ena-add-intr_moder_rx_interval-to-struct-ena_com.patch new file mode 100644 index 000000000000..5f210902b30b --- /dev/null +++ b/debian/patches/features/all/ena/0002-net-ena-add-intr_moder_rx_interval-to-struct-ena_com.patch @@ -0,0 +1,118 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:26 +0300 +Subject: [PATCH 02/14] net: ena: add intr_moder_rx_interval to struct + ena_com_dev and use it +Origin: https://git.kernel.org/linus/15619e722b16aaa40f942b93631aa92581a7b393 +Bug-Debian: https://bugs.debian.org/941291 + +Add intr_moder_rx_interval to struct ena_com_dev and use it as the +location where the interrupt moderation rx interval is saved, instead +of the interrupt moderation table. + +This is done as a first step before removing the old interrupt moderation +code. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_com.c | 20 ++++---------------- + drivers/net/ethernet/amazon/ena/ena_com.h | 8 +++++++- + drivers/net/ethernet/amazon/ena/ena_netdev.c | 3 ++- + 3 files changed, 13 insertions(+), 18 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.c +@@ -1297,9 +1297,6 @@ static int ena_com_init_interrupt_modera + static void ena_com_update_intr_delay_resolution(struct ena_com_dev *ena_dev, + u16 intr_delay_resolution) + { +- struct ena_intr_moder_entry *intr_moder_tbl = ena_dev->intr_moder_tbl; +- unsigned int i; +- + if (!intr_delay_resolution) { + pr_err("Illegal intr_delay_resolution provided. Going to use default 1 usec resolution\n"); + intr_delay_resolution = 1; +@@ -1307,8 +1304,7 @@ static void ena_com_update_intr_delay_re + ena_dev->intr_delay_resolution = intr_delay_resolution; + + /* update Rx */ +- for (i = 0; i < ENA_INTR_MAX_NUM_OF_LEVELS; i++) +- intr_moder_tbl[i].intr_moder_interval /= intr_delay_resolution; ++ ena_dev->intr_moder_rx_interval /= intr_delay_resolution; + + /* update Tx */ + ena_dev->intr_moder_tx_interval /= intr_delay_resolution; +@@ -2798,11 +2794,8 @@ int ena_com_update_nonadaptive_moderatio + return -EFAULT; + } + +- /* We use LOWEST entry of moderation table for storing +- * nonadaptive interrupt coalescing values +- */ +- ena_dev->intr_moder_tbl[ENA_INTR_MODER_LOWEST].intr_moder_interval = +- rx_coalesce_usecs / ena_dev->intr_delay_resolution; ++ ena_dev->intr_moder_rx_interval = rx_coalesce_usecs / ++ ena_dev->intr_delay_resolution; + + return 0; + } +@@ -2907,12 +2900,7 @@ unsigned int ena_com_get_nonadaptive_mod + + unsigned int ena_com_get_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev) + { +- struct ena_intr_moder_entry *intr_moder_tbl = ena_dev->intr_moder_tbl; +- +- if (intr_moder_tbl) +- return intr_moder_tbl[ENA_INTR_MODER_LOWEST].intr_moder_interval; +- +- return 0; ++ return ena_dev->intr_moder_rx_interval; + } + + void ena_com_init_intr_moderation_entry(struct ena_com_dev *ena_dev, +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.h +@@ -93,7 +93,7 @@ + #define ENA_INTR_HIGHEST_BYTES (192 * 1024) + + #define ENA_INTR_INITIAL_TX_INTERVAL_USECS 196 +-#define ENA_INTR_INITIAL_RX_INTERVAL_USECS 4 ++#define ENA_INTR_INITIAL_RX_INTERVAL_USECS 0 + #define ENA_INTR_DELAY_OLD_VALUE_WEIGHT 6 + #define ENA_INTR_DELAY_NEW_VALUE_WEIGHT 4 + #define ENA_INTR_MODER_LEVEL_STRIDE 2 +@@ -376,7 +376,13 @@ struct ena_com_dev { + struct ena_host_attribute host_attr; + bool adaptive_coalescing; + u16 intr_delay_resolution; ++ ++ /* interrupt moderation intervals are in usec divided by ++ * intr_delay_resolution, which is supplied by the device. ++ */ + u32 intr_moder_tx_interval; ++ u32 intr_moder_rx_interval; ++ + struct ena_intr_moder_entry *intr_moder_tbl; + + struct ena_com_llq_info llq_info; +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -3486,10 +3486,11 @@ static int ena_probe(struct pci_dev *pde + calc_queue_ctx.get_feat_ctx = &get_feat_ctx; + calc_queue_ctx.pdev = pdev; + +- /* initial Tx interrupt delay, Assumes 1 usec granularity. ++ /* Initial Tx and RX interrupt delay. Assumes 1 usec granularity. + * Updated during device initialization with the real granularity + */ + ena_dev->intr_moder_tx_interval = ENA_INTR_INITIAL_TX_INTERVAL_USECS; ++ ena_dev->intr_moder_rx_interval = ENA_INTR_INITIAL_RX_INTERVAL_USECS; + io_queue_num = ena_calc_io_queue_num(pdev, ena_dev, &get_feat_ctx); + rc = ena_calc_queue_size(&calc_queue_ctx); + if (rc || io_queue_num <= 0) { diff --git a/debian/patches/features/all/ena/0003-net-ena-switch-to-dim-algorithm-for-rx-adaptive-inte.patch b/debian/patches/features/all/ena/0003-net-ena-switch-to-dim-algorithm-for-rx-adaptive-inte.patch new file mode 100644 index 000000000000..03a93d5cabbc --- /dev/null +++ b/debian/patches/features/all/ena/0003-net-ena-switch-to-dim-algorithm-for-rx-adaptive-inte.patch @@ -0,0 +1,163 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:27 +0300 +Subject: [PATCH 03/14] net: ena: switch to dim algorithm for rx adaptive + interrupt moderation +Origin: https://git.kernel.org/linus/282faf61a053be43910fcc42d86ecf16c0d30123 +Bug-Debian: https://bugs.debian.org/941291 + +Use the dim library for the rx adaptive interrupt moderation implementation + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_com.c | 4 +- + drivers/net/ethernet/amazon/ena/ena_netdev.c | 55 +++++++++++++------- + drivers/net/ethernet/amazon/ena/ena_netdev.h | 3 ++ + 3 files changed, 41 insertions(+), 21 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.c +@@ -2839,9 +2839,7 @@ int ena_com_init_interrupt_moderation(st + delay_resolution = get_resp.u.intr_moderation.intr_delay_resolution; + ena_com_update_intr_delay_resolution(ena_dev, delay_resolution); + +- /* Disable adaptive moderation by default - can be enabled from +- * ethtool +- */ ++ /* Disable adaptive moderation by default - can be enabled later */ + ena_com_disable_adaptive_moderation(ena_dev); + + return 0; +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -196,6 +196,7 @@ static void ena_init_io_rings(struct ena + rxr->smoothed_interval = + ena_com_get_nonadaptive_moderation_interval_rx(ena_dev); + rxr->empty_rx_queue = 0; ++ adapter->ena_napi[i].dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; + } + } + +@@ -712,6 +713,7 @@ static void ena_destroy_all_rx_queues(st + + for (i = 0; i < adapter->num_queues; i++) { + ena_qid = ENA_IO_RXQ_IDX(i); ++ cancel_work_sync(&adapter->ena_napi[i].dim.work); + ena_com_destroy_io_queue(adapter->ena_dev, ena_qid); + } + } +@@ -1156,23 +1158,35 @@ error: + return 0; + } + +-void ena_adjust_intr_moderation(struct ena_ring *rx_ring, +- struct ena_ring *tx_ring) ++static void ena_dim_work(struct work_struct *w) + { +- /* We apply adaptive moderation on Rx path only. +- * Tx uses static interrupt moderation. +- */ +- ena_com_calculate_interrupt_delay(rx_ring->ena_dev, +- rx_ring->per_napi_packets, +- rx_ring->per_napi_bytes, +- &rx_ring->smoothed_interval, +- &rx_ring->moder_tbl_idx); +- +- /* Reset per napi packets/bytes */ +- tx_ring->per_napi_packets = 0; +- tx_ring->per_napi_bytes = 0; ++ struct dim *dim = container_of(w, struct dim, work); ++ struct dim_cq_moder cur_moder = ++ net_dim_get_rx_moderation(dim->mode, dim->profile_ix); ++ struct ena_napi *ena_napi = container_of(dim, struct ena_napi, dim); ++ ++ ena_napi->rx_ring->smoothed_interval = cur_moder.usec; ++ dim->state = DIM_START_MEASURE; ++} ++ ++static void ena_adjust_adaptive_rx_intr_moderation(struct ena_napi *ena_napi) ++{ ++ struct dim_sample dim_sample; ++ struct ena_ring *rx_ring = ena_napi->rx_ring; ++ ++ if (!rx_ring->per_napi_packets) ++ return; ++ ++ rx_ring->non_empty_napi_events++; ++ ++ dim_update_sample(rx_ring->non_empty_napi_events, ++ rx_ring->rx_stats.cnt, ++ rx_ring->rx_stats.bytes, ++ &dim_sample); ++ ++ net_dim(&ena_napi->dim, dim_sample); ++ + rx_ring->per_napi_packets = 0; +- rx_ring->per_napi_bytes = 0; + } + + static void ena_unmask_interrupt(struct ena_ring *tx_ring, +@@ -1261,9 +1275,11 @@ static int ena_io_poll(struct napi_struc + * from the interrupt context (vs from sk_busy_loop) + */ + if (napi_complete_done(napi, rx_work_done)) { +- /* Tx and Rx share the same interrupt vector */ ++ /* We apply adaptive moderation on Rx path only. ++ * Tx uses static interrupt moderation. ++ */ + if (ena_com_get_adaptive_moderation_enabled(rx_ring->ena_dev)) +- ena_adjust_intr_moderation(rx_ring, tx_ring); ++ ena_adjust_adaptive_rx_intr_moderation(ena_napi); + + ena_unmask_interrupt(tx_ring, rx_ring); + } +@@ -1741,13 +1757,16 @@ static int ena_create_all_io_rx_queues(s + rc = ena_create_io_rx_queue(adapter, i); + if (rc) + goto create_err; ++ INIT_WORK(&adapter->ena_napi[i].dim.work, ena_dim_work); + } + + return 0; + + create_err: +- while (i--) ++ while (i--) { ++ cancel_work_sync(&adapter->ena_napi[i].dim.work); + ena_com_destroy_io_queue(ena_dev, ENA_IO_RXQ_IDX(i)); ++ } + + return rc; + } +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.h +@@ -34,6 +34,7 @@ + #define ENA_H + + #include ++#include + #include + #include + #include +@@ -153,6 +154,7 @@ struct ena_napi { + struct ena_ring *tx_ring; + struct ena_ring *rx_ring; + u32 qid; ++ struct dim dim; + }; + + struct ena_calc_queue_size_ctx { +@@ -280,6 +282,7 @@ struct ena_ring { + u32 per_napi_packets; + u32 per_napi_bytes; + enum ena_intr_moder_level moder_tbl_idx; ++ u16 non_empty_napi_events; + struct u64_stats_sync syncp; + union { + struct ena_stats_tx tx_stats; diff --git a/debian/patches/features/all/ena/0004-net-ena-reimplement-set-get_coalesce.patch b/debian/patches/features/all/ena/0004-net-ena-reimplement-set-get_coalesce.patch new file mode 100644 index 000000000000..8341546eca99 --- /dev/null +++ b/debian/patches/features/all/ena/0004-net-ena-reimplement-set-get_coalesce.patch @@ -0,0 +1,158 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:28 +0300 +Subject: [PATCH 04/14] net: ena: reimplement set/get_coalesce() +Origin: https://git.kernel.org/linus/b3db86dc4b82ffc63e33c78dafc09d5c78ac4fe4 +Bug-Debian: https://bugs.debian.org/941291 + +1. Remove old adaptive interrupt moderation code from set/get_coalesce() +2. Add ena_update_rx_rings_intr_moderation() function for updating + nonadaptive interrupt moderation intervals similarly to + ena_update_tx_rings_intr_moderation(). +3. Remove checks of multiple unsupported received interrupt coalescing + parameters. This makes code cleaner and cancels the need to update + it every time a new coalescing parameter is invented. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_ethtool.c | 84 ++++++------------- + 1 file changed, 26 insertions(+), 58 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_ethtool.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_ethtool.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_ethtool.c +@@ -305,7 +305,6 @@ static int ena_get_coalesce(struct net_d + { + struct ena_adapter *adapter = netdev_priv(net_dev); + struct ena_com_dev *ena_dev = adapter->ena_dev; +- struct ena_intr_moder_entry intr_moder_entry; + + if (!ena_com_interrupt_moderation_supported(ena_dev)) { + /* the devie doesn't support interrupt moderation */ +@@ -314,23 +313,12 @@ static int ena_get_coalesce(struct net_d + coalesce->tx_coalesce_usecs = + ena_com_get_nonadaptive_moderation_interval_tx(ena_dev) / + ena_dev->intr_delay_resolution; +- if (!ena_com_get_adaptive_moderation_enabled(ena_dev)) { ++ ++ if (!ena_com_get_adaptive_moderation_enabled(ena_dev)) + coalesce->rx_coalesce_usecs = + ena_com_get_nonadaptive_moderation_interval_rx(ena_dev) + / ena_dev->intr_delay_resolution; +- } else { +- ena_com_get_intr_moderation_entry(adapter->ena_dev, ENA_INTR_MODER_LOWEST, &intr_moder_entry); +- coalesce->rx_coalesce_usecs_low = intr_moder_entry.intr_moder_interval; +- coalesce->rx_max_coalesced_frames_low = intr_moder_entry.pkts_per_interval; +- +- ena_com_get_intr_moderation_entry(adapter->ena_dev, ENA_INTR_MODER_MID, &intr_moder_entry); +- coalesce->rx_coalesce_usecs = intr_moder_entry.intr_moder_interval; +- coalesce->rx_max_coalesced_frames = intr_moder_entry.pkts_per_interval; +- +- ena_com_get_intr_moderation_entry(adapter->ena_dev, ENA_INTR_MODER_HIGHEST, &intr_moder_entry); +- coalesce->rx_coalesce_usecs_high = intr_moder_entry.intr_moder_interval; +- coalesce->rx_max_coalesced_frames_high = intr_moder_entry.pkts_per_interval; +- } ++ + coalesce->use_adaptive_rx_coalesce = + ena_com_get_adaptive_moderation_enabled(ena_dev); + +@@ -348,12 +336,22 @@ static void ena_update_tx_rings_intr_mod + adapter->tx_ring[i].smoothed_interval = val; + } + ++static void ena_update_rx_rings_intr_moderation(struct ena_adapter *adapter) ++{ ++ unsigned int val; ++ int i; ++ ++ val = ena_com_get_nonadaptive_moderation_interval_rx(adapter->ena_dev); ++ ++ for (i = 0; i < adapter->num_queues; i++) ++ adapter->rx_ring[i].smoothed_interval = val; ++} ++ + static int ena_set_coalesce(struct net_device *net_dev, + struct ethtool_coalesce *coalesce) + { + struct ena_adapter *adapter = netdev_priv(net_dev); + struct ena_com_dev *ena_dev = adapter->ena_dev; +- struct ena_intr_moder_entry intr_moder_entry; + int rc; + + if (!ena_com_interrupt_moderation_supported(ena_dev)) { +@@ -361,22 +359,6 @@ static int ena_set_coalesce(struct net_d + return -EOPNOTSUPP; + } + +- if (coalesce->rx_coalesce_usecs_irq || +- coalesce->rx_max_coalesced_frames_irq || +- coalesce->tx_coalesce_usecs_irq || +- coalesce->tx_max_coalesced_frames || +- coalesce->tx_max_coalesced_frames_irq || +- coalesce->stats_block_coalesce_usecs || +- coalesce->use_adaptive_tx_coalesce || +- coalesce->pkt_rate_low || +- coalesce->tx_coalesce_usecs_low || +- coalesce->tx_max_coalesced_frames_low || +- coalesce->pkt_rate_high || +- coalesce->tx_coalesce_usecs_high || +- coalesce->tx_max_coalesced_frames_high || +- coalesce->rate_sample_interval) +- return -EINVAL; +- + rc = ena_com_update_nonadaptive_moderation_interval_tx(ena_dev, + coalesce->tx_coalesce_usecs); + if (rc) +@@ -384,37 +366,23 @@ static int ena_set_coalesce(struct net_d + + ena_update_tx_rings_intr_moderation(adapter); + +- if (ena_com_get_adaptive_moderation_enabled(ena_dev)) { +- if (!coalesce->use_adaptive_rx_coalesce) { +- ena_com_disable_adaptive_moderation(ena_dev); +- rc = ena_com_update_nonadaptive_moderation_interval_rx(ena_dev, +- coalesce->rx_coalesce_usecs); +- return rc; +- } +- } else { /* was in non-adaptive mode */ +- if (coalesce->use_adaptive_rx_coalesce) { ++ if (coalesce->use_adaptive_rx_coalesce) { ++ if (!ena_com_get_adaptive_moderation_enabled(ena_dev)) + ena_com_enable_adaptive_moderation(ena_dev); +- } else { +- rc = ena_com_update_nonadaptive_moderation_interval_rx(ena_dev, +- coalesce->rx_coalesce_usecs); +- return rc; +- } ++ return 0; + } + +- intr_moder_entry.intr_moder_interval = coalesce->rx_coalesce_usecs_low; +- intr_moder_entry.pkts_per_interval = coalesce->rx_max_coalesced_frames_low; +- intr_moder_entry.bytes_per_interval = ENA_INTR_BYTE_COUNT_NOT_SUPPORTED; +- ena_com_init_intr_moderation_entry(adapter->ena_dev, ENA_INTR_MODER_LOWEST, &intr_moder_entry); +- +- intr_moder_entry.intr_moder_interval = coalesce->rx_coalesce_usecs; +- intr_moder_entry.pkts_per_interval = coalesce->rx_max_coalesced_frames; +- intr_moder_entry.bytes_per_interval = ENA_INTR_BYTE_COUNT_NOT_SUPPORTED; +- ena_com_init_intr_moderation_entry(adapter->ena_dev, ENA_INTR_MODER_MID, &intr_moder_entry); +- +- intr_moder_entry.intr_moder_interval = coalesce->rx_coalesce_usecs_high; +- intr_moder_entry.pkts_per_interval = coalesce->rx_max_coalesced_frames_high; +- intr_moder_entry.bytes_per_interval = ENA_INTR_BYTE_COUNT_NOT_SUPPORTED; +- ena_com_init_intr_moderation_entry(adapter->ena_dev, ENA_INTR_MODER_HIGHEST, &intr_moder_entry); ++ rc = ena_com_update_nonadaptive_moderation_interval_rx(ena_dev, ++ coalesce->rx_coalesce_usecs); ++ if (rc) ++ return rc; ++ ++ ena_update_rx_rings_intr_moderation(adapter); ++ ++ if (!coalesce->use_adaptive_rx_coalesce) { ++ if (ena_com_get_adaptive_moderation_enabled(ena_dev)) ++ ena_com_disable_adaptive_moderation(ena_dev); ++ } + + return 0; + } diff --git a/debian/patches/features/all/ena/0005-net-ena-enable-the-interrupt_moderation-in-driver_su.patch b/debian/patches/features/all/ena/0005-net-ena-enable-the-interrupt_moderation-in-driver_su.patch new file mode 100644 index 000000000000..4db4ff5606a9 --- /dev/null +++ b/debian/patches/features/all/ena/0005-net-ena-enable-the-interrupt_moderation-in-driver_su.patch @@ -0,0 +1,63 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:29 +0300 +Subject: [PATCH 05/14] net: ena: enable the interrupt_moderation in + driver_supported_features +Origin: https://git.kernel.org/linus/bd21b0cc3a63d1c658b230db084b0f392b78cab2 +Bug-Debian: https://bugs.debian.org/941291 + +Add driver_supported_features to host_host info which is a new API used to +communicate to the device which features are supported by the driver. + +Add the interrupt_moderation bit to host_info->driver_supported_features +and enable it to signal the device that this driver supports interrupt +moderation properly. + +Reserved bits are for features implemented in the future + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_admin_defs.h | 8 ++++++++ + drivers/net/ethernet/amazon/ena/ena_netdev.c | 3 +++ + 2 files changed, 11 insertions(+) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_admin_defs.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_admin_defs.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_admin_defs.h +@@ -808,6 +808,12 @@ struct ena_admin_host_info { + u16 num_cpus; + + u16 reserved; ++ ++ /* 1 :0 : reserved ++ * 2 : interrupt_moderation ++ * 31:3 : reserved ++ */ ++ u32 driver_supported_features; + }; + + struct ena_admin_rss_ind_table_entry { +@@ -1110,6 +1116,8 @@ struct ena_admin_ena_mmio_req_read_less_ + #define ENA_ADMIN_HOST_INFO_DEVICE_MASK GENMASK(7, 3) + #define ENA_ADMIN_HOST_INFO_BUS_SHIFT 8 + #define ENA_ADMIN_HOST_INFO_BUS_MASK GENMASK(15, 8) ++#define ENA_ADMIN_HOST_INFO_INTERRUPT_MODERATION_SHIFT 2 ++#define ENA_ADMIN_HOST_INFO_INTERRUPT_MODERATION_MASK BIT(2) + + /* aenq_common_desc */ + #define ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK BIT(0) +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -2439,6 +2439,9 @@ static void ena_config_host_info(struct + ("K"[0] << ENA_ADMIN_HOST_INFO_MODULE_TYPE_SHIFT); + host_info->num_cpus = num_online_cpus(); + ++ host_info->driver_supported_features = ++ ENA_ADMIN_HOST_INFO_INTERRUPT_MODERATION_MASK; ++ + rc = ena_com_set_host_attributes(ena_dev); + if (rc) { + if (rc == -EOPNOTSUPP) diff --git a/debian/patches/features/all/ena/0006-net-ena-remove-code-duplication-in-ena_com_update_no.patch b/debian/patches/features/all/ena/0006-net-ena-remove-code-duplication-in-ena_com_update_no.patch new file mode 100644 index 000000000000..877debbc998b --- /dev/null +++ b/debian/patches/features/all/ena/0006-net-ena-remove-code-duplication-in-ena_com_update_no.patch @@ -0,0 +1,71 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:30 +0300 +Subject: [PATCH 06/14] net: ena: remove code duplication in + ena_com_update_nonadaptive_moderation_interval _*() +Origin: https://git.kernel.org/linus/57e3a5f24bb5bf265988e973a911845abcbf6a00 +Bug-Debian: https://bugs.debian.org/941291 + +Remove code duplication in: +ena_com_update_nonadaptive_moderation_interval_tx() +ena_com_update_nonadaptive_moderation_interval_rx() +functions. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_com.c | 30 ++++++++++++----------- + 1 file changed, 16 insertions(+), 14 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.c +@@ -2772,32 +2772,34 @@ bool ena_com_interrupt_moderation_suppor + ENA_ADMIN_INTERRUPT_MODERATION); + } + +-int ena_com_update_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev, +- u32 tx_coalesce_usecs) ++static int ena_com_update_nonadaptive_moderation_interval(u32 coalesce_usecs, ++ u32 intr_delay_resolution, ++ u32 *intr_moder_interval) + { +- if (!ena_dev->intr_delay_resolution) { ++ if (!intr_delay_resolution) { + pr_err("Illegal interrupt delay granularity value\n"); + return -EFAULT; + } + +- ena_dev->intr_moder_tx_interval = tx_coalesce_usecs / +- ena_dev->intr_delay_resolution; ++ *intr_moder_interval = coalesce_usecs / intr_delay_resolution; + + return 0; + } + ++int ena_com_update_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev, ++ u32 tx_coalesce_usecs) ++{ ++ return ena_com_update_nonadaptive_moderation_interval(tx_coalesce_usecs, ++ ena_dev->intr_delay_resolution, ++ &ena_dev->intr_moder_tx_interval); ++} ++ + int ena_com_update_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev, + u32 rx_coalesce_usecs) + { +- if (!ena_dev->intr_delay_resolution) { +- pr_err("Illegal interrupt delay granularity value\n"); +- return -EFAULT; +- } +- +- ena_dev->intr_moder_rx_interval = rx_coalesce_usecs / +- ena_dev->intr_delay_resolution; +- +- return 0; ++ return ena_com_update_nonadaptive_moderation_interval(rx_coalesce_usecs, ++ ena_dev->intr_delay_resolution, ++ &ena_dev->intr_moder_rx_interval); + } + + void ena_com_destroy_interrupt_moderation(struct ena_com_dev *ena_dev) diff --git a/debian/patches/features/all/ena/0007-net-ena-remove-old-adaptive-interrupt-moderation-cod.patch b/debian/patches/features/all/ena/0007-net-ena-remove-old-adaptive-interrupt-moderation-cod.patch new file mode 100644 index 000000000000..d9c22ad4ace9 --- /dev/null +++ b/debian/patches/features/all/ena/0007-net-ena-remove-old-adaptive-interrupt-moderation-cod.patch @@ -0,0 +1,83 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:31 +0300 +Subject: [PATCH 07/14] net: ena: remove old adaptive interrupt moderation code + from ena_netdev +Origin: https://git.kernel.org/linus/242d81fd3dd9f301b0c20564aafec8efdb2bbe5b +Bug-Debian: https://bugs.debian.org/941291 + +1. Out of the fields {per_napi_bytes, per_napi_packets} in struct ena_ring, + only rx_ring->per_napi_packets are used to determine if napi did work + for dim. + This commit removes all other uses of these fields. +2. Remove ena_ring->moder_tbl_idx, which is not used by dim. +3. Remove all calls to ena_com_destroy_interrupt_moderation(), since all it + did was to destroy the interrupt moderation table, which is removed as + part of removing old interrupt moderation code. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_netdev.c | 8 -------- + drivers/net/ethernet/amazon/ena/ena_netdev.h | 2 -- + 2 files changed, 10 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -158,7 +158,6 @@ static void ena_init_io_rings_common(str + ring->adapter = adapter; + ring->ena_dev = adapter->ena_dev; + ring->per_napi_packets = 0; +- ring->per_napi_bytes = 0; + ring->cpu = 0; + ring->first_interrupt = false; + ring->no_interrupt_event_cnt = 0; +@@ -835,9 +834,6 @@ static int ena_clean_tx_irq(struct ena_r + __netif_tx_unlock(txq); + } + +- tx_ring->per_napi_bytes += tx_bytes; +- tx_ring->per_napi_packets += tx_pkts; +- + return tx_pkts; + } + +@@ -1121,7 +1117,6 @@ static int ena_clean_rx_irq(struct ena_r + } while (likely(res_budget)); + + work_done = budget - res_budget; +- rx_ring->per_napi_bytes += total_len; + rx_ring->per_napi_packets += work_done; + u64_stats_update_begin(&rx_ring->syncp); + rx_ring->rx_stats.bytes += total_len; +@@ -3642,7 +3637,6 @@ err_free_msix: + ena_free_mgmnt_irq(adapter); + ena_disable_msix(adapter); + err_worker_destroy: +- ena_com_destroy_interrupt_moderation(ena_dev); + del_timer(&adapter->timer_service); + err_netdev_destroy: + free_netdev(netdev); +@@ -3703,8 +3697,6 @@ static void ena_remove(struct pci_dev *p + + pci_disable_device(pdev); + +- ena_com_destroy_interrupt_moderation(ena_dev); +- + vfree(ena_dev); + } + +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.h +@@ -280,8 +280,6 @@ struct ena_ring { + struct ena_com_rx_buf_info ena_bufs[ENA_PKT_MAX_BUFS]; + u32 smoothed_interval; + u32 per_napi_packets; +- u32 per_napi_bytes; +- enum ena_intr_moder_level moder_tbl_idx; + u16 non_empty_napi_events; + struct u64_stats_sync syncp; + union { diff --git a/debian/patches/features/all/ena/0008-net-ena-remove-ena_restore_ethtool_params-and-releva.patch b/debian/patches/features/all/ena/0008-net-ena-remove-ena_restore_ethtool_params-and-releva.patch new file mode 100644 index 000000000000..2eccf936b4b7 --- /dev/null +++ b/debian/patches/features/all/ena/0008-net-ena-remove-ena_restore_ethtool_params-and-releva.patch @@ -0,0 +1,59 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:32 +0300 +Subject: [PATCH 08/14] net: ena: remove ena_restore_ethtool_params() and + relevant fields +Origin: https://git.kernel.org/linus/64d1fb9dfc6c5d8589312fa847fee14ec14ee12b +Bug-Debian: https://bugs.debian.org/941291 + +Deleted unused 4 fields from struct ena_adapter and their only user +ena_restore_ethtool_params(). + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_netdev.c | 10 ---------- + drivers/net/ethernet/amazon/ena/ena_netdev.h | 3 --- + 2 files changed, 13 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -1564,14 +1564,6 @@ static void ena_napi_enable_all(struct e + napi_enable(&adapter->ena_napi[i].napi); + } + +-static void ena_restore_ethtool_params(struct ena_adapter *adapter) +-{ +- adapter->tx_usecs = 0; +- adapter->rx_usecs = 0; +- adapter->tx_frames = 1; +- adapter->rx_frames = 1; +-} +- + /* Configure the Rx forwarding */ + static int ena_rss_configure(struct ena_adapter *adapter) + { +@@ -1621,8 +1613,6 @@ static int ena_up_complete(struct ena_ad + /* enable transmits */ + netif_tx_start_all_queues(adapter->netdev); + +- ena_restore_ethtool_params(adapter); +- + ena_napi_enable_all(adapter); + + return 0; +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.h +@@ -330,9 +330,6 @@ struct ena_adapter { + + u32 missing_tx_completion_threshold; + +- u32 tx_usecs, rx_usecs; /* interrupt moderation */ +- u32 tx_frames, rx_frames; /* interrupt moderation */ +- + u32 requested_tx_ring_size; + u32 requested_rx_ring_size; + diff --git a/debian/patches/features/all/ena/0009-net-ena-remove-all-old-adaptive-rx-interrupt-moderat.patch b/debian/patches/features/all/ena/0009-net-ena-remove-all-old-adaptive-rx-interrupt-moderat.patch new file mode 100644 index 000000000000..8068f8ff22bb --- /dev/null +++ b/debian/patches/features/all/ena/0009-net-ena-remove-all-old-adaptive-rx-interrupt-moderat.patch @@ -0,0 +1,361 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:33 +0300 +Subject: [PATCH 09/14] net: ena: remove all old adaptive rx interrupt + moderation code from ena_com +Origin: https://git.kernel.org/linus/3ced8cbdf7ddb3160ffa714a91040dd18f39a12c +Bug-Debian: https://bugs.debian.org/941291 + +Remove previous implementation of adaptive rx interrupt moderation +from ena_com files. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_com.c | 110 ----------------- + drivers/net/ethernet/amazon/ena/ena_com.h | 142 ---------------------- + 2 files changed, 252 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.c +@@ -1278,22 +1278,6 @@ static int ena_com_ind_tbl_convert_from_ + return 0; + } + +-static int ena_com_init_interrupt_moderation_table(struct ena_com_dev *ena_dev) +-{ +- size_t size; +- +- size = sizeof(struct ena_intr_moder_entry) * ENA_INTR_MAX_NUM_OF_LEVELS; +- +- ena_dev->intr_moder_tbl = +- devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL); +- if (!ena_dev->intr_moder_tbl) +- return -ENOMEM; +- +- ena_com_config_default_interrupt_moderation_table(ena_dev); +- +- return 0; +-} +- + static void ena_com_update_intr_delay_resolution(struct ena_com_dev *ena_dev, + u16 intr_delay_resolution) + { +@@ -2802,13 +2786,6 @@ int ena_com_update_nonadaptive_moderatio + &ena_dev->intr_moder_rx_interval); + } + +-void ena_com_destroy_interrupt_moderation(struct ena_com_dev *ena_dev) +-{ +- if (ena_dev->intr_moder_tbl) +- devm_kfree(ena_dev->dmadev, ena_dev->intr_moder_tbl); +- ena_dev->intr_moder_tbl = NULL; +-} +- + int ena_com_init_interrupt_moderation(struct ena_com_dev *ena_dev) + { + struct ena_admin_get_feat_resp get_resp; +@@ -2833,10 +2810,6 @@ int ena_com_init_interrupt_moderation(st + return rc; + } + +- rc = ena_com_init_interrupt_moderation_table(ena_dev); +- if (rc) +- goto err; +- + /* if moderation is supported by device we set adaptive moderation */ + delay_resolution = get_resp.u.intr_moderation.intr_delay_resolution; + ena_com_update_intr_delay_resolution(ena_dev, delay_resolution); +@@ -2845,52 +2818,6 @@ int ena_com_init_interrupt_moderation(st + ena_com_disable_adaptive_moderation(ena_dev); + + return 0; +-err: +- ena_com_destroy_interrupt_moderation(ena_dev); +- return rc; +-} +- +-void ena_com_config_default_interrupt_moderation_table(struct ena_com_dev *ena_dev) +-{ +- struct ena_intr_moder_entry *intr_moder_tbl = ena_dev->intr_moder_tbl; +- +- if (!intr_moder_tbl) +- return; +- +- intr_moder_tbl[ENA_INTR_MODER_LOWEST].intr_moder_interval = +- ENA_INTR_LOWEST_USECS; +- intr_moder_tbl[ENA_INTR_MODER_LOWEST].pkts_per_interval = +- ENA_INTR_LOWEST_PKTS; +- intr_moder_tbl[ENA_INTR_MODER_LOWEST].bytes_per_interval = +- ENA_INTR_LOWEST_BYTES; +- +- intr_moder_tbl[ENA_INTR_MODER_LOW].intr_moder_interval = +- ENA_INTR_LOW_USECS; +- intr_moder_tbl[ENA_INTR_MODER_LOW].pkts_per_interval = +- ENA_INTR_LOW_PKTS; +- intr_moder_tbl[ENA_INTR_MODER_LOW].bytes_per_interval = +- ENA_INTR_LOW_BYTES; +- +- intr_moder_tbl[ENA_INTR_MODER_MID].intr_moder_interval = +- ENA_INTR_MID_USECS; +- intr_moder_tbl[ENA_INTR_MODER_MID].pkts_per_interval = +- ENA_INTR_MID_PKTS; +- intr_moder_tbl[ENA_INTR_MODER_MID].bytes_per_interval = +- ENA_INTR_MID_BYTES; +- +- intr_moder_tbl[ENA_INTR_MODER_HIGH].intr_moder_interval = +- ENA_INTR_HIGH_USECS; +- intr_moder_tbl[ENA_INTR_MODER_HIGH].pkts_per_interval = +- ENA_INTR_HIGH_PKTS; +- intr_moder_tbl[ENA_INTR_MODER_HIGH].bytes_per_interval = +- ENA_INTR_HIGH_BYTES; +- +- intr_moder_tbl[ENA_INTR_MODER_HIGHEST].intr_moder_interval = +- ENA_INTR_HIGHEST_USECS; +- intr_moder_tbl[ENA_INTR_MODER_HIGHEST].pkts_per_interval = +- ENA_INTR_HIGHEST_PKTS; +- intr_moder_tbl[ENA_INTR_MODER_HIGHEST].bytes_per_interval = +- ENA_INTR_HIGHEST_BYTES; + } + + unsigned int ena_com_get_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev) +@@ -2903,43 +2830,6 @@ unsigned int ena_com_get_nonadaptive_mod + return ena_dev->intr_moder_rx_interval; + } + +-void ena_com_init_intr_moderation_entry(struct ena_com_dev *ena_dev, +- enum ena_intr_moder_level level, +- struct ena_intr_moder_entry *entry) +-{ +- struct ena_intr_moder_entry *intr_moder_tbl = ena_dev->intr_moder_tbl; +- +- if (level >= ENA_INTR_MAX_NUM_OF_LEVELS) +- return; +- +- intr_moder_tbl[level].intr_moder_interval = entry->intr_moder_interval; +- if (ena_dev->intr_delay_resolution) +- intr_moder_tbl[level].intr_moder_interval /= +- ena_dev->intr_delay_resolution; +- intr_moder_tbl[level].pkts_per_interval = entry->pkts_per_interval; +- +- /* use hardcoded value until ethtool supports bytecount parameter */ +- if (entry->bytes_per_interval != ENA_INTR_BYTE_COUNT_NOT_SUPPORTED) +- intr_moder_tbl[level].bytes_per_interval = entry->bytes_per_interval; +-} +- +-void ena_com_get_intr_moderation_entry(struct ena_com_dev *ena_dev, +- enum ena_intr_moder_level level, +- struct ena_intr_moder_entry *entry) +-{ +- struct ena_intr_moder_entry *intr_moder_tbl = ena_dev->intr_moder_tbl; +- +- if (level >= ENA_INTR_MAX_NUM_OF_LEVELS) +- return; +- +- entry->intr_moder_interval = intr_moder_tbl[level].intr_moder_interval; +- if (ena_dev->intr_delay_resolution) +- entry->intr_moder_interval *= ena_dev->intr_delay_resolution; +- entry->pkts_per_interval = +- intr_moder_tbl[level].pkts_per_interval; +- entry->bytes_per_interval = intr_moder_tbl[level].bytes_per_interval; +-} +- + int ena_com_config_dev_mode(struct ena_com_dev *ena_dev, + struct ena_admin_feature_llq_desc *llq_features, + struct ena_llq_configurations *llq_default_cfg) +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.h +@@ -72,46 +72,13 @@ + /*****************************************************************************/ + /* ENA adaptive interrupt moderation settings */ + +-#define ENA_INTR_LOWEST_USECS (0) +-#define ENA_INTR_LOWEST_PKTS (3) +-#define ENA_INTR_LOWEST_BYTES (2 * 1524) +- +-#define ENA_INTR_LOW_USECS (32) +-#define ENA_INTR_LOW_PKTS (12) +-#define ENA_INTR_LOW_BYTES (16 * 1024) +- +-#define ENA_INTR_MID_USECS (80) +-#define ENA_INTR_MID_PKTS (48) +-#define ENA_INTR_MID_BYTES (64 * 1024) +- +-#define ENA_INTR_HIGH_USECS (128) +-#define ENA_INTR_HIGH_PKTS (96) +-#define ENA_INTR_HIGH_BYTES (128 * 1024) +- +-#define ENA_INTR_HIGHEST_USECS (192) +-#define ENA_INTR_HIGHEST_PKTS (128) +-#define ENA_INTR_HIGHEST_BYTES (192 * 1024) +- + #define ENA_INTR_INITIAL_TX_INTERVAL_USECS 196 + #define ENA_INTR_INITIAL_RX_INTERVAL_USECS 0 +-#define ENA_INTR_DELAY_OLD_VALUE_WEIGHT 6 +-#define ENA_INTR_DELAY_NEW_VALUE_WEIGHT 4 +-#define ENA_INTR_MODER_LEVEL_STRIDE 2 +-#define ENA_INTR_BYTE_COUNT_NOT_SUPPORTED 0xFFFFFF + + #define ENA_HW_HINTS_NO_TIMEOUT 0xFFFF + + #define ENA_FEATURE_MAX_QUEUE_EXT_VER 1 + +-enum ena_intr_moder_level { +- ENA_INTR_MODER_LOWEST = 0, +- ENA_INTR_MODER_LOW, +- ENA_INTR_MODER_MID, +- ENA_INTR_MODER_HIGH, +- ENA_INTR_MODER_HIGHEST, +- ENA_INTR_MAX_NUM_OF_LEVELS, +-}; +- + struct ena_llq_configurations { + enum ena_admin_llq_header_location llq_header_location; + enum ena_admin_llq_ring_entry_size llq_ring_entry_size; +@@ -120,12 +87,6 @@ struct ena_llq_configurations { + u16 llq_ring_entry_size_value; + }; + +-struct ena_intr_moder_entry { +- unsigned int intr_moder_interval; +- unsigned int pkts_per_interval; +- unsigned int bytes_per_interval; +-}; +- + enum queue_direction { + ENA_COM_IO_QUEUE_DIRECTION_TX, + ENA_COM_IO_QUEUE_DIRECTION_RX +@@ -920,11 +881,6 @@ int ena_com_execute_admin_command(struct + */ + int ena_com_init_interrupt_moderation(struct ena_com_dev *ena_dev); + +-/* ena_com_destroy_interrupt_moderation - Destroy interrupt moderation resources +- * @ena_dev: ENA communication layer struct +- */ +-void ena_com_destroy_interrupt_moderation(struct ena_com_dev *ena_dev); +- + /* ena_com_interrupt_moderation_supported - Return if interrupt moderation + * capability is supported by the device. + * +@@ -932,12 +888,6 @@ void ena_com_destroy_interrupt_moderatio + */ + bool ena_com_interrupt_moderation_supported(struct ena_com_dev *ena_dev); + +-/* ena_com_config_default_interrupt_moderation_table - Restore the interrupt +- * moderation table back to the default parameters. +- * @ena_dev: ENA communication layer struct +- */ +-void ena_com_config_default_interrupt_moderation_table(struct ena_com_dev *ena_dev); +- + /* ena_com_update_nonadaptive_moderation_interval_tx - Update the + * non-adaptive interval in Tx direction. + * @ena_dev: ENA communication layer struct +@@ -974,29 +924,6 @@ unsigned int ena_com_get_nonadaptive_mod + */ + unsigned int ena_com_get_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev); + +-/* ena_com_init_intr_moderation_entry - Update a single entry in the interrupt +- * moderation table. +- * @ena_dev: ENA communication layer struct +- * @level: Interrupt moderation table level +- * @entry: Entry value +- * +- * Update a single entry in the interrupt moderation table. +- */ +-void ena_com_init_intr_moderation_entry(struct ena_com_dev *ena_dev, +- enum ena_intr_moder_level level, +- struct ena_intr_moder_entry *entry); +- +-/* ena_com_get_intr_moderation_entry - Init ena_intr_moder_entry. +- * @ena_dev: ENA communication layer struct +- * @level: Interrupt moderation table level +- * @entry: Entry to fill. +- * +- * Initialize the entry according to the adaptive interrupt moderation table. +- */ +-void ena_com_get_intr_moderation_entry(struct ena_com_dev *ena_dev, +- enum ena_intr_moder_level level, +- struct ena_intr_moder_entry *entry); +- + /* ena_com_config_dev_mode - Configure the placement policy of the device. + * @ena_dev: ENA communication layer struct + * @llq_features: LLQ feature descriptor, retrieve via +@@ -1022,75 +949,6 @@ static inline void ena_com_disable_adapt + ena_dev->adaptive_coalescing = false; + } + +-/* ena_com_calculate_interrupt_delay - Calculate new interrupt delay +- * @ena_dev: ENA communication layer struct +- * @pkts: Number of packets since the last update +- * @bytes: Number of bytes received since the last update. +- * @smoothed_interval: Returned interval +- * @moder_tbl_idx: Current table level as input update new level as return +- * value. +- */ +-static inline void ena_com_calculate_interrupt_delay(struct ena_com_dev *ena_dev, +- unsigned int pkts, +- unsigned int bytes, +- unsigned int *smoothed_interval, +- unsigned int *moder_tbl_idx) +-{ +- enum ena_intr_moder_level curr_moder_idx, new_moder_idx; +- struct ena_intr_moder_entry *curr_moder_entry; +- struct ena_intr_moder_entry *pred_moder_entry; +- struct ena_intr_moder_entry *new_moder_entry; +- struct ena_intr_moder_entry *intr_moder_tbl = ena_dev->intr_moder_tbl; +- unsigned int interval; +- +- /* We apply adaptive moderation on Rx path only. +- * Tx uses static interrupt moderation. +- */ +- if (!pkts || !bytes) +- /* Tx interrupt, or spurious interrupt, +- * in both cases we just use same delay values +- */ +- return; +- +- curr_moder_idx = (enum ena_intr_moder_level)(*moder_tbl_idx); +- if (unlikely(curr_moder_idx >= ENA_INTR_MAX_NUM_OF_LEVELS)) { +- pr_err("Wrong moderation index %u\n", curr_moder_idx); +- return; +- } +- +- curr_moder_entry = &intr_moder_tbl[curr_moder_idx]; +- new_moder_idx = curr_moder_idx; +- +- if (curr_moder_idx == ENA_INTR_MODER_LOWEST) { +- if ((pkts > curr_moder_entry->pkts_per_interval) || +- (bytes > curr_moder_entry->bytes_per_interval)) +- new_moder_idx = +- (enum ena_intr_moder_level)(curr_moder_idx + ENA_INTR_MODER_LEVEL_STRIDE); +- } else { +- pred_moder_entry = &intr_moder_tbl[curr_moder_idx - ENA_INTR_MODER_LEVEL_STRIDE]; +- +- if ((pkts <= pred_moder_entry->pkts_per_interval) || +- (bytes <= pred_moder_entry->bytes_per_interval)) +- new_moder_idx = +- (enum ena_intr_moder_level)(curr_moder_idx - ENA_INTR_MODER_LEVEL_STRIDE); +- else if ((pkts > curr_moder_entry->pkts_per_interval) || +- (bytes > curr_moder_entry->bytes_per_interval)) { +- if (curr_moder_idx != ENA_INTR_MODER_HIGHEST) +- new_moder_idx = +- (enum ena_intr_moder_level)(curr_moder_idx + ENA_INTR_MODER_LEVEL_STRIDE); +- } +- } +- new_moder_entry = &intr_moder_tbl[new_moder_idx]; +- +- interval = new_moder_entry->intr_moder_interval; +- *smoothed_interval = ( +- (interval * ENA_INTR_DELAY_NEW_VALUE_WEIGHT + +- ENA_INTR_DELAY_OLD_VALUE_WEIGHT * (*smoothed_interval)) + 5) / +- 10; +- +- *moder_tbl_idx = new_moder_idx; +-} +- + /* ena_com_update_intr_reg - Prepare interrupt register + * @intr_reg: interrupt register to update. + * @rx_delay_interval: Rx interval in usecs diff --git a/debian/patches/features/all/ena/0010-net-ena-fix-update-of-interrupt-moderation-register.patch b/debian/patches/features/all/ena/0010-net-ena-fix-update-of-interrupt-moderation-register.patch new file mode 100644 index 000000000000..dee2b1f1f961 --- /dev/null +++ b/debian/patches/features/all/ena/0010-net-ena-fix-update-of-interrupt-moderation-register.patch @@ -0,0 +1,39 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:34 +0300 +Subject: [PATCH 10/14] net: ena: fix update of interrupt moderation register +Origin: https://git.kernel.org/linus/7b8a28787e2ba671eaeb073e3b62fb4786338a09 +Bug-Debian: https://bugs.debian.org/941291 + +Current implementation always updates the interrupt register with +the smoothed_interval of the rx_ring. However this should be +done only in case of adaptive interrupt moderation. If non-adaptive +interrupt moderation is used, the non-adaptive interrupt moderation +interval should be used. This commit fixes that. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_netdev.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -1188,12 +1188,15 @@ static void ena_unmask_interrupt(struct + struct ena_ring *rx_ring) + { + struct ena_eth_io_intr_reg intr_reg; ++ u32 rx_interval = ena_com_get_adaptive_moderation_enabled(rx_ring->ena_dev) ? ++ rx_ring->smoothed_interval : ++ ena_com_get_nonadaptive_moderation_interval_rx(rx_ring->ena_dev); + + /* Update intr register: rx intr delay, + * tx intr delay and interrupt unmask + */ + ena_com_update_intr_reg(&intr_reg, +- rx_ring->smoothed_interval, ++ rx_interval, + tx_ring->smoothed_interval, + true); + diff --git a/debian/patches/features/all/ena/0011-net-ena-fix-retrieval-of-nonadaptive-interrupt-moder.patch b/debian/patches/features/all/ena/0011-net-ena-fix-retrieval-of-nonadaptive-interrupt-moder.patch new file mode 100644 index 000000000000..aca9b61c3108 --- /dev/null +++ b/debian/patches/features/all/ena/0011-net-ena-fix-retrieval-of-nonadaptive-interrupt-moder.patch @@ -0,0 +1,45 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:35 +0300 +Subject: [PATCH 11/14] net: ena: fix retrieval of nonadaptive interrupt + moderation intervals +Origin: https://git.kernel.org/linus/0eda847953d8dfb4b713ea62420f66157e230e13 +Bug-Debian: https://bugs.debian.org/941291 + +Nonadaptive interrupt moderation intervals are assigned the value set +by the user in ethtool -C divided by ena_dev->intr_delay_resolution. + +Therefore when the user tries to get the nonadaptive interrupt moderation +intervals with ethtool -c the code needs to multiply the saved value +by ena_dev->intr_delay_resolution. + +The current code erroneously divides instead of multiplying in ethtool -c. +This patch fixes this. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_ethtool.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_ethtool.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_ethtool.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_ethtool.c +@@ -310,14 +310,15 @@ static int ena_get_coalesce(struct net_d + /* the devie doesn't support interrupt moderation */ + return -EOPNOTSUPP; + } ++ + coalesce->tx_coalesce_usecs = +- ena_com_get_nonadaptive_moderation_interval_tx(ena_dev) / ++ ena_com_get_nonadaptive_moderation_interval_tx(ena_dev) * + ena_dev->intr_delay_resolution; + + if (!ena_com_get_adaptive_moderation_enabled(ena_dev)) + coalesce->rx_coalesce_usecs = + ena_com_get_nonadaptive_moderation_interval_rx(ena_dev) +- / ena_dev->intr_delay_resolution; ++ * ena_dev->intr_delay_resolution; + + coalesce->use_adaptive_rx_coalesce = + ena_com_get_adaptive_moderation_enabled(ena_dev); diff --git a/debian/patches/features/all/ena/0012-net-ena-fix-incorrect-update-of-intr_delay_resolutio.patch b/debian/patches/features/all/ena/0012-net-ena-fix-incorrect-update-of-intr_delay_resolutio.patch new file mode 100644 index 000000000000..f3831b300a0e --- /dev/null +++ b/debian/patches/features/all/ena/0012-net-ena-fix-incorrect-update-of-intr_delay_resolutio.patch @@ -0,0 +1,89 @@ +From: Arthur Kiyanovski +Date: Mon, 16 Sep 2019 14:31:36 +0300 +Subject: [PATCH 12/14] net: ena: fix incorrect update of intr_delay_resolution +Origin: https://git.kernel.org/linus/79226cea4a5ebbd84a4eee1762526f664c7beb62 +Bug-Debian: https://bugs.debian.org/941291 + +ena_dev->intr_moder_rx/tx_interval save the intervals received from the +user after dividing them by ena_dev->intr_delay_resolution. Therefore +when intr_delay_resolution changes, the code needs to first mutiply +intr_moder_rx/tx_interval by the previous intr_delay_resolution to get +the value originally given by the user, and only then divide it by the +new intr_delay_resolution. + +Current code does not first multiply intr_moder_rx/tx_interval by the old +intr_delay_resolution. This commit fixes it. + +Also initialize ena_dev->intr_delay_resolution to be 1. + +Signed-off-by: Arthur Kiyanovski +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_com.c | 21 ++++++++++++++++---- + drivers/net/ethernet/amazon/ena/ena_com.h | 1 + + drivers/net/ethernet/amazon/ena/ena_netdev.c | 1 + + 3 files changed, 19 insertions(+), 4 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.c +@@ -1281,17 +1281,30 @@ static int ena_com_ind_tbl_convert_from_ + static void ena_com_update_intr_delay_resolution(struct ena_com_dev *ena_dev, + u16 intr_delay_resolution) + { ++ /* Initial value of intr_delay_resolution might be 0 */ ++ u16 prev_intr_delay_resolution = ++ ena_dev->intr_delay_resolution ? ++ ena_dev->intr_delay_resolution : ++ ENA_DEFAULT_INTR_DELAY_RESOLUTION; ++ + if (!intr_delay_resolution) { + pr_err("Illegal intr_delay_resolution provided. Going to use default 1 usec resolution\n"); +- intr_delay_resolution = 1; ++ intr_delay_resolution = ENA_DEFAULT_INTR_DELAY_RESOLUTION; + } +- ena_dev->intr_delay_resolution = intr_delay_resolution; + + /* update Rx */ +- ena_dev->intr_moder_rx_interval /= intr_delay_resolution; ++ ena_dev->intr_moder_rx_interval = ++ ena_dev->intr_moder_rx_interval * ++ prev_intr_delay_resolution / ++ intr_delay_resolution; + + /* update Tx */ +- ena_dev->intr_moder_tx_interval /= intr_delay_resolution; ++ ena_dev->intr_moder_tx_interval = ++ ena_dev->intr_moder_tx_interval * ++ prev_intr_delay_resolution / ++ intr_delay_resolution; ++ ++ ena_dev->intr_delay_resolution = intr_delay_resolution; + } + + /*****************************************************************************/ +Index: linux/drivers/net/ethernet/amazon/ena/ena_com.h +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_com.h ++++ linux/drivers/net/ethernet/amazon/ena/ena_com.h +@@ -74,6 +74,7 @@ + + #define ENA_INTR_INITIAL_TX_INTERVAL_USECS 196 + #define ENA_INTR_INITIAL_RX_INTERVAL_USECS 0 ++#define ENA_DEFAULT_INTR_DELAY_RESOLUTION 1 + + #define ENA_HW_HINTS_NO_TIMEOUT 0xFFFF + +Index: linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -3501,6 +3501,7 @@ static int ena_probe(struct pci_dev *pde + */ + ena_dev->intr_moder_tx_interval = ENA_INTR_INITIAL_TX_INTERVAL_USECS; + ena_dev->intr_moder_rx_interval = ENA_INTR_INITIAL_RX_INTERVAL_USECS; ++ ena_dev->intr_delay_resolution = ENA_DEFAULT_INTR_DELAY_RESOLUTION; + io_queue_num = ena_calc_io_queue_num(pdev, ena_dev, &get_feat_ctx); + rc = ena_calc_queue_size(&calc_queue_ctx); + if (rc || io_queue_num <= 0) { diff --git a/debian/patches/features/all/ena/0013-net-ena-Select-DIMLIB-for-ENA_ETHERNET.patch b/debian/patches/features/all/ena/0013-net-ena-Select-DIMLIB-for-ENA_ETHERNET.patch new file mode 100644 index 000000000000..a8cd97b4eed9 --- /dev/null +++ b/debian/patches/features/all/ena/0013-net-ena-Select-DIMLIB-for-ENA_ETHERNET.patch @@ -0,0 +1,40 @@ +From: Mao Wenan +Date: Sun, 22 Sep 2019 13:38:08 +0800 +Subject: [PATCH 13/14] net: ena: Select DIMLIB for ENA_ETHERNET +Origin: https://git.kernel.org/linus/ff04cfbaa23644562f369eeca0b44ef66e185c9e +Bug-Debian: https://bugs.debian.org/941291 + +If CONFIG_ENA_ETHERNET=y and CONFIG_DIMLIB=n, +below erros can be found: +drivers/net/ethernet/amazon/ena/ena_netdev.o: In function `ena_dim_work': +ena_netdev.c:(.text+0x21cc): undefined reference to `net_dim_get_rx_moderation' +ena_netdev.c:(.text+0x21cc): relocation truncated to +fit: R_AARCH64_CALL26 against undefined symbol `net_dim_get_rx_moderation' +drivers/net/ethernet/amazon/ena/ena_netdev.o: In function `ena_io_poll': +ena_netdev.c:(.text+0x7bd4): undefined reference to `net_dim' +ena_netdev.c:(.text+0x7bd4): relocation truncated to fit: +R_AARCH64_CALL26 against undefined symbol `net_dim' + +After commit 282faf61a053 ("net: ena: switch to dim algorithm for rx adaptive +interrupt moderation"), it introduces dim algorithm, which configured by CONFIG_DIMLIB. +So, this patch is to select DIMLIB for ENA_ETHERNET. + +Fixes: 282faf61a053 ("net: ena: switch to dim algorithm for rx adaptive interrupt moderation") +Signed-off-by: Mao Wenan +Signed-off-by: Jakub Kicinski +--- + drivers/net/ethernet/amazon/Kconfig | 1 + + 1 file changed, 1 insertion(+) + +Index: linux/drivers/net/ethernet/amazon/Kconfig +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/Kconfig ++++ linux/drivers/net/ethernet/amazon/Kconfig +@@ -19,6 +19,7 @@ if NET_VENDOR_AMAZON + config ENA_ETHERNET + tristate "Elastic Network Adapter (ENA) support" + depends on PCI_MSI && !CPU_BIG_ENDIAN ++ select DIMLIB + ---help--- + This driver supports Elastic Network Adapter (ENA)" + diff --git a/debian/patches/features/all/ena/0014-net-ena-clean-up-indentation-issue.patch b/debian/patches/features/all/ena/0014-net-ena-clean-up-indentation-issue.patch new file mode 100644 index 000000000000..33f8885ac6ad --- /dev/null +++ b/debian/patches/features/all/ena/0014-net-ena-clean-up-indentation-issue.patch @@ -0,0 +1,29 @@ +From: Colin Ian King +Date: Thu, 26 Sep 2019 12:22:52 +0100 +Subject: [PATCH 14/14] net: ena: clean up indentation issue +Origin: https://git.kernel.org/linus/4208966f65f520d7f392dbaa62e39a8fa88ffb95 +Bug-Debian: https://bugs.debian.org/941291 + +There memset is indented incorrectly, remove the extraneous tabs. + +Signed-off-by: Colin Ian King +Signed-off-by: David S. Miller +--- + drivers/net/ethernet/amazon/ena/ena_eth_com.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Index: linux/drivers/net/ethernet/amazon/ena/ena_eth_com.c +=================================================================== +--- linux.orig/drivers/net/ethernet/amazon/ena/ena_eth_com.c ++++ linux/drivers/net/ethernet/amazon/ena/ena_eth_com.c +@@ -211,8 +211,8 @@ static int ena_com_sq_update_llq_tail(st + + pkt_ctrl->curr_bounce_buf = + ena_com_get_next_bounce_buffer(&io_sq->bounce_buf_ctrl); +- memset(io_sq->llq_buf_ctrl.curr_bounce_buf, +- 0x0, llq_info->desc_list_entry_size); ++ memset(io_sq->llq_buf_ctrl.curr_bounce_buf, ++ 0x0, llq_info->desc_list_entry_size); + + pkt_ctrl->idx = 0; + if (unlikely(llq_info->desc_stride_ctrl == ENA_ADMIN_SINGLE_DESC_PER_ENTRY)) diff --git a/debian/patches/series b/debian/patches/series index 23da7bf4cb12..65b32b1faa56 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -168,3 +168,17 @@ debian/wireless-disable-regulatory.db-direct-loading.patch debian/overlayfs-permit-mounts-in-userns.patch # ABI maintenance +features/all/ena/0001-net-ena-don-t-wake-up-tx-queue-when-down.patch +features/all/ena/0002-net-ena-add-intr_moder_rx_interval-to-struct-ena_com.patch +features/all/ena/0003-net-ena-switch-to-dim-algorithm-for-rx-adaptive-inte.patch +features/all/ena/0004-net-ena-reimplement-set-get_coalesce.patch +features/all/ena/0005-net-ena-enable-the-interrupt_moderation-in-driver_su.patch +features/all/ena/0006-net-ena-remove-code-duplication-in-ena_com_update_no.patch +features/all/ena/0007-net-ena-remove-old-adaptive-interrupt-moderation-cod.patch +features/all/ena/0008-net-ena-remove-ena_restore_ethtool_params-and-releva.patch +features/all/ena/0009-net-ena-remove-all-old-adaptive-rx-interrupt-moderat.patch +features/all/ena/0010-net-ena-fix-update-of-interrupt-moderation-register.patch +features/all/ena/0011-net-ena-fix-retrieval-of-nonadaptive-interrupt-moder.patch +features/all/ena/0012-net-ena-fix-incorrect-update-of-intr_delay_resolutio.patch +features/all/ena/0013-net-ena-Select-DIMLIB-for-ENA_ETHERNET.patch +features/all/ena/0014-net-ena-clean-up-indentation-issue.patch