.init = at91ether_init,
  };
  
++
 +static const struct macb_config zynqmp_config = {
 +      .caps = MACB_CAPS_SG_DISABLED | MACB_CAPS_GIGABIT_MODE_AVAILABLE |
 +              MACB_CAPS_JUMBO,
 +      .dma_burst_length = 16,
 +      .clk_init = macb_clk_init,
 +      .init = macb_init,
 +      .jumbo_max_len = 10240,
 +};
 +
+ static const struct macb_config zynq_config = {
+       .caps = MACB_CAPS_SG_DISABLED | MACB_CAPS_GIGABIT_MODE_AVAILABLE |
+               MACB_CAPS_NO_GIGABIT_HALF,
+       .dma_burst_length = 16,
+       .clk_init = macb_clk_init,
+       .init = macb_init,
+ };
+ 
  static const struct of_device_id macb_dt_ids[] = {
        { .compatible = "cdns,at32ap7000-macb" },
        { .compatible = "cdns,at91sam9260-macb", .data = &at91sam9260_config },
        { .compatible = "atmel,sama5d4-gem", .data = &sama5d4_config },
        { .compatible = "cdns,at91rm9200-emac", .data = &emac_config },
        { .compatible = "cdns,emac", .data = &emac_config },
 +      { .compatible = "cdns,zynqmp-gem", .data = &zynqmp_config},
+       { .compatible = "cdns,zynq-gem", .data = &zynq_config },
        { /* sentinel */ }
  };
  MODULE_DEVICE_TABLE(of, macb_dt_ids);
 
        struct delayed_work *dwork = to_delayed_work(work);
        struct phy_device *phydev =
                        container_of(dwork, struct phy_device, state_queue);
-       bool needs_aneg = false, do_suspend = false, do_resume = false;
+       bool needs_aneg = false, do_suspend = false;
 +      enum phy_state old_state;
        int err = 0;
  
        mutex_lock(&phydev->lock);
 
        bool                    pkt_otherhost;
        unsigned int            mask;
        struct net_device       *physindev;
 -      struct net_device       *physoutdev;
 -      char                    neigh_header[8];
 +      union {
 +              struct net_device *physoutdev;
 +              char neigh_header[8];
 +      };
+       __be32                  ipv4_daddr;
  };
  #endif
  
 
                        state = fa->fa_state;
                        new_fa->fa_state = state & ~FA_S_ACCESSED;
                        new_fa->fa_slen = fa->fa_slen;
+                       new_fa->tb_id = tb->tb_id;
  
 -                      err = netdev_switch_fib_ipv4_add(key, plen, fi,
 -                                                       new_fa->fa_tos,
 -                                                       cfg->fc_type,
 -                                                       cfg->fc_nlflags,
 -                                                       tb->tb_id);
 +                      err = switchdev_fib_ipv4_add(key, plen, fi,
 +                                                   new_fa->fa_tos,
 +                                                   cfg->fc_type,
 +                                                   cfg->fc_nlflags,
 +                                                   tb->tb_id);
                        if (err) {
 -                              netdev_switch_fib_ipv4_abort(fi);
 +                              switchdev_fib_ipv4_abort(fi);
                                kmem_cache_free(fn_alias_kmem, new_fa);
                                goto out;
                        }
                        /* record local slen */
                        slen = fa->fa_slen;
  
-                       if (!fi || !(fi->fib_flags & RTNH_F_EXTERNAL))
+                       if (!fi || !(fi->fib_flags & RTNH_F_OFFLOAD))
                                continue;
  
 -                      netdev_switch_fib_ipv4_del(n->key,
 -                                                 KEYLENGTH - fa->fa_slen,
 -                                                 fi, fa->fa_tos,
 -                                                 fa->fa_type, tb->tb_id);
 +                      switchdev_fib_ipv4_del(n->key, KEYLENGTH - fa->fa_slen,
 +                                             fi, fa->fa_tos, fa->fa_type,
 +                                             tb->tb_id);
                }
  
                /* update leaf slen */
 
        rate = READ_ONCE(sk->sk_max_pacing_rate);
        info->tcpi_max_pacing_rate = rate != ~0U ? rate : ~0ULL;
  
-       spin_lock_bh(&sk->sk_lock.slock);
-       info->tcpi_bytes_acked = tp->bytes_acked;
-       info->tcpi_bytes_received = tp->bytes_received;
+       do {
+               start = u64_stats_fetch_begin_irq(&tp->syncp);
+               info->tcpi_bytes_acked = tp->bytes_acked;
+               info->tcpi_bytes_received = tp->bytes_received;
+       } while (u64_stats_fetch_retry_irq(&tp->syncp, start));
 +      info->tcpi_segs_out = tp->segs_out;
 +      info->tcpi_segs_in = tp->segs_in;
-       spin_unlock_bh(&sk->sk_lock.slock);
  }
  EXPORT_SYMBOL_GPL(tcp_get_info);
  
 
  
  static inline int netlink_is_kernel(struct sock *sk)
  {
 -      return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET;
 +      return nlk_sk(sk)->flags & NETLINK_F_KERNEL_SOCKET;
  }
  
- struct netlink_table *nl_table;
+ struct netlink_table *nl_table __read_mostly;
  EXPORT_SYMBOL_GPL(nl_table);
  
  static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
 
        if (fi->fib_net->ipv4.fib_offload_disabled)
                return 0;
  
 -      dev = netdev_switch_get_dev_by_nhs(fi);
 +      dev = switchdev_get_dev_by_nhs(fi);
        if (!dev)
                return 0;
 -      ops = dev->swdev_ops;
 -
 -      if (ops->swdev_fib_ipv4_add) {
 -              err = ops->swdev_fib_ipv4_add(dev, htonl(dst), dst_len,
 -                                            fi, tos, type, nlflags,
 -                                            tb_id);
 -              if (!err)
 -                      fi->fib_flags |= RTNH_F_OFFLOAD;
 -      }
 +
 +      err = switchdev_port_obj_add(dev, &fib_obj);
 +      if (!err)
-               fi->fib_flags |= RTNH_F_EXTERNAL;
++              fi->fib_flags |= RTNH_F_OFFLOAD;
  
        return err;
  }
   *
   *    Delete IPv4 route entry from switch device.
   */
 -int netdev_switch_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
 -                             u8 tos, u8 type, u32 tb_id)
 +int switchdev_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
 +                         u8 tos, u8 type, u32 tb_id)
  {
 +      struct switchdev_obj fib_obj = {
 +              .id = SWITCHDEV_OBJ_IPV4_FIB,
 +              .u.ipv4_fib = {
 +                      .dst = dst,
 +                      .dst_len = dst_len,
 +                      .fi = fi,
 +                      .tos = tos,
 +                      .type = type,
 +                      .nlflags = 0,
 +                      .tb_id = tb_id,
 +              },
 +      };
        struct net_device *dev;
 -      const struct swdev_ops *ops;
        int err = 0;
  
-       if (!(fi->fib_flags & RTNH_F_EXTERNAL))
+       if (!(fi->fib_flags & RTNH_F_OFFLOAD))
                return 0;
  
 -      dev = netdev_switch_get_dev_by_nhs(fi);
 +      dev = switchdev_get_dev_by_nhs(fi);
        if (!dev)
                return 0;
 -      ops = dev->swdev_ops;
  
 -      if (ops->swdev_fib_ipv4_del) {
 -              err = ops->swdev_fib_ipv4_del(dev, htonl(dst), dst_len,
 -                                            fi, tos, type, tb_id);
 -              if (!err)
 -                      fi->fib_flags &= ~RTNH_F_OFFLOAD;
 -      }
 +      err = switchdev_port_obj_del(dev, &fib_obj);
 +      if (!err)
-               fi->fib_flags &= ~RTNH_F_EXTERNAL;
++              fi->fib_flags &= ~RTNH_F_OFFLOAD;
  
        return err;
  }