*/
        struct dsa_platform_data        *pd;
 
-       /*
-        * Reference to network device to use, and which tagging
-        * protocol to use.
-        */
-       struct net_device       *master_netdev;
-
        /* Copy of tag_ops->rcv for faster access in hot path */
        struct sk_buff *        (*rcv)(struct sk_buff *skb,
                                       struct net_device *dev,
                                       struct packet_type *pt,
                                       struct net_device *orig_dev);
 
-       /*
-        * Original copy of the master netdev ethtool_ops
-        */
-       struct ethtool_ops      master_ethtool_ops;
-       const struct ethtool_ops *master_orig_ethtool_ops;
-
        /*
         * The switch port to which the CPU is attached.
         */
        u8                      stp_state;
        struct net_device       *bridge_dev;
        struct devlink_port     devlink_port;
+       /*
+        * Original copy of the master netdev ethtool_ops
+        */
+       struct ethtool_ops      ethtool_ops;
+       const struct ethtool_ops *orig_ethtool_ops;
 };
 
 struct dsa_switch {
 
        struct net_device *master;
        struct ethtool_ops *cpu_ops;
 
-       master = ds->dst->cpu_dp->netdev;
+       master = cpu_dp->netdev;
+
        cpu_ops = devm_kzalloc(ds->dev, sizeof(*cpu_ops), GFP_KERNEL);
        if (!cpu_ops)
                return -ENOMEM;
 
-       memcpy(&ds->dst->master_ethtool_ops, master->ethtool_ops,
+       memcpy(&cpu_dp->ethtool_ops, master->ethtool_ops,
               sizeof(struct ethtool_ops));
-       ds->dst->master_orig_ethtool_ops = master->ethtool_ops;
-       memcpy(cpu_ops, &ds->dst->master_ethtool_ops,
+       cpu_dp->orig_ethtool_ops = master->ethtool_ops;
+       memcpy(cpu_ops, &cpu_dp->ethtool_ops,
               sizeof(struct ethtool_ops));
        dsa_cpu_port_ethtool_init(cpu_ops);
        master->ethtool_ops = cpu_ops;
 
 void dsa_cpu_port_ethtool_restore(struct dsa_port *cpu_dp)
 {
-       struct dsa_switch *ds = cpu_dp->ds;
-       struct net_device *master;
-
-       master = ds->dst->cpu_dp->netdev;
-
-       master->ethtool_ops = ds->dst->master_orig_ethtool_ops;
+       cpu_dp->netdev->ethtool_ops = cpu_dp->orig_ethtool_ops;
 }
 
 void dsa_cpu_dsa_destroy(struct dsa_port *port)
 
        s8 cpu_port = dst->cpu_dp->index;
        int count = 0;
 
-       if (dst->master_ethtool_ops.get_sset_count) {
-               count = dst->master_ethtool_ops.get_sset_count(dev,
+       if (dst->cpu_dp->ethtool_ops.get_sset_count) {
+               count = dst->cpu_dp->ethtool_ops.get_sset_count(dev,
                                                               ETH_SS_STATS);
-               dst->master_ethtool_ops.get_ethtool_stats(dev, stats, data);
+               dst->cpu_dp->ethtool_ops.get_ethtool_stats(dev, stats, data);
        }
 
        if (ds->ops->get_ethtool_stats)
        struct dsa_switch *ds = dst->cpu_dp->ds;
        int count = 0;
 
-       if (dst->master_ethtool_ops.get_sset_count)
-               count += dst->master_ethtool_ops.get_sset_count(dev, sset);
+       if (dst->cpu_dp->ethtool_ops.get_sset_count)
+               count += dst->cpu_dp->ethtool_ops.get_sset_count(dev, sset);
 
        if (sset == ETH_SS_STATS && ds->ops->get_sset_count)
                count += ds->ops->get_sset_count(ds);
        /* We do not want to be NULL-terminated, since this is a prefix */
        pfx[sizeof(pfx) - 1] = '_';
 
-       if (dst->master_ethtool_ops.get_sset_count) {
-               mcount = dst->master_ethtool_ops.get_sset_count(dev,
+       if (dst->cpu_dp->ethtool_ops.get_sset_count) {
+               mcount = dst->cpu_dp->ethtool_ops.get_sset_count(dev,
                                                                ETH_SS_STATS);
-               dst->master_ethtool_ops.get_strings(dev, stringset, data);
+               dst->cpu_dp->ethtool_ops.get_strings(dev, stringset, data);
        }
 
        if (stringset == ETH_SS_STATS && ds->ops->get_strings) {