#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
-#include <linux/net_dim.h>
 #include <linux/etherdevice.h>
 #include <linux/platform_device.h>
 #include <linux/of.h>
        rdma_writel(priv, reg, RDMA_MBDONE_INTR);
 }
 
-static void bcm_sysport_set_tx_coalesce(struct bcm_sysport_tx_ring *ring)
+static void bcm_sysport_set_tx_coalesce(struct bcm_sysport_tx_ring *ring,
+                                       struct ethtool_coalesce *ec)
 {
        struct bcm_sysport_priv *priv = ring->priv;
        u32 reg;
        reg = tdma_readl(priv, TDMA_DESC_RING_INTR_CONTROL(ring->index));
        reg &= ~(RING_INTR_THRESH_MASK |
                 RING_TIMEOUT_MASK << RING_TIMEOUT_SHIFT);
-       reg |= ring->dim.coal_pkts;
-       reg |= DIV_ROUND_UP(ring->dim.coal_usecs * 1000, 8192) <<
+       reg |= ec->tx_max_coalesced_frames;
+       reg |= DIV_ROUND_UP(ec->tx_coalesce_usecs * 1000, 8192) <<
                            RING_TIMEOUT_SHIFT;
        tdma_writel(priv, reg, TDMA_DESC_RING_INTR_CONTROL(ring->index));
 }
                                    struct ethtool_coalesce *ec)
 {
        struct bcm_sysport_priv *priv = netdev_priv(dev);
-       struct bcm_sysport_tx_ring *ring;
-       unsigned int i;
        u32 reg;
 
        reg = tdma_readl(priv, TDMA_DESC_RING_INTR_CONTROL(0));
 
        ec->tx_coalesce_usecs = (reg >> RING_TIMEOUT_SHIFT) * 8192 / 1000;
        ec->tx_max_coalesced_frames = reg & RING_INTR_THRESH_MASK;
-       for (i = 0; i < dev->num_tx_queues; i++) {
-               ring = &priv->tx_rings[i];
-               ec->use_adaptive_tx_coalesce |= ring->dim.use_dim;
-       }
 
        reg = rdma_readl(priv, RDMA_MBDONE_INTR);
 
                                    struct ethtool_coalesce *ec)
 {
        struct bcm_sysport_priv *priv = netdev_priv(dev);
-       struct bcm_sysport_tx_ring *ring;
        unsigned int i;
 
        /* Base system clock is 125Mhz, DMA timeout is this reference clock
                return -EINVAL;
 
        if ((ec->tx_coalesce_usecs == 0 && ec->tx_max_coalesced_frames == 0) ||
-           (ec->rx_coalesce_usecs == 0 && ec->rx_max_coalesced_frames == 0))
+           (ec->rx_coalesce_usecs == 0 && ec->rx_max_coalesced_frames == 0) ||
+           ec->use_adaptive_tx_coalesce)
                return -EINVAL;
 
-       for (i = 0; i < dev->num_tx_queues; i++) {
-               ring = &priv->tx_rings[i];
-               ring->dim.coal_pkts = ec->tx_max_coalesced_frames;
-               ring->dim.coal_usecs = ec->tx_coalesce_usecs;
-               if (!ec->use_adaptive_tx_coalesce && ring->dim.use_dim) {
-                       ring->dim.coal_pkts = 1;
-                       ring->dim.coal_usecs = 0;
-               }
-               ring->dim.use_dim = ec->use_adaptive_tx_coalesce;
-               bcm_sysport_set_tx_coalesce(ring);
-       }
+       for (i = 0; i < dev->num_tx_queues; i++)
+               bcm_sysport_set_tx_coalesce(&priv->tx_rings[i], ec);
 
        priv->dim.coal_usecs = ec->rx_coalesce_usecs;
        priv->dim.coal_pkts = ec->rx_max_coalesced_frames;
        ring->packets += pkts_compl;
        ring->bytes += bytes_compl;
        u64_stats_update_end(&priv->syncp);
-       ring->dim.packets = pkts_compl;
-       ring->dim.bytes = bytes_compl;
 
        ring->c_index = c_index;
 
 {
        struct bcm_sysport_tx_ring *ring =
                container_of(napi, struct bcm_sysport_tx_ring, napi);
-       struct net_dim_sample dim_sample;
        unsigned int work_done = 0;
 
        work_done = bcm_sysport_tx_reclaim(ring->priv, ring);
                return 0;
        }
 
-       if (ring->dim.use_dim) {
-               net_dim_sample(ring->dim.event_ctr, ring->dim.packets,
-                              ring->dim.bytes, &dim_sample);
-               net_dim(&ring->dim.dim, dim_sample);
-       }
-
        return budget;
 }
 
        dim->state = NET_DIM_START_MEASURE;
 }
 
-static void bcm_sysport_dim_tx_work(struct work_struct *work)
-{
-       struct net_dim *dim = container_of(work, struct net_dim, work);
-       struct bcm_sysport_net_dim *ndim =
-                       container_of(dim, struct bcm_sysport_net_dim, dim);
-       struct bcm_sysport_tx_ring *ring =
-                       container_of(ndim, struct bcm_sysport_tx_ring, dim);
-       struct net_dim_cq_moder cur_profile =
-                               net_dim_get_profile(dim->mode, dim->profile_ix);
-
-       ring->dim.coal_usecs = cur_profile.usec;
-       ring->dim.coal_pkts = cur_profile.pkts;
-
-       bcm_sysport_set_tx_coalesce(ring);
-       dim->state = NET_DIM_START_MEASURE;
-}
-
 /* RX and misc interrupt routine */
 static irqreturn_t bcm_sysport_rx_isr(int irq, void *dev_id)
 {
                        continue;
 
                txr = &priv->tx_rings[ring];
-               txr->dim.event_ctr++;
 
                if (likely(napi_schedule_prep(&txr->napi))) {
                        intrl2_0_mask_set(priv, ring_bit);
                        continue;
 
                txr = &priv->tx_rings[ring];
-               txr->dim.event_ctr++;
 
                if (likely(napi_schedule_prep(&txr->napi))) {
                        intrl2_1_mask_set(priv, BIT(ring));
        reg |= (1 << index);
        tdma_writel(priv, reg, TDMA_TIER1_ARB_0_QUEUE_EN);
 
-       bcm_sysport_init_dim(&ring->dim, bcm_sysport_dim_tx_work);
        napi_enable(&ring->napi);
 
        netif_dbg(priv, hw, priv->netdev,
                return;
 
        napi_disable(&ring->napi);
-       cancel_work_sync(&ring->dim.dim.work);
        netif_napi_del(&ring->napi);
 
        bcm_sysport_tx_clean(priv, ring);