Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes from David Miller:
 "I'm sending this out, in particular, to get the iwlwifi fix
  propagated:

   1) Fix build due to missing include in i40e driver, from Lucas
      Tanure.

   2) Memory leak in openvswitch port allocation, from Chirstoph Jaeger.

   3) Check DMA mapping errors in myri10ge, from Stanislaw Gruszka.

   4) Fix various deadlock scenerios in sunvnet driver, from Sowmini
      Varadhan.

   5) Fix cxgb4i build failures with incompatible Kconfig settings of
      the driver vs ipv6, from Anish Bhatt.

   6) Fix generation of ACK packet timestamps in the presence of TSO
      which will be split up, from Willem de Bruijn.

   7) Don't enable sched scan in iwlwifi driver, it causes firmware
      crashes in some revisions.  From Emmanuel Grumbach.

   8) Revert a macvlan simplification that causes crashes.

   9) Handle RTT calculations properly in the presence of repair'd SKBs,
      from Andrey Vagin.

  10) SIT tunnel lookup uses wrong device index in compares, from
      Shmulik Ladkani.

  11) Handle MTU reductions in TCP properly for ipv4 mapped ipv6
      sockets, from Neal Cardwell.

  12) Add missing annotations in rhashtable code, from Thomas Graf.

  13) Fix false interpretation of two RTOs as being from the same TCP
      loss event in the FRTO code, from Neal Cardwell"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (42 commits)
  netlink: Annotate RCU locking for seq_file walker
  rhashtable: fix annotations for rht_for_each_entry_rcu()
  rhashtable: unexport and make rht_obj() static
  rhashtable: RCU annotations for next pointers
  tcp: fix ssthresh and undo for consecutive short FRTO episodes
  tcp: don't allow syn packets without timestamps to pass tcp_tw_recycle logic
  tcp: fix tcp_release_cb() to dispatch via address family for mtu_reduced()
  sit: Fix ipip6_tunnel_lookup device matching criteria
  net: ethernet: ibm: ehea: Remove duplicate object from Makefile
  net: xgene: Check negative return value of xgene_enet_get_ring_size()
  tcp: don't use timestamp from repaired skb-s to calculate RTT (v2)
  net: xilinx: Remove .owner field for driver
  Revert "macvlan: simplify the structure port"
  iwlwifi: mvm: disable scheduled scan to prevent firmware crash
  xen-netback: remove loop waiting function
  xen-netback: don't stop dealloc kthread too early
  xen-netback: move NAPI add/remove calls
  xen-netback: fix debugfs entry creation
  xen-netback: fix debugfs write length check
  net-timestamp: fix missing tcp fragmentation cases
  ...

13 files changed, 120 insertions, 54 deletions

diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
index af7c40ac1455..e1a8f4e19983 100644
--- a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
@@ -581,7 +581,11 @@ static struct xgene_enet_desc_ring *xgene_enet_create_desc_ring(
         struct xgene_enet_desc_ring *ring;
         struct xgene_enet_pdata *pdata = netdev_priv(ndev);
         struct device *dev = ndev_to_dev(ndev);
-        u32 size;
+        int size;
+
+        size = xgene_enet_get_ring_size(dev, cfgsize);
+        if (size < 0)
+                return NULL;
 
         ring = devm_kzalloc(dev, sizeof(struct xgene_enet_desc_ring),
                             GFP_KERNEL);
@@ -593,7 +597,6 @@ static struct xgene_enet_desc_ring *xgene_enet_create_desc_ring(
         ring->cfgsize = cfgsize;
         ring->id = ring_id;
 
-        size = xgene_enet_get_ring_size(dev, cfgsize);
         ring->desc_addr = dma_zalloc_coherent(dev, size, &ring->dma,
                                               GFP_KERNEL);
         if (!ring->desc_addr) {
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index a3dd5dc64f4c..4296b3d26f02 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -14093,8 +14093,9 @@ static struct rtnl_link_stats64 *tg3_get_stats64(struct net_device *dev,
 
         spin_lock_bh(&tp->lock);
         if (!tp->hw_stats) {
+                *stats = tp->net_stats_prev;
                 spin_unlock_bh(&tp->lock);
-                return &tp->net_stats_prev;
+                return stats;
         }
 
         tg3_get_nstats(tp, stats);
diff --git a/drivers/net/ethernet/ibm/ehea/Makefile b/drivers/net/ethernet/ibm/ehea/Makefile
index 775d9969b5c2..cd473e295242 100644
--- a/drivers/net/ethernet/ibm/ehea/Makefile
+++ b/drivers/net/ethernet/ibm/ehea/Makefile
@@ -1,6 +1,6 @@
 #
 # Makefile for the eHEA ethernet device driver for IBM eServer System p
 #
-ehea-y = ehea_main.o ehea_phyp.o ehea_qmr.o ehea_ethtool.o ehea_phyp.o
+ehea-y = ehea_main.o ehea_phyp.o ehea_qmr.o ehea_ethtool.o
 obj-$(CONFIG_EHEA) += ehea.o
 
diff --git a/drivers/net/ethernet/intel/e1000e/manage.c b/drivers/net/ethernet/intel/e1000e/manage.c
index 58856032298d..06edfca1a35e 100644
--- a/drivers/net/ethernet/intel/e1000e/manage.c
+++ b/drivers/net/ethernet/intel/e1000e/manage.c
@@ -47,7 +47,7 @@ static u8 e1000_calculate_checksum(u8 *buffer, u32 length)
  *  e1000_mng_enable_host_if - Checks host interface is enabled
  *  @hw: pointer to the HW structure
  *
- *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
+ *  Returns 0 upon success, else -E1000_ERR_HOST_INTERFACE_COMMAND
  *
  *  This function checks whether the HOST IF is enabled for command operation
  *  and also checks whether the previous command is completed.  It busy waits
@@ -78,7 +78,7 @@ static s32 e1000_mng_enable_host_if(struct e1000_hw *hw)
         }
 
         if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {
-                e_dbg("Previous command timeout failed .\n");
+                e_dbg("Previous command timeout failed.\n");
                 return -E1000_ERR_HOST_INTERFACE_COMMAND;
         }
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
index 6938fc1ad877..5d01db1d789b 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
@@ -33,6 +33,7 @@
 #include <scsi/fc/fc_fcoe.h>
 #include <scsi/libfc.h>
 #include <scsi/libfcoe.h>
+#include <uapi/linux/dcbnl.h>
 
 #include "i40e.h"
 #include "i40e_fcoe.h"
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 51bc03072ed3..871474f6fe62 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -4415,13 +4415,13 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
 
         switch (vsi->back->hw.phy.link_info.link_speed) {
         case I40E_LINK_SPEED_40GB:
-                strncpy(speed, "40 Gbps", SPEED_SIZE);
+                strlcpy(speed, "40 Gbps", SPEED_SIZE);
                 break;
         case I40E_LINK_SPEED_10GB:
-                strncpy(speed, "10 Gbps", SPEED_SIZE);
+                strlcpy(speed, "10 Gbps", SPEED_SIZE);
                 break;
         case I40E_LINK_SPEED_1GB:
-                strncpy(speed, "1000 Mbps", SPEED_SIZE);
+                strlcpy(speed, "1000 Mbps", SPEED_SIZE);
                 break;
         default:
                 break;
@@ -4429,16 +4429,16 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
 
         switch (vsi->back->hw.fc.current_mode) {
         case I40E_FC_FULL:
-                strncpy(fc, "RX/TX", FC_SIZE);
+                strlcpy(fc, "RX/TX", FC_SIZE);
                 break;
         case I40E_FC_TX_PAUSE:
-                strncpy(fc, "TX", FC_SIZE);
+                strlcpy(fc, "TX", FC_SIZE);
                 break;
         case I40E_FC_RX_PAUSE:
-                strncpy(fc, "RX", FC_SIZE);
+                strlcpy(fc, "RX", FC_SIZE);
                 break;
         default:
-                strncpy(fc, "None", FC_SIZE);
+                strlcpy(fc, "None", FC_SIZE);
                 break;
         }
 
@@ -5839,7 +5839,7 @@ static void i40e_send_version(struct i40e_pf *pf)
         dv.minor_version = DRV_VERSION_MINOR;
         dv.build_version = DRV_VERSION_BUILD;
         dv.subbuild_version = 0;
-        strncpy(dv.driver_string, DRV_VERSION, sizeof(dv.driver_string));
+        strlcpy(dv.driver_string, DRV_VERSION, sizeof(dv.driver_string));
         i40e_aq_send_driver_version(&pf->hw, &dv, NULL);
 }
 
@@ -6293,7 +6293,7 @@ static int i40e_vsi_alloc_arrays(struct i40e_vsi *vsi, bool alloc_qvectors)
 
         if (alloc_qvectors) {
                 /* allocate memory for q_vector pointers */
-                size = sizeof(struct i40e_q_vectors *) * vsi->num_q_vectors;
+                size = sizeof(struct i40e_q_vector *) * vsi->num_q_vectors;
                 vsi->q_vectors = kzalloc(size, GFP_KERNEL);
                 if (!vsi->q_vectors) {
                         ret = -ENOMEM;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_nvm.c b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
index 97bda3dffd49..25c4f9a3011f 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_nvm.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
@@ -251,9 +251,9 @@ i40e_status i40e_read_nvm_buffer(struct i40e_hw *hw, u16 offset,
  *
  * Writes a 16 bit words buffer to the Shadow RAM using the admin command.
  **/
-i40e_status i40e_write_nvm_aq(struct i40e_hw *hw, u8 module_pointer,
-                              u32 offset, u16 words, void *data,
-                              bool last_command)
+static i40e_status i40e_write_nvm_aq(struct i40e_hw *hw, u8 module_pointer,
+                                     u32 offset, u16 words, void *data,
+                                     bool last_command)
 {
         i40e_status ret_code = I40E_ERR_NVM;
 
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index 69c26f04d8ce..679db026f4be 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -873,6 +873,10 @@ static int myri10ge_dma_test(struct myri10ge_priv *mgp, int test_type)
                 return -ENOMEM;
         dmatest_bus = pci_map_page(mgp->pdev, dmatest_page, 0, PAGE_SIZE,
                                    DMA_BIDIRECTIONAL);
+        if (unlikely(pci_dma_mapping_error(mgp->pdev, dmatest_bus))) {
+                __free_page(dmatest_page);
+                return -ENOMEM;
+        }
 
         /* Run a small DMA test.
          * The magic multipliers to the length tell the firmware
@@ -1294,6 +1298,7 @@ myri10ge_alloc_rx_pages(struct myri10ge_priv *mgp, struct myri10ge_rx_buf *rx,
                         int bytes, int watchdog)
 {
         struct page *page;
+        dma_addr_t bus;
         int idx;
 #if MYRI10GE_ALLOC_SIZE > 4096
         int end_offset;
@@ -1318,11 +1323,21 @@ myri10ge_alloc_rx_pages(struct myri10ge_priv *mgp, struct myri10ge_rx_buf *rx,
                                         rx->watchdog_needed = 1;
                                 return;
                         }
+
+                        bus = pci_map_page(mgp->pdev, page, 0,
+                                           MYRI10GE_ALLOC_SIZE,
+                                           PCI_DMA_FROMDEVICE);
+                        if (unlikely(pci_dma_mapping_error(mgp->pdev, bus))) {
+                                __free_pages(page, MYRI10GE_ALLOC_ORDER);
+                                if (rx->fill_cnt - rx->cnt < 16)
+                                        rx->watchdog_needed = 1;
+                                return;
+                        }
+
                         rx->page = page;
                         rx->page_offset = 0;
-                        rx->bus = pci_map_page(mgp->pdev, page, 0,
-                                               MYRI10GE_ALLOC_SIZE,
-                                               PCI_DMA_FROMDEVICE);
+                        rx->bus = bus;
+
                 }
                 rx->info[idx].page = rx->page;
                 rx->info[idx].page_offset = rx->page_offset;
@@ -2764,6 +2779,35 @@ myri10ge_submit_req(struct myri10ge_tx_buf *tx, struct mcp_kreq_ether_send *src,
         mb();
 }
 
+static void myri10ge_unmap_tx_dma(struct myri10ge_priv *mgp,
+                                  struct myri10ge_tx_buf *tx, int idx)
+{
+        unsigned int len;
+        int last_idx;
+
+        /* Free any DMA resources we've alloced and clear out the skb slot */
+        last_idx = (idx + 1) & tx->mask;
+        idx = tx->req & tx->mask;
+        do {
+                len = dma_unmap_len(&tx->info[idx], len);
+                if (len) {
+                        if (tx->info[idx].skb != NULL)
+                                pci_unmap_single(mgp->pdev,
+                                                 dma_unmap_addr(&tx->info[idx],
+                                                                bus), len,
+                                                 PCI_DMA_TODEVICE);
+                        else
+                                pci_unmap_page(mgp->pdev,
+                                               dma_unmap_addr(&tx->info[idx],
+                                                              bus), len,
+                                               PCI_DMA_TODEVICE);
+                        dma_unmap_len_set(&tx->info[idx], len, 0);
+                        tx->info[idx].skb = NULL;
+                }
+                idx = (idx + 1) & tx->mask;
+        } while (idx != last_idx);
+}
+
 /*
  * Transmit a packet.  We need to split the packet so that a single
  * segment does not cross myri10ge->tx_boundary, so this makes segment
@@ -2787,7 +2831,7 @@ static netdev_tx_t myri10ge_xmit(struct sk_buff *skb,
         u32 low;
         __be32 high_swapped;
         unsigned int len;
-        int idx, last_idx, avail, frag_cnt, frag_idx, count, mss, max_segments;
+        int idx, avail, frag_cnt, frag_idx, count, mss, max_segments;
         u16 pseudo_hdr_offset, cksum_offset, queue;
         int cum_len, seglen, boundary, rdma_count;
         u8 flags, odd_flag;
@@ -2884,9 +2928,12 @@ again:
 
         /* map the skb for DMA */
         len = skb_headlen(skb);
+        bus = pci_map_single(mgp->pdev, skb->data, len, PCI_DMA_TODEVICE);
+        if (unlikely(pci_dma_mapping_error(mgp->pdev, bus)))
+                goto drop;
+
         idx = tx->req & tx->mask;
         tx->info[idx].skb = skb;
-        bus = pci_map_single(mgp->pdev, skb->data, len, PCI_DMA_TODEVICE);
         dma_unmap_addr_set(&tx->info[idx], bus, bus);
         dma_unmap_len_set(&tx->info[idx], len, len);
 
@@ -2985,12 +3032,16 @@ again:
                         break;
 
                 /* map next fragment for DMA */
-                idx = (count + tx->req) & tx->mask;
                 frag = &skb_shinfo(skb)->frags[frag_idx];
                 frag_idx++;
                 len = skb_frag_size(frag);
                 bus = skb_frag_dma_map(&mgp->pdev->dev, frag, 0, len,
                                        DMA_TO_DEVICE);
+                if (unlikely(pci_dma_mapping_error(mgp->pdev, bus))) {
+                        myri10ge_unmap_tx_dma(mgp, tx, idx);
+                        goto drop;
+                }
+                idx = (count + tx->req) & tx->mask;
                 dma_unmap_addr_set(&tx->info[idx], bus, bus);
                 dma_unmap_len_set(&tx->info[idx], len, len);
         }
@@ -3021,31 +3072,8 @@ again:
         return NETDEV_TX_OK;
 
 abort_linearize:
-        /* Free any DMA resources we've alloced and clear out the skb
-         * slot so as to not trip up assertions, and to avoid a
-         * double-free if linearizing fails */
+        myri10ge_unmap_tx_dma(mgp, tx, idx);
 
-        last_idx = (idx + 1) & tx->mask;
-        idx = tx->req & tx->mask;
-        tx->info[idx].skb = NULL;
-        do {
-                len = dma_unmap_len(&tx->info[idx], len);
-                if (len) {
-                        if (tx->info[idx].skb != NULL)
-                                pci_unmap_single(mgp->pdev,
-                                                 dma_unmap_addr(&tx->info[idx],
-                                                                bus), len,
-                                                 PCI_DMA_TODEVICE);
-                        else
-                                pci_unmap_page(mgp->pdev,
-                                               dma_unmap_addr(&tx->info[idx],
-                                                              bus), len,
-                                               PCI_DMA_TODEVICE);
-                        dma_unmap_len_set(&tx->info[idx], len, 0);
-                        tx->info[idx].skb = NULL;
-                }
-                idx = (idx + 1) & tx->mask;
-        } while (idx != last_idx);
         if (skb_is_gso(skb)) {
                 netdev_err(mgp->dev, "TSO but wanted to linearize?!?!?\n");
                 goto drop;
diff --git a/drivers/net/ethernet/sun/sunvnet.c b/drivers/net/ethernet/sun/sunvnet.c
index d813bfb1a847..23c89ab5a6ad 100644
--- a/drivers/net/ethernet/sun/sunvnet.c
+++ b/drivers/net/ethernet/sun/sunvnet.c
@@ -32,6 +32,11 @@ MODULE_DESCRIPTION("Sun LDOM virtual network driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_MODULE_VERSION);
 
+/* Heuristic for the number of times to exponentially backoff and
+ * retry sending an LDC trigger when EAGAIN is encountered
+ */
+#define VNET_MAX_RETRIES        10
+
 /* Ordered from largest major to lowest */
 static struct vio_version vnet_versions[] = {
         { .major = 1, .minor = 0 },
@@ -260,6 +265,7 @@ static int vnet_send_ack(struct vnet_port *port, struct vio_dring_state *dr,
                 .state                  = vio_dring_state,
         };
         int err, delay;
+        int retries = 0;
 
         hdr.seq = dr->snd_nxt;
         delay = 1;
@@ -272,6 +278,13 @@ static int vnet_send_ack(struct vnet_port *port, struct vio_dring_state *dr,
                 udelay(delay);
                 if ((delay <<= 1) > 128)
                         delay = 128;
+                if (retries++ > VNET_MAX_RETRIES) {
+                        pr_info("ECONNRESET %x:%x:%x:%x:%x:%x\n",
+                                port->raddr[0], port->raddr[1],
+                                port->raddr[2], port->raddr[3],
+                                port->raddr[4], port->raddr[5]);
+                        err = -ECONNRESET;
+                }
         } while (err == -EAGAIN);
 
         return err;
@@ -475,8 +488,9 @@ static int handle_mcast(struct vnet_port *port, void *msgbuf)
         return 0;
 }
 
-static void maybe_tx_wakeup(struct vnet *vp)
+static void maybe_tx_wakeup(unsigned long param)
 {
+        struct vnet *vp = (struct vnet *)param;
         struct net_device *dev = vp->dev;
 
         netif_tx_lock(dev);
@@ -573,8 +587,13 @@ static void vnet_event(void *arg, int event)
                         break;
         }
         spin_unlock(&vio->lock);
+        /* Kick off a tasklet to wake the queue.  We cannot call
+         * maybe_tx_wakeup directly here because we could deadlock on
+         * netif_tx_lock() with dev_watchdog()
+         */
         if (unlikely(tx_wakeup && err != -ECONNRESET))
-                maybe_tx_wakeup(port->vp);
+                tasklet_schedule(&port->vp->vnet_tx_wakeup);
+
         local_irq_restore(flags);
 }
 
@@ -593,6 +612,7 @@ static int __vnet_tx_trigger(struct vnet_port *port)
                 .end_idx                = (u32) -1,
         };
         int err, delay;
+        int retries = 0;
 
         hdr.seq = dr->snd_nxt;
         delay = 1;
@@ -605,6 +625,8 @@ static int __vnet_tx_trigger(struct vnet_port *port)
                 udelay(delay);
                 if ((delay <<= 1) > 128)
                         delay = 128;
+                if (retries++ > VNET_MAX_RETRIES)
+                        break;
         } while (err == -EAGAIN);
 
         return err;
@@ -691,7 +713,15 @@ static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 memset(tx_buf+VNET_PACKET_SKIP+skb->len, 0, len - skb->len);
         }
 
-        d->hdr.ack = VIO_ACK_ENABLE;
+        /* We don't rely on the ACKs to free the skb in vnet_start_xmit(),
+         * thus it is safe to not set VIO_ACK_ENABLE for each transmission:
+         * the protocol itself does not require it as long as the peer
+         * sends a VIO_SUBTYPE_ACK for VIO_DRING_STOPPED.
+         *
+         * An ACK for every packet in the ring is expensive as the
+         * sending of LDC messages is slow and affects performance.
+         */
+        d->hdr.ack = VIO_ACK_DISABLE;
         d->size = len;
         d->ncookies = port->tx_bufs[dr->prod].ncookies;
         for (i = 0; i < d->ncookies; i++)
@@ -1046,6 +1076,7 @@ static struct vnet *vnet_new(const u64 *local_mac)
         vp = netdev_priv(dev);
 
         spin_lock_init(&vp->lock);
+        tasklet_init(&vp->vnet_tx_wakeup, maybe_tx_wakeup, (unsigned long)vp);
         vp->dev = dev;
 
         INIT_LIST_HEAD(&vp->port_list);
@@ -1105,6 +1136,7 @@ static void vnet_cleanup(void)
                 vp = list_first_entry(&vnet_list, struct vnet, list);
                 list_del(&vp->list);
                 dev = vp->dev;
+                tasklet_kill(&vp->vnet_tx_wakeup);
                 /* vio_unregister_driver() should have cleaned up port_list */
                 BUG_ON(!list_empty(&vp->port_list));
                 unregister_netdev(dev);
diff --git a/drivers/net/ethernet/sun/sunvnet.h b/drivers/net/ethernet/sun/sunvnet.h
index d347a5bf24b0..de5c2c64996f 100644
--- a/drivers/net/ethernet/sun/sunvnet.h
+++ b/drivers/net/ethernet/sun/sunvnet.h
@@ -1,6 +1,8 @@
 #ifndef _SUNVNET_H
 #define _SUNVNET_H
 
+#include <linux/interrupt.h>
+
 #define DESC_NCOOKIES(entry_size)       \
         ((entry_size) - sizeof(struct vio_net_desc))
 
@@ -78,6 +80,8 @@ struct vnet {
 
         struct list_head        list;
         u64                     local_mac;
+
+        struct tasklet_struct   vnet_tx_wakeup;
 };
 
 #endif /* _SUNVNET_H */
diff --git a/drivers/net/ethernet/xilinx/ll_temac_main.c b/drivers/net/ethernet/xilinx/ll_temac_main.c
index 36f4459520c3..fda5891835d4 100644
--- a/drivers/net/ethernet/xilinx/ll_temac_main.c
+++ b/drivers/net/ethernet/xilinx/ll_temac_main.c
@@ -1170,7 +1170,6 @@ static struct platform_driver temac_of_driver = {
         .probe = temac_of_probe,
         .remove = temac_of_remove,
         .driver = {
-                .owner = THIS_MODULE,
                 .name = "xilinx_temac",
                 .of_match_table = temac_of_match,
         },
diff --git a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
index 30e8608ff050..c8fd94133ecd 100644
--- a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
+++ b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
@@ -1645,7 +1645,6 @@ static struct platform_driver axienet_of_driver = {
         .probe = axienet_of_probe,
         .remove = axienet_of_remove,
         .driver = {
-                 .owner = THIS_MODULE,
                  .name = "xilinx_axienet",
                  .of_match_table = axienet_of_match,
         },
diff --git a/drivers/net/ethernet/xilinx/xilinx_emaclite.c b/drivers/net/ethernet/xilinx/xilinx_emaclite.c
index 782bb9373cd8..28dbbdc393eb 100644
--- a/drivers/net/ethernet/xilinx/xilinx_emaclite.c
+++ b/drivers/net/ethernet/xilinx/xilinx_emaclite.c
@@ -1245,7 +1245,6 @@ MODULE_DEVICE_TABLE(of, xemaclite_of_match);
 static struct platform_driver xemaclite_of_driver = {
         .driver = {
                 .name = DRIVER_NAME,
-                .owner = THIS_MODULE,
                 .of_match_table = xemaclite_of_match,
         },
         .probe          = xemaclite_of_probe,