diff --git a/target/linux/layerscape/patches-5.4/701-net-0244-net-mscc-ocelot-separate-net_device-related-items-ou.patch b/target/linux/layerscape/patches-5.4/701-net-0244-net-mscc-ocelot-separate-net_device-related-items-ou.patch
new file mode 100644
index 0000000..774e8d0
--- /dev/null
+++ b/target/linux/layerscape/patches-5.4/701-net-0244-net-mscc-ocelot-separate-net_device-related-items-ou.patch
@@ -0,0 +1,1171 @@
+From b0481fbc0d853fd164055293002c621827eba5ad Mon Sep 17 00:00:00 2001
+From: Vladimir Oltean <vladimir.oltean@nxp.com>
+Date: Sat, 9 Nov 2019 15:02:53 +0200
+Subject: [PATCH] net: mscc: ocelot: separate net_device related items out of
+ ocelot_port
+
+The ocelot and ocelot_port structures will be used by a new DSA driver,
+so the ocelot_board.c file will have to allocate and work with a private
+structure (ocelot_port_private), which embeds the generic struct
+ocelot_port. This is because in DSA, at least one interface does not
+have a net_device, and the DSA driver API does not interact with that
+anyway.
+
+The ocelot_port structure is equivalent to dsa_port, and ocelot to
+dsa_switch. The members of ocelot_port which have an equivalent in
+dsa_port (such as dp->vlan_filtering) have been moved to
+ocelot_port_private.
+
+We want to enforce the coding convention that "ocelot_port" refers to
+the structure, and "port" refers to the integer index. One can retrieve
+the structure at any time from ocelot->ports[port].
+
+The patch is large but only contains variable renaming and mechanical
+movement of fields from one structure to another.
+
+Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+---
+ drivers/net/ethernet/mscc/ocelot.c        | 288 ++++++++++++++++--------------
+ drivers/net/ethernet/mscc/ocelot.h        |  21 ++-
+ drivers/net/ethernet/mscc/ocelot_ace.h    |   4 +-
+ drivers/net/ethernet/mscc/ocelot_board.c  |  25 ++-
+ drivers/net/ethernet/mscc/ocelot_flower.c |  32 ++--
+ drivers/net/ethernet/mscc/ocelot_tc.c     |  57 +++---
+ 6 files changed, 235 insertions(+), 192 deletions(-)
+
+--- a/drivers/net/ethernet/mscc/ocelot.c
++++ b/drivers/net/ethernet/mscc/ocelot.c
+@@ -229,8 +229,6 @@ static void ocelot_port_vlan_filtering(s
+ 	ocelot_rmw_gix(ocelot, val,
+ 		       REW_TAG_CFG_TAG_CFG_M,
+ 		       REW_TAG_CFG, port);
+-
+-	ocelot_port->vlan_aware = vlan_aware;
+ }
+ 
+ static int ocelot_port_set_native_vlan(struct ocelot *ocelot, int port,
+@@ -297,9 +295,10 @@ static int ocelot_vlan_add(struct ocelot
+ static int ocelot_vlan_vid_add(struct net_device *dev, u16 vid, bool pvid,
+ 			       bool untagged)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
+ 	struct ocelot *ocelot = ocelot_port->ocelot;
+-	int port = ocelot_port->chip_port;
++	int port = priv->chip_port;
+ 	int ret;
+ 
+ 	ret = ocelot_vlan_add(ocelot, port, vid, pvid, untagged);
+@@ -337,9 +336,9 @@ static int ocelot_vlan_del(struct ocelot
+ 
+ static int ocelot_vlan_vid_del(struct net_device *dev, u16 vid)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
+-	int port = ocelot_port->chip_port;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 	int ret;
+ 
+ 	/* 8021q removes VID 0 on module unload for all interfaces
+@@ -412,10 +411,11 @@ static u16 ocelot_wm_enc(u16 value)
+ 
+ static void ocelot_port_adjust_link(struct net_device *dev)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
+-	u8 p = port->chip_port;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 	int speed, atop_wm, mode = 0;
++	u8 port = priv->chip_port;
+ 
+ 	switch (dev->phydev->speed) {
+ 	case SPEED_10:
+@@ -444,62 +444,66 @@ static void ocelot_port_adjust_link(stru
+ 		return;
+ 
+ 	/* Only full duplex supported for now */
+-	ocelot_port_writel(port, DEV_MAC_MODE_CFG_FDX_ENA |
++	ocelot_port_writel(ocelot_port, DEV_MAC_MODE_CFG_FDX_ENA |
+ 			   mode, DEV_MAC_MODE_CFG);
+ 
+ 	/* Set MAC IFG Gaps
+ 	 * FDX: TX_IFG = 5, RX_IFG1 = RX_IFG2 = 0
+ 	 * !FDX: TX_IFG = 5, RX_IFG1 = RX_IFG2 = 5
+ 	 */
+-	ocelot_port_writel(port, DEV_MAC_IFG_CFG_TX_IFG(5), DEV_MAC_IFG_CFG);
++	ocelot_port_writel(ocelot_port, DEV_MAC_IFG_CFG_TX_IFG(5),
++			   DEV_MAC_IFG_CFG);
+ 
+ 	/* Load seed (0) and set MAC HDX late collision  */
+-	ocelot_port_writel(port, DEV_MAC_HDX_CFG_LATE_COL_POS(67) |
++	ocelot_port_writel(ocelot_port, DEV_MAC_HDX_CFG_LATE_COL_POS(67) |
+ 			   DEV_MAC_HDX_CFG_SEED_LOAD,
+ 			   DEV_MAC_HDX_CFG);
+ 	mdelay(1);
+-	ocelot_port_writel(port, DEV_MAC_HDX_CFG_LATE_COL_POS(67),
++	ocelot_port_writel(ocelot_port, DEV_MAC_HDX_CFG_LATE_COL_POS(67),
+ 			   DEV_MAC_HDX_CFG);
+ 
+ 	/* Disable HDX fast control */
+-	ocelot_port_writel(port, DEV_PORT_MISC_HDX_FAST_DIS, DEV_PORT_MISC);
++	ocelot_port_writel(ocelot_port, DEV_PORT_MISC_HDX_FAST_DIS,
++			   DEV_PORT_MISC);
+ 
+ 	/* SGMII only for now */
+-	ocelot_port_writel(port, PCS1G_MODE_CFG_SGMII_MODE_ENA, PCS1G_MODE_CFG);
+-	ocelot_port_writel(port, PCS1G_SD_CFG_SD_SEL, PCS1G_SD_CFG);
++	ocelot_port_writel(ocelot_port, PCS1G_MODE_CFG_SGMII_MODE_ENA,
++			   PCS1G_MODE_CFG);
++	ocelot_port_writel(ocelot_port, PCS1G_SD_CFG_SD_SEL, PCS1G_SD_CFG);
+ 
+ 	/* Enable PCS */
+-	ocelot_port_writel(port, PCS1G_CFG_PCS_ENA, PCS1G_CFG);
++	ocelot_port_writel(ocelot_port, PCS1G_CFG_PCS_ENA, PCS1G_CFG);
+ 
+ 	/* No aneg on SGMII */
+-	ocelot_port_writel(port, 0, PCS1G_ANEG_CFG);
++	ocelot_port_writel(ocelot_port, 0, PCS1G_ANEG_CFG);
+ 
+ 	/* No loopback */
+-	ocelot_port_writel(port, 0, PCS1G_LB_CFG);
++	ocelot_port_writel(ocelot_port, 0, PCS1G_LB_CFG);
+ 
+ 	/* Set Max Length and maximum tags allowed */
+-	ocelot_port_writel(port, VLAN_ETH_FRAME_LEN, DEV_MAC_MAXLEN_CFG);
+-	ocelot_port_writel(port, DEV_MAC_TAGS_CFG_TAG_ID(ETH_P_8021AD) |
++	ocelot_port_writel(ocelot_port, VLAN_ETH_FRAME_LEN,
++			   DEV_MAC_MAXLEN_CFG);
++	ocelot_port_writel(ocelot_port, DEV_MAC_TAGS_CFG_TAG_ID(ETH_P_8021AD) |
+ 			   DEV_MAC_TAGS_CFG_VLAN_AWR_ENA |
+ 			   DEV_MAC_TAGS_CFG_VLAN_LEN_AWR_ENA,
+ 			   DEV_MAC_TAGS_CFG);
+ 
+ 	/* Enable MAC module */
+-	ocelot_port_writel(port, DEV_MAC_ENA_CFG_RX_ENA |
++	ocelot_port_writel(ocelot_port, DEV_MAC_ENA_CFG_RX_ENA |
+ 			   DEV_MAC_ENA_CFG_TX_ENA, DEV_MAC_ENA_CFG);
+ 
+ 	/* Take MAC, Port, Phy (intern) and PCS (SGMII/Serdes) clock out of
+ 	 * reset */
+-	ocelot_port_writel(port, DEV_CLOCK_CFG_LINK_SPEED(speed),
++	ocelot_port_writel(ocelot_port, DEV_CLOCK_CFG_LINK_SPEED(speed),
+ 			   DEV_CLOCK_CFG);
+ 
+ 	/* Set SMAC of Pause frame (00:00:00:00:00:00) */
+-	ocelot_port_writel(port, 0, DEV_MAC_FC_MAC_HIGH_CFG);
+-	ocelot_port_writel(port, 0, DEV_MAC_FC_MAC_LOW_CFG);
++	ocelot_port_writel(ocelot_port, 0, DEV_MAC_FC_MAC_HIGH_CFG);
++	ocelot_port_writel(ocelot_port, 0, DEV_MAC_FC_MAC_LOW_CFG);
+ 
+ 	/* No PFC */
+ 	ocelot_write_gix(ocelot, ANA_PFC_PFC_CFG_FC_LINK_SPEED(speed),
+-			 ANA_PFC_PFC_CFG, p);
++			 ANA_PFC_PFC_CFG, port);
+ 
+ 	/* Set Pause WM hysteresis
+ 	 * 152 = 6 * VLAN_ETH_FRAME_LEN / OCELOT_BUFFER_CELL_SZ
+@@ -507,13 +511,13 @@ static void ocelot_port_adjust_link(stru
+ 	 */
+ 	ocelot_write_rix(ocelot, SYS_PAUSE_CFG_PAUSE_ENA |
+ 			 SYS_PAUSE_CFG_PAUSE_STOP(101) |
+-			 SYS_PAUSE_CFG_PAUSE_START(152), SYS_PAUSE_CFG, p);
++			 SYS_PAUSE_CFG_PAUSE_START(152), SYS_PAUSE_CFG, port);
+ 
+ 	/* Core: Enable port for frame transfer */
+ 	ocelot_write_rix(ocelot, QSYS_SWITCH_PORT_MODE_INGRESS_DROP_MODE |
+ 			 QSYS_SWITCH_PORT_MODE_SCH_NEXT_CFG(1) |
+ 			 QSYS_SWITCH_PORT_MODE_PORT_ENA,
+-			 QSYS_SWITCH_PORT_MODE, p);
++			 QSYS_SWITCH_PORT_MODE, port);
+ 
+ 	/* Flow control */
+ 	ocelot_write_rix(ocelot, SYS_MAC_FC_CFG_PAUSE_VAL_CFG(0xffff) |
+@@ -521,20 +525,21 @@ static void ocelot_port_adjust_link(stru
+ 			 SYS_MAC_FC_CFG_ZERO_PAUSE_ENA |
+ 			 SYS_MAC_FC_CFG_FC_LATENCY_CFG(0x7) |
+ 			 SYS_MAC_FC_CFG_FC_LINK_SPEED(speed),
+-			 SYS_MAC_FC_CFG, p);
+-	ocelot_write_rix(ocelot, 0, ANA_POL_FLOWC, p);
++			 SYS_MAC_FC_CFG, port);
++	ocelot_write_rix(ocelot, 0, ANA_POL_FLOWC, port);
+ 
+ 	/* Tail dropping watermark */
+ 	atop_wm = (ocelot->shared_queue_sz - 9 * VLAN_ETH_FRAME_LEN) / OCELOT_BUFFER_CELL_SZ;
+ 	ocelot_write_rix(ocelot, ocelot_wm_enc(9 * VLAN_ETH_FRAME_LEN),
+-			 SYS_ATOP, p);
++			 SYS_ATOP, port);
+ 	ocelot_write(ocelot, ocelot_wm_enc(atop_wm), SYS_ATOP_TOT_CFG);
+ }
+ 
+ static int ocelot_port_open(struct net_device *dev)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 	int err;
+ 
+ 	/* Enable receiving frames on the port, and activate auto-learning of
+@@ -542,43 +547,44 @@ static int ocelot_port_open(struct net_d
+ 	 */
+ 	ocelot_write_gix(ocelot, ANA_PORT_PORT_CFG_LEARNAUTO |
+ 			 ANA_PORT_PORT_CFG_RECV_ENA |
+-			 ANA_PORT_PORT_CFG_PORTID_VAL(port->chip_port),
+-			 ANA_PORT_PORT_CFG, port->chip_port);
++			 ANA_PORT_PORT_CFG_PORTID_VAL(port),
++			 ANA_PORT_PORT_CFG, port);
+ 
+-	if (port->serdes) {
+-		err = phy_set_mode_ext(port->serdes, PHY_MODE_ETHERNET,
+-				       port->phy_mode);
++	if (priv->serdes) {
++		err = phy_set_mode_ext(priv->serdes, PHY_MODE_ETHERNET,
++				       priv->phy_mode);
+ 		if (err) {
+ 			netdev_err(dev, "Could not set mode of SerDes\n");
+ 			return err;
+ 		}
+ 	}
+ 
+-	err = phy_connect_direct(dev, port->phy, &ocelot_port_adjust_link,
+-				 port->phy_mode);
++	err = phy_connect_direct(dev, priv->phy, &ocelot_port_adjust_link,
++				 priv->phy_mode);
+ 	if (err) {
+ 		netdev_err(dev, "Could not attach to PHY\n");
+ 		return err;
+ 	}
+ 
+-	dev->phydev = port->phy;
++	dev->phydev = priv->phy;
+ 
+-	phy_attached_info(port->phy);
+-	phy_start(port->phy);
++	phy_attached_info(priv->phy);
++	phy_start(priv->phy);
+ 	return 0;
+ }
+ 
+ static int ocelot_port_stop(struct net_device *dev)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *port = &priv->port;
+ 
+-	phy_disconnect(port->phy);
++	phy_disconnect(priv->phy);
+ 
+ 	dev->phydev = NULL;
+ 
+ 	ocelot_port_writel(port, 0, DEV_MAC_ENA_CFG);
+ 	ocelot_rmw_rix(port->ocelot, 0, QSYS_SWITCH_PORT_MODE_PORT_ENA,
+-			 QSYS_SWITCH_PORT_MODE, port->chip_port);
++		       QSYS_SWITCH_PORT_MODE, priv->chip_port);
+ 	return 0;
+ }
+ 
+@@ -604,13 +610,15 @@ static int ocelot_gen_ifh(u32 *ifh, stru
+ 
+ static int ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev)
+ {
++	struct ocelot_port_private *priv = netdev_priv(dev);
+ 	struct skb_shared_info *shinfo = skb_shinfo(skb);
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
+-	u32 val, ifh[IFH_LEN];
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 	struct frame_info info = {};
+ 	u8 grp = 0; /* Send everything on CPU group 0 */
+ 	unsigned int i, count, last;
++	int port = priv->chip_port;
++	u32 val, ifh[IFH_LEN];
+ 
+ 	val = ocelot_read(ocelot, QS_INJ_STATUS);
+ 	if (!(val & QS_INJ_STATUS_FIFO_RDY(BIT(grp))) ||
+@@ -620,15 +628,15 @@ static int ocelot_port_xmit(struct sk_bu
+ 	ocelot_write_rix(ocelot, QS_INJ_CTRL_GAP_SIZE(1) |
+ 			 QS_INJ_CTRL_SOF, QS_INJ_CTRL, grp);
+ 
+-	info.port = BIT(port->chip_port);
++	info.port = BIT(port);
+ 	info.tag_type = IFH_TAG_TYPE_C;
+ 	info.vid = skb_vlan_tag_get(skb);
+ 
+ 	/* Check if timestamping is needed */
+ 	if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP) {
+-		info.rew_op = port->ptp_cmd;
+-		if (port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
+-			info.rew_op |= (port->ts_id  % 4) << 3;
++		info.rew_op = ocelot_port->ptp_cmd;
++		if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
++			info.rew_op |= (ocelot_port->ts_id  % 4) << 3;
+ 	}
+ 
+ 	ocelot_gen_ifh(ifh, &info);
+@@ -663,7 +671,7 @@ static int ocelot_port_xmit(struct sk_bu
+ 	dev->stats.tx_bytes += skb->len;
+ 
+ 	if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP &&
+-	    port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
++	    ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
+ 		struct ocelot_skb *oskb =
+ 			kzalloc(sizeof(struct ocelot_skb), GFP_ATOMIC);
+ 
+@@ -673,10 +681,10 @@ static int ocelot_port_xmit(struct sk_bu
+ 		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+ 
+ 		oskb->skb = skb;
+-		oskb->id = port->ts_id % 4;
+-		port->ts_id++;
++		oskb->id = ocelot_port->ts_id % 4;
++		ocelot_port->ts_id++;
+ 
+-		list_add_tail(&oskb->head, &port->skbs);
++		list_add_tail(&oskb->head, &ocelot_port->skbs);
+ 
+ 		return NETDEV_TX_OK;
+ 	}
+@@ -715,25 +723,29 @@ EXPORT_SYMBOL(ocelot_get_hwtimestamp);
+ 
+ static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 
+-	return ocelot_mact_forget(port->ocelot, addr, port->pvid);
++	return ocelot_mact_forget(ocelot, addr, ocelot_port->pvid);
+ }
+ 
+ static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 
+-	return ocelot_mact_learn(port->ocelot, PGID_CPU, addr, port->pvid,
++	return ocelot_mact_learn(ocelot, PGID_CPU, addr, ocelot_port->pvid,
+ 				 ENTRYTYPE_LOCKED);
+ }
+ 
+ static void ocelot_set_rx_mode(struct net_device *dev)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
+-	int i;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
+ 	u32 val;
++	int i;
+ 
+ 	/* This doesn't handle promiscuous mode because the bridge core is
+ 	 * setting IFF_PROMISC on all slave interfaces and all frames would be
+@@ -749,10 +761,11 @@ static void ocelot_set_rx_mode(struct ne
+ static int ocelot_port_get_phys_port_name(struct net_device *dev,
+ 					  char *buf, size_t len)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	int port = priv->chip_port;
+ 	int ret;
+ 
+-	ret = snprintf(buf, len, "p%d", port->chip_port);
++	ret = snprintf(buf, len, "p%d", port);
+ 	if (ret >= len)
+ 		return -EINVAL;
+ 
+@@ -761,15 +774,16 @@ static int ocelot_port_get_phys_port_nam
+ 
+ static int ocelot_port_set_mac_address(struct net_device *dev, void *p)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 	const struct sockaddr *addr = p;
+ 
+ 	/* Learn the new net device MAC address in the mac table. */
+-	ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data, port->pvid,
++	ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data, ocelot_port->pvid,
+ 			  ENTRYTYPE_LOCKED);
+ 	/* Then forget the previous one. */
+-	ocelot_mact_forget(ocelot, dev->dev_addr, port->pvid);
++	ocelot_mact_forget(ocelot, dev->dev_addr, ocelot_port->pvid);
+ 
+ 	ether_addr_copy(dev->dev_addr, addr->sa_data);
+ 	return 0;
+@@ -778,11 +792,12 @@ static int ocelot_port_set_mac_address(s
+ static void ocelot_get_stats64(struct net_device *dev,
+ 			       struct rtnl_link_stats64 *stats)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 
+ 	/* Configure the port to read the stats from */
+-	ocelot_write(ocelot, SYS_STAT_CFG_STAT_VIEW(port->chip_port),
++	ocelot_write(ocelot, SYS_STAT_CFG_STAT_VIEW(port),
+ 		     SYS_STAT_CFG);
+ 
+ 	/* Get Rx stats */
+@@ -814,12 +829,13 @@ static void ocelot_get_stats64(struct ne
+ }
+ 
+ static int ocelot_fdb_add(struct ocelot *ocelot, int port,
+-			  const unsigned char *addr, u16 vid)
++			  const unsigned char *addr, u16 vid,
++			  bool vlan_aware)
+ {
+ 	struct ocelot_port *ocelot_port = ocelot->ports[port];
+ 
+ 	if (!vid) {
+-		if (!ocelot_port->vlan_aware)
++		if (!vlan_aware)
+ 			/* If the bridge is not VLAN aware and no VID was
+ 			 * provided, set it to pvid to ensure the MAC entry
+ 			 * matches incoming untagged packets
+@@ -841,10 +857,11 @@ static int ocelot_port_fdb_add(struct nd
+ 			       u16 vid, u16 flags,
+ 			       struct netlink_ext_ack *extack)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 
+-	return ocelot_fdb_add(ocelot, ocelot_port->chip_port, addr, vid);
++	return ocelot_fdb_add(ocelot, port, addr, vid, priv->vlan_aware);
+ }
+ 
+ static int ocelot_fdb_del(struct ocelot *ocelot, int port,
+@@ -857,10 +874,11 @@ static int ocelot_port_fdb_del(struct nd
+ 			       struct net_device *dev,
+ 			       const unsigned char *addr, u16 vid)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 
+-	return ocelot_fdb_del(ocelot, ocelot_port->chip_port, addr, vid);
++	return ocelot_fdb_del(ocelot, port, addr, vid);
+ }
+ 
+ struct ocelot_dump_ctx {
+@@ -999,18 +1017,18 @@ static int ocelot_port_fdb_dump(struct s
+ 				struct net_device *dev,
+ 				struct net_device *filter_dev, int *idx)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
+ 	struct ocelot_dump_ctx dump = {
+ 		.dev = dev,
+ 		.skb = skb,
+ 		.cb = cb,
+ 		.idx = *idx,
+ 	};
++	int port = priv->chip_port;
+ 	int ret;
+ 
+-	ret = ocelot_fdb_dump(ocelot, ocelot_port->chip_port,
+-			      ocelot_port_fdb_do_dump, &dump);
++	ret = ocelot_fdb_dump(ocelot, port, ocelot_port_fdb_do_dump, &dump);
+ 
+ 	*idx = dump.idx;
+ 
+@@ -1033,12 +1051,12 @@ static int ocelot_set_features(struct ne
+ 			       netdev_features_t features)
+ {
+ 	netdev_features_t changed = dev->features ^ features;
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
+-	int port = ocelot_port->chip_port;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 
+ 	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) &&
+-	    ocelot_port->tc.offload_cnt) {
++	    priv->tc.offload_cnt) {
+ 		netdev_err(dev,
+ 			   "Cannot disable HW TC offload while offloads active\n");
+ 		return -EBUSY;
+@@ -1053,8 +1071,8 @@ static int ocelot_set_features(struct ne
+ static int ocelot_get_port_parent_id(struct net_device *dev,
+ 				     struct netdev_phys_item_id *ppid)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
+ 
+ 	ppid->id_len = sizeof(ocelot->base_mac);
+ 	memcpy(&ppid->id, &ocelot->base_mac, ppid->id_len);
+@@ -1130,9 +1148,9 @@ static int ocelot_hwstamp_set(struct oce
+ 
+ static int ocelot_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
+-	int port = ocelot_port->chip_port;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 
+ 	/* The function is only used for PTP operations for now */
+ 	if (!ocelot->ptp)
+@@ -1169,8 +1187,8 @@ static const struct net_device_ops ocelo
+ 
+ static void ocelot_get_strings(struct net_device *netdev, u32 sset, u8 *data)
+ {
+-	struct ocelot_port *port = netdev_priv(netdev);
+-	struct ocelot *ocelot = port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(netdev);
++	struct ocelot *ocelot = priv->port.ocelot;
+ 	int i;
+ 
+ 	if (sset != ETH_SS_STATS)
+@@ -1224,8 +1242,9 @@ static void ocelot_check_stats_work(stru
+ static void ocelot_get_ethtool_stats(struct net_device *dev,
+ 				     struct ethtool_stats *stats, u64 *data)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 	int i;
+ 
+ 	/* check and update now */
+@@ -1233,13 +1252,13 @@ static void ocelot_get_ethtool_stats(str
+ 
+ 	/* Copy all counters */
+ 	for (i = 0; i < ocelot->num_stats; i++)
+-		*data++ = ocelot->stats[port->chip_port * ocelot->num_stats + i];
++		*data++ = ocelot->stats[port * ocelot->num_stats + i];
+ }
+ 
+ static int ocelot_get_sset_count(struct net_device *dev, int sset)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
+ 
+ 	if (sset != ETH_SS_STATS)
+ 		return -EOPNOTSUPP;
+@@ -1249,8 +1268,8 @@ static int ocelot_get_sset_count(struct
+ static int ocelot_get_ts_info(struct net_device *dev,
+ 			      struct ethtool_ts_info *info)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
+ 
+ 	if (!ocelot->ptp)
+ 		return ethtool_op_get_ts_info(dev, info);
+@@ -1385,9 +1404,9 @@ static int ocelot_port_attr_set(struct n
+ 				const struct switchdev_attr *attr,
+ 				struct switchdev_trans *trans)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
+-	struct ocelot *ocelot = ocelot_port->ocelot;
+-	int port = ocelot_port->chip_port;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot *ocelot = priv->port.ocelot;
++	int port = priv->chip_port;
+ 	int err = 0;
+ 
+ 	switch (attr->id) {
+@@ -1399,8 +1418,8 @@ static int ocelot_port_attr_set(struct n
+ 		ocelot_port_attr_ageing_set(ocelot, port, attr->u.ageing_time);
+ 		break;
+ 	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
+-		ocelot_port_vlan_filtering(ocelot, port,
+-					   attr->u.vlan_filtering);
++		priv->vlan_aware = attr->u.vlan_filtering;
++		ocelot_port_vlan_filtering(ocelot, port, priv->vlan_aware);
+ 		break;
+ 	case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
+ 		ocelot_port_attr_mc_set(ocelot, port, !attr->u.mc_disabled);
+@@ -1465,15 +1484,17 @@ static int ocelot_port_obj_add_mdb(struc
+ 				   const struct switchdev_obj_port_mdb *mdb,
+ 				   struct switchdev_trans *trans)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
+-	struct ocelot_multicast *mc;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 	unsigned char addr[ETH_ALEN];
++	struct ocelot_multicast *mc;
++	int port = priv->chip_port;
+ 	u16 vid = mdb->vid;
+ 	bool new = false;
+ 
+ 	if (!vid)
+-		vid = port->pvid;
++		vid = ocelot_port->pvid;
+ 
+ 	mc = ocelot_multicast_get(ocelot, mdb->addr, vid);
+ 	if (!mc) {
+@@ -1497,7 +1518,7 @@ static int ocelot_port_obj_add_mdb(struc
+ 		ocelot_mact_forget(ocelot, addr, vid);
+ 	}
+ 
+-	mc->ports |= BIT(port->chip_port);
++	mc->ports |= BIT(port);
+ 	addr[2] = mc->ports << 0;
+ 	addr[1] = mc->ports << 8;
+ 
+@@ -1507,14 +1528,16 @@ static int ocelot_port_obj_add_mdb(struc
+ static int ocelot_port_obj_del_mdb(struct net_device *dev,
+ 				   const struct switchdev_obj_port_mdb *mdb)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
+-	struct ocelot *ocelot = port->ocelot;
+-	struct ocelot_multicast *mc;
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
++	struct ocelot *ocelot = ocelot_port->ocelot;
+ 	unsigned char addr[ETH_ALEN];
++	struct ocelot_multicast *mc;
++	int port = priv->chip_port;
+ 	u16 vid = mdb->vid;
+ 
+ 	if (!vid)
+-		vid = port->pvid;
++		vid = ocelot_port->pvid;
+ 
+ 	mc = ocelot_multicast_get(ocelot, mdb->addr, vid);
+ 	if (!mc)
+@@ -1526,7 +1549,7 @@ static int ocelot_port_obj_del_mdb(struc
+ 	addr[0] = 0;
+ 	ocelot_mact_forget(ocelot, addr, vid);
+ 
+-	mc->ports &= ~BIT(port->chip_port);
++	mc->ports &= ~BIT(port);
+ 	if (!mc->ports) {
+ 		list_del(&mc->list);
+ 		devm_kfree(ocelot->dev, mc);
+@@ -1680,9 +1703,9 @@ static int ocelot_port_lag_join(struct o
+ 
+ 	rcu_read_lock();
+ 	for_each_netdev_in_bond_rcu(bond, ndev) {
+-		struct ocelot_port *port = netdev_priv(ndev);
++		struct ocelot_port_private *priv = netdev_priv(ndev);
+ 
+-		bond_mask |= BIT(port->chip_port);
++		bond_mask |= BIT(priv->chip_port);
+ 	}
+ 	rcu_read_unlock();
+ 
+@@ -1750,20 +1773,23 @@ static int ocelot_netdevice_port_event(s
+ 				       unsigned long event,
+ 				       struct netdev_notifier_changeupper_info *info)
+ {
+-	struct ocelot_port *ocelot_port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
++	struct ocelot_port *ocelot_port = &priv->port;
+ 	struct ocelot *ocelot = ocelot_port->ocelot;
+-	int port = ocelot_port->chip_port;
++	int port = priv->chip_port;
+ 	int err = 0;
+ 
+ 	switch (event) {
+ 	case NETDEV_CHANGEUPPER:
+ 		if (netif_is_bridge_master(info->upper_dev)) {
+-			if (info->linking)
++			if (info->linking) {
+ 				err = ocelot_port_bridge_join(ocelot, port,
+ 							      info->upper_dev);
+-			else
++			} else {
+ 				err = ocelot_port_bridge_leave(ocelot, port,
+ 							       info->upper_dev);
++				priv->vlan_aware = false;
++			}
+ 		}
+ 		if (netif_is_lag_master(info->upper_dev)) {
+ 			if (info->linking)
+@@ -2079,21 +2105,23 @@ int ocelot_probe_port(struct ocelot *oce
+ 		      void __iomem *regs,
+ 		      struct phy_device *phy)
+ {
++	struct ocelot_port_private *priv;
+ 	struct ocelot_port *ocelot_port;
+ 	struct net_device *dev;
+ 	u32 val;
+ 	int err;
+ 
+-	dev = alloc_etherdev(sizeof(struct ocelot_port));
++	dev = alloc_etherdev(sizeof(struct ocelot_port_private));
+ 	if (!dev)
+ 		return -ENOMEM;
+ 	SET_NETDEV_DEV(dev, ocelot->dev);
+-	ocelot_port = netdev_priv(dev);
+-	ocelot_port->dev = dev;
++	priv = netdev_priv(dev);
++	priv->dev = dev;
++	priv->phy = phy;
++	priv->chip_port = port;
++	ocelot_port = &priv->port;
+ 	ocelot_port->ocelot = ocelot;
+ 	ocelot_port->regs = regs;
+-	ocelot_port->chip_port = port;
+-	ocelot_port->phy = phy;
+ 	ocelot->ports[port] = ocelot_port;
+ 
+ 	dev->netdev_ops = &ocelot_port_netdev_ops;
+--- a/drivers/net/ethernet/mscc/ocelot.h
++++ b/drivers/net/ethernet/mscc/ocelot.h
+@@ -479,11 +479,9 @@ struct ocelot {
+ };
+ 
+ struct ocelot_port {
+-	struct net_device *dev;
+ 	struct ocelot *ocelot;
+-	struct phy_device *phy;
++
+ 	void __iomem *regs;
+-	u8 chip_port;
+ 
+ 	/* Ingress default VLAN (pvid) */
+ 	u16 pvid;
+@@ -491,18 +489,23 @@ struct ocelot_port {
+ 	/* Egress default VLAN (vid) */
+ 	u16 vid;
+ 
+-	u8 vlan_aware;
++	u8 ptp_cmd;
++	struct list_head skbs;
++	u8 ts_id;
++};
+ 
+-	u64 *stats;
++struct ocelot_port_private {
++	struct ocelot_port port;
++	struct net_device *dev;
++	struct phy_device *phy;
++	u8 chip_port;
++
++	u8 vlan_aware;
+ 
+ 	phy_interface_t phy_mode;
+ 	struct phy *serdes;
+ 
+ 	struct ocelot_port_tc tc;
+-
+-	u8 ptp_cmd;
+-	struct list_head skbs;
+-	u8 ts_id;
+ };
+ 
+ struct ocelot_skb {
+--- a/drivers/net/ethernet/mscc/ocelot_ace.h
++++ b/drivers/net/ethernet/mscc/ocelot_ace.h
+@@ -224,9 +224,9 @@ int ocelot_ace_rule_stats_update(struct
+ int ocelot_ace_init(struct ocelot *ocelot);
+ void ocelot_ace_deinit(void);
+ 
+-int ocelot_setup_tc_block_flower_bind(struct ocelot_port *port,
++int ocelot_setup_tc_block_flower_bind(struct ocelot_port_private *priv,
+ 				      struct flow_block_offload *f);
+-void ocelot_setup_tc_block_flower_unbind(struct ocelot_port *port,
++void ocelot_setup_tc_block_flower_unbind(struct ocelot_port_private *priv,
+ 					 struct flow_block_offload *f);
+ 
+ #endif /* _MSCC_OCELOT_ACE_H_ */
+--- a/drivers/net/ethernet/mscc/ocelot_board.c
++++ b/drivers/net/ethernet/mscc/ocelot_board.c
+@@ -95,6 +95,8 @@ static irqreturn_t ocelot_xtr_irq_handle
+ 
+ 	do {
+ 		struct skb_shared_hwtstamps *shhwtstamps;
++		struct ocelot_port_private *priv;
++		struct ocelot_port *ocelot_port;
+ 		u64 tod_in_ns, full_ts_in_ns;
+ 		struct frame_info info = {};
+ 		struct net_device *dev;
+@@ -122,7 +124,10 @@ static irqreturn_t ocelot_xtr_irq_handle
+ 
+ 		ocelot_parse_ifh(ifh, &info);
+ 
+-		dev = ocelot->ports[info.port]->dev;
++		ocelot_port = ocelot->ports[info.port];
++		priv = container_of(ocelot_port, struct ocelot_port_private,
++				    port);
++		dev = priv->dev;
+ 
+ 		skb = netdev_alloc_skb(dev, info.len);
+ 
+@@ -371,6 +376,8 @@ static int mscc_ocelot_probe(struct plat
+ 	ocelot_init(ocelot);
+ 
+ 	for_each_available_child_of_node(ports, portnp) {
++		struct ocelot_port_private *priv;
++		struct ocelot_port *ocelot_port;
+ 		struct device_node *phy_node;
+ 		struct phy_device *phy;
+ 		struct resource *res;
+@@ -406,13 +413,17 @@ static int mscc_ocelot_probe(struct plat
+ 			goto out_put_ports;
+ 		}
+ 
++		ocelot_port = ocelot->ports[port];
++		priv = container_of(ocelot_port, struct ocelot_port_private,
++				    port);
++
+ 		phy_mode = of_get_phy_mode(portnp);
+ 		if (phy_mode < 0)
+-			ocelot->ports[port]->phy_mode = PHY_INTERFACE_MODE_NA;
+-		else
+-			ocelot->ports[port]->phy_mode = phy_mode;
++			phy_mode = PHY_INTERFACE_MODE_NA;
++
++		priv->phy_mode = phy_mode;
+ 
+-		switch (ocelot->ports[port]->phy_mode) {
++		switch (priv->phy_mode) {
+ 		case PHY_INTERFACE_MODE_NA:
+ 			continue;
+ 		case PHY_INTERFACE_MODE_SGMII:
+@@ -421,7 +432,7 @@ static int mscc_ocelot_probe(struct plat
+ 			/* Ensure clock signals and speed is set on all
+ 			 * QSGMII links
+ 			 */
+-			ocelot_port_writel(ocelot->ports[port],
++			ocelot_port_writel(ocelot_port,
+ 					   DEV_CLOCK_CFG_LINK_SPEED
+ 					   (OCELOT_SPEED_1000),
+ 					   DEV_CLOCK_CFG);
+@@ -449,7 +460,7 @@ static int mscc_ocelot_probe(struct plat
+ 			goto out_put_ports;
+ 		}
+ 
+-		ocelot->ports[port]->serdes = serdes;
++		priv->serdes = serdes;
+ 	}
+ 
+ 	register_netdevice_notifier(&ocelot_netdevice_nb);
+--- a/drivers/net/ethernet/mscc/ocelot_flower.c
++++ b/drivers/net/ethernet/mscc/ocelot_flower.c
+@@ -10,7 +10,7 @@
+ 
+ struct ocelot_port_block {
+ 	struct ocelot_acl_block *block;
+-	struct ocelot_port *port;
++	struct ocelot_port_private *priv;
+ };
+ 
+ static int ocelot_flower_parse_action(struct flow_cls_offload *f,
+@@ -177,8 +177,8 @@ struct ocelot_ace_rule *ocelot_ace_rule_
+ 	if (!rule)
+ 		return NULL;
+ 
+-	rule->port = block->port;
+-	rule->chip_port = block->port->chip_port;
++	rule->port = &block->priv->port;
++	rule->chip_port = block->priv->chip_port;
+ 	return rule;
+ }
+ 
+@@ -202,7 +202,7 @@ static int ocelot_flower_replace(struct
+ 	if (ret)
+ 		return ret;
+ 
+-	port_block->port->tc.offload_cnt++;
++	port_block->priv->tc.offload_cnt++;
+ 	return 0;
+ }
+ 
+@@ -213,14 +213,14 @@ static int ocelot_flower_destroy(struct
+ 	int ret;
+ 
+ 	rule.prio = f->common.prio;
+-	rule.port = port_block->port;
++	rule.port = &port_block->priv->port;
+ 	rule.id = f->cookie;
+ 
+ 	ret = ocelot_ace_rule_offload_del(&rule);
+ 	if (ret)
+ 		return ret;
+ 
+-	port_block->port->tc.offload_cnt--;
++	port_block->priv->tc.offload_cnt--;
+ 	return 0;
+ }
+ 
+@@ -231,7 +231,7 @@ static int ocelot_flower_stats_update(st
+ 	int ret;
+ 
+ 	rule.prio = f->common.prio;
+-	rule.port = port_block->port;
++	rule.port = &port_block->priv->port;
+ 	rule.id = f->cookie;
+ 	ret = ocelot_ace_rule_stats_update(&rule);
+ 	if (ret)
+@@ -261,7 +261,7 @@ static int ocelot_setup_tc_block_cb_flow
+ {
+ 	struct ocelot_port_block *port_block = cb_priv;
+ 
+-	if (!tc_cls_can_offload_and_chain0(port_block->port->dev, type_data))
++	if (!tc_cls_can_offload_and_chain0(port_block->priv->dev, type_data))
+ 		return -EOPNOTSUPP;
+ 
+ 	switch (type) {
+@@ -275,7 +275,7 @@ static int ocelot_setup_tc_block_cb_flow
+ }
+ 
+ static struct ocelot_port_block*
+-ocelot_port_block_create(struct ocelot_port *port)
++ocelot_port_block_create(struct ocelot_port_private *priv)
+ {
+ 	struct ocelot_port_block *port_block;
+ 
+@@ -283,7 +283,7 @@ ocelot_port_block_create(struct ocelot_p
+ 	if (!port_block)
+ 		return NULL;
+ 
+-	port_block->port = port;
++	port_block->priv = priv;
+ 
+ 	return port_block;
+ }
+@@ -300,7 +300,7 @@ static void ocelot_tc_block_unbind(void
+ 	ocelot_port_block_destroy(port_block);
+ }
+ 
+-int ocelot_setup_tc_block_flower_bind(struct ocelot_port *port,
++int ocelot_setup_tc_block_flower_bind(struct ocelot_port_private *priv,
+ 				      struct flow_block_offload *f)
+ {
+ 	struct ocelot_port_block *port_block;
+@@ -311,14 +311,14 @@ int ocelot_setup_tc_block_flower_bind(st
+ 		return -EOPNOTSUPP;
+ 
+ 	block_cb = flow_block_cb_lookup(f->block,
+-					ocelot_setup_tc_block_cb_flower, port);
++					ocelot_setup_tc_block_cb_flower, priv);
+ 	if (!block_cb) {
+-		port_block = ocelot_port_block_create(port);
++		port_block = ocelot_port_block_create(priv);
+ 		if (!port_block)
+ 			return -ENOMEM;
+ 
+ 		block_cb = flow_block_cb_alloc(ocelot_setup_tc_block_cb_flower,
+-					       port, port_block,
++					       priv, port_block,
+ 					       ocelot_tc_block_unbind);
+ 		if (IS_ERR(block_cb)) {
+ 			ret = PTR_ERR(block_cb);
+@@ -339,13 +339,13 @@ err_cb_register:
+ 	return ret;
+ }
+ 
+-void ocelot_setup_tc_block_flower_unbind(struct ocelot_port *port,
++void ocelot_setup_tc_block_flower_unbind(struct ocelot_port_private *priv,
+ 					 struct flow_block_offload *f)
+ {
+ 	struct flow_block_cb *block_cb;
+ 
+ 	block_cb = flow_block_cb_lookup(f->block,
+-					ocelot_setup_tc_block_cb_flower, port);
++					ocelot_setup_tc_block_cb_flower, priv);
+ 	if (!block_cb)
+ 		return;
+ 
+--- a/drivers/net/ethernet/mscc/ocelot_tc.c
++++ b/drivers/net/ethernet/mscc/ocelot_tc.c
+@@ -9,17 +9,19 @@
+ #include "ocelot_ace.h"
+ #include <net/pkt_cls.h>
+ 
+-static int ocelot_setup_tc_cls_matchall(struct ocelot_port *port,
++static int ocelot_setup_tc_cls_matchall(struct ocelot_port_private *priv,
+ 					struct tc_cls_matchall_offload *f,
+ 					bool ingress)
+ {
+ 	struct netlink_ext_ack *extack = f->common.extack;
++	struct ocelot *ocelot = priv->port.ocelot;
+ 	struct ocelot_policer pol = { 0 };
+ 	struct flow_action_entry *action;
++	int port = priv->chip_port;
+ 	int err;
+ 
+-	netdev_dbg(port->dev, "%s: port %u command %d cookie %lu\n",
+-		   __func__, port->chip_port, f->command, f->cookie);
++	netdev_dbg(priv->dev, "%s: port %u command %d cookie %lu\n",
++		   __func__, port, f->command, f->cookie);
+ 
+ 	if (!ingress) {
+ 		NL_SET_ERR_MSG_MOD(extack, "Only ingress is supported");
+@@ -34,7 +36,7 @@ static int ocelot_setup_tc_cls_matchall(
+ 			return -EOPNOTSUPP;
+ 		}
+ 
+-		if (port->tc.block_shared) {
++		if (priv->tc.block_shared) {
+ 			NL_SET_ERR_MSG_MOD(extack,
+ 					   "Rate limit is not supported on shared blocks");
+ 			return -EOPNOTSUPP;
+@@ -47,7 +49,7 @@ static int ocelot_setup_tc_cls_matchall(
+ 			return -EOPNOTSUPP;
+ 		}
+ 
+-		if (port->tc.police_id && port->tc.police_id != f->cookie) {
++		if (priv->tc.police_id && priv->tc.police_id != f->cookie) {
+ 			NL_SET_ERR_MSG_MOD(extack,
+ 					   "Only one policer per port is supported\n");
+ 			return -EEXIST;
+@@ -58,28 +60,27 @@ static int ocelot_setup_tc_cls_matchall(
+ 					 PSCHED_NS2TICKS(action->police.burst),
+ 					 PSCHED_TICKS_PER_SEC);
+ 
+-		err = ocelot_port_policer_add(port->ocelot, port->chip_port,
+-					      &pol);
++		err = ocelot_port_policer_add(ocelot, port, &pol);
+ 		if (err) {
+ 			NL_SET_ERR_MSG_MOD(extack, "Could not add policer\n");
+ 			return err;
+ 		}
+ 
+-		port->tc.police_id = f->cookie;
+-		port->tc.offload_cnt++;
++		priv->tc.police_id = f->cookie;
++		priv->tc.offload_cnt++;
+ 		return 0;
+ 	case TC_CLSMATCHALL_DESTROY:
+-		if (port->tc.police_id != f->cookie)
++		if (priv->tc.police_id != f->cookie)
+ 			return -ENOENT;
+ 
+-		err = ocelot_port_policer_del(port->ocelot, port->chip_port);
++		err = ocelot_port_policer_del(ocelot, port);
+ 		if (err) {
+ 			NL_SET_ERR_MSG_MOD(extack,
+ 					   "Could not delete policer\n");
+ 			return err;
+ 		}
+-		port->tc.police_id = 0;
+-		port->tc.offload_cnt--;
++		priv->tc.police_id = 0;
++		priv->tc.offload_cnt--;
+ 		return 0;
+ 	case TC_CLSMATCHALL_STATS: /* fall through */
+ 	default:
+@@ -91,21 +92,21 @@ static int ocelot_setup_tc_block_cb(enum
+ 				    void *type_data,
+ 				    void *cb_priv, bool ingress)
+ {
+-	struct ocelot_port *port = cb_priv;
++	struct ocelot_port_private *priv = cb_priv;
+ 
+-	if (!tc_cls_can_offload_and_chain0(port->dev, type_data))
++	if (!tc_cls_can_offload_and_chain0(priv->dev, type_data))
+ 		return -EOPNOTSUPP;
+ 
+ 	switch (type) {
+ 	case TC_SETUP_CLSMATCHALL:
+-		netdev_dbg(port->dev, "tc_block_cb: TC_SETUP_CLSMATCHALL %s\n",
++		netdev_dbg(priv->dev, "tc_block_cb: TC_SETUP_CLSMATCHALL %s\n",
+ 			   ingress ? "ingress" : "egress");
+ 
+-		return ocelot_setup_tc_cls_matchall(port, type_data, ingress);
++		return ocelot_setup_tc_cls_matchall(priv, type_data, ingress);
+ 	case TC_SETUP_CLSFLOWER:
+ 		return 0;
+ 	default:
+-		netdev_dbg(port->dev, "tc_block_cb: type %d %s\n",
++		netdev_dbg(priv->dev, "tc_block_cb: type %d %s\n",
+ 			   type,
+ 			   ingress ? "ingress" : "egress");
+ 
+@@ -131,19 +132,19 @@ static int ocelot_setup_tc_block_cb_eg(e
+ 
+ static LIST_HEAD(ocelot_block_cb_list);
+ 
+-static int ocelot_setup_tc_block(struct ocelot_port *port,
++static int ocelot_setup_tc_block(struct ocelot_port_private *priv,
+ 				 struct flow_block_offload *f)
+ {
+ 	struct flow_block_cb *block_cb;
+ 	flow_setup_cb_t *cb;
+ 	int err;
+ 
+-	netdev_dbg(port->dev, "tc_block command %d, binder_type %d\n",
++	netdev_dbg(priv->dev, "tc_block command %d, binder_type %d\n",
+ 		   f->command, f->binder_type);
+ 
+ 	if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) {
+ 		cb = ocelot_setup_tc_block_cb_ig;
+-		port->tc.block_shared = f->block_shared;
++		priv->tc.block_shared = f->block_shared;
+ 	} else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) {
+ 		cb = ocelot_setup_tc_block_cb_eg;
+ 	} else {
+@@ -154,14 +155,14 @@ static int ocelot_setup_tc_block(struct
+ 
+ 	switch (f->command) {
+ 	case FLOW_BLOCK_BIND:
+-		if (flow_block_cb_is_busy(cb, port, &ocelot_block_cb_list))
++		if (flow_block_cb_is_busy(cb, priv, &ocelot_block_cb_list))
+ 			return -EBUSY;
+ 
+-		block_cb = flow_block_cb_alloc(cb, port, port, NULL);
++		block_cb = flow_block_cb_alloc(cb, priv, priv, NULL);
+ 		if (IS_ERR(block_cb))
+ 			return PTR_ERR(block_cb);
+ 
+-		err = ocelot_setup_tc_block_flower_bind(port, f);
++		err = ocelot_setup_tc_block_flower_bind(priv, f);
+ 		if (err < 0) {
+ 			flow_block_cb_free(block_cb);
+ 			return err;
+@@ -170,11 +171,11 @@ static int ocelot_setup_tc_block(struct
+ 		list_add_tail(&block_cb->driver_list, f->driver_block_list);
+ 		return 0;
+ 	case FLOW_BLOCK_UNBIND:
+-		block_cb = flow_block_cb_lookup(f->block, cb, port);
++		block_cb = flow_block_cb_lookup(f->block, cb, priv);
+ 		if (!block_cb)
+ 			return -ENOENT;
+ 
+-		ocelot_setup_tc_block_flower_unbind(port, f);
++		ocelot_setup_tc_block_flower_unbind(priv, f);
+ 		flow_block_cb_remove(block_cb, f);
+ 		list_del(&block_cb->driver_list);
+ 		return 0;
+@@ -186,11 +187,11 @@ static int ocelot_setup_tc_block(struct
+ int ocelot_setup_tc(struct net_device *dev, enum tc_setup_type type,
+ 		    void *type_data)
+ {
+-	struct ocelot_port *port = netdev_priv(dev);
++	struct ocelot_port_private *priv = netdev_priv(dev);
+ 
+ 	switch (type) {
+ 	case TC_SETUP_BLOCK:
+-		return ocelot_setup_tc_block(port, type_data);
++		return ocelot_setup_tc_block(priv, type_data);
+ 	default:
+ 		return -EOPNOTSUPP;
+ 	}