target/linux/layerscape/patches-5.4/701-net-0244-net-mscc-ocelot-separate-net_device-related-items-ou.patch

   1 From b0481fbc0d853fd164055293002c621827eba5ad Mon Sep 17 00:00:00 2001
   2 From: Vladimir Oltean <vladimir.oltean@nxp.com>
   3 Date: Sat, 9 Nov 2019 15:02:53 +0200
   4 Subject: [PATCH] net: mscc: ocelot: separate net_device related items out of
   5  ocelot_port
   6
   7 The ocelot and ocelot_port structures will be used by a new DSA driver,
   8 so the ocelot_board.c file will have to allocate and work with a private
   9 structure (ocelot_port_private), which embeds the generic struct
  10 ocelot_port. This is because in DSA, at least one interface does not
  11 have a net_device, and the DSA driver API does not interact with that
  12 anyway.
  13
  14 The ocelot_port structure is equivalent to dsa_port, and ocelot to
  15 dsa_switch. The members of ocelot_port which have an equivalent in
  16 dsa_port (such as dp->vlan_filtering) have been moved to
  17 ocelot_port_private.
  18
  19 We want to enforce the coding convention that "ocelot_port" refers to
  20 the structure, and "port" refers to the integer index. One can retrieve
  21 the structure at any time from ocelot->ports[port].
  22
  23 The patch is large but only contains variable renaming and mechanical
  24 movement of fields from one structure to another.
  25
  26 Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
  27 Signed-off-by: David S. Miller <davem@davemloft.net>
  28 ---
  29  drivers/net/ethernet/mscc/ocelot.c        | 288 ++++++++++++++++--------------
  30  drivers/net/ethernet/mscc/ocelot.h        |  21 ++-
  31  drivers/net/ethernet/mscc/ocelot_ace.h    |   4 +-
  32  drivers/net/ethernet/mscc/ocelot_board.c  |  25 ++-
  33  drivers/net/ethernet/mscc/ocelot_flower.c |  32 ++--
  34  drivers/net/ethernet/mscc/ocelot_tc.c     |  57 +++---
  35  6 files changed, 235 insertions(+), 192 deletions(-)
  36
  37 --- a/drivers/net/ethernet/mscc/ocelot.c
  38 +++ b/drivers/net/ethernet/mscc/ocelot.c
  39 @@ -229,8 +229,6 @@ static void ocelot_port_vlan_filtering(s
  40         ocelot_rmw_gix(ocelot, val,
  41                        REW_TAG_CFG_TAG_CFG_M,
  42                        REW_TAG_CFG, port);
  43 -
  44 -       ocelot_port->vlan_aware = vlan_aware;
  45  }
  46
  47  static int ocelot_port_set_native_vlan(struct ocelot *ocelot, int port,
  48 @@ -297,9 +295,10 @@ static int ocelot_vlan_add(struct ocelot
  49  static int ocelot_vlan_vid_add(struct net_device *dev, u16 vid, bool pvid,
  50                                bool untagged)
  51  {
  52 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
  53 +       struct ocelot_port_private *priv = netdev_priv(dev);
  54 +       struct ocelot_port *ocelot_port = &priv->port;
  55         struct ocelot *ocelot = ocelot_port->ocelot;
  56 -       int port = ocelot_port->chip_port;
  57 +       int port = priv->chip_port;
  58         int ret;
  59
  60         ret = ocelot_vlan_add(ocelot, port, vid, pvid, untagged);
  61 @@ -337,9 +336,9 @@ static int ocelot_vlan_del(struct ocelot
  62
  63  static int ocelot_vlan_vid_del(struct net_device *dev, u16 vid)
  64  {
  65 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
  66 -       struct ocelot *ocelot = ocelot_port->ocelot;
  67 -       int port = ocelot_port->chip_port;
  68 +       struct ocelot_port_private *priv = netdev_priv(dev);
  69 +       struct ocelot *ocelot = priv->port.ocelot;
  70 +       int port = priv->chip_port;
  71         int ret;
  72
  73         /* 8021q removes VID 0 on module unload for all interfaces
  74 @@ -412,10 +411,11 @@ static u16 ocelot_wm_enc(u16 value)
  75
  76  static void ocelot_port_adjust_link(struct net_device *dev)
  77  {
  78 -       struct ocelot_port *port = netdev_priv(dev);
  79 -       struct ocelot *ocelot = port->ocelot;
  80 -       u8 p = port->chip_port;
  81 +       struct ocelot_port_private *priv = netdev_priv(dev);
  82 +       struct ocelot_port *ocelot_port = &priv->port;
  83 +       struct ocelot *ocelot = ocelot_port->ocelot;
  84         int speed, atop_wm, mode = 0;
  85 +       u8 port = priv->chip_port;
  86
  87         switch (dev->phydev->speed) {
  88         case SPEED_10:
  89 @@ -444,62 +444,66 @@ static void ocelot_port_adjust_link(stru
  90                 return;
  91
  92         /* Only full duplex supported for now */
  93 -       ocelot_port_writel(port, DEV_MAC_MODE_CFG_FDX_ENA |
  94 +       ocelot_port_writel(ocelot_port, DEV_MAC_MODE_CFG_FDX_ENA |
  95                            mode, DEV_MAC_MODE_CFG);
  96
  97         /* Set MAC IFG Gaps
  98          * FDX: TX_IFG = 5, RX_IFG1 = RX_IFG2 = 0
  99          * !FDX: TX_IFG = 5, RX_IFG1 = RX_IFG2 = 5
 100          */
 101 -       ocelot_port_writel(port, DEV_MAC_IFG_CFG_TX_IFG(5), DEV_MAC_IFG_CFG);
 102 +       ocelot_port_writel(ocelot_port, DEV_MAC_IFG_CFG_TX_IFG(5),
 103 +                          DEV_MAC_IFG_CFG);
 104
 105         /* Load seed (0) and set MAC HDX late collision  */
 106 -       ocelot_port_writel(port, DEV_MAC_HDX_CFG_LATE_COL_POS(67) |
 107 +       ocelot_port_writel(ocelot_port, DEV_MAC_HDX_CFG_LATE_COL_POS(67) |
 108                            DEV_MAC_HDX_CFG_SEED_LOAD,
 109                            DEV_MAC_HDX_CFG);
 110         mdelay(1);
 111 -       ocelot_port_writel(port, DEV_MAC_HDX_CFG_LATE_COL_POS(67),
 112 +       ocelot_port_writel(ocelot_port, DEV_MAC_HDX_CFG_LATE_COL_POS(67),
 113                            DEV_MAC_HDX_CFG);
 114
 115         /* Disable HDX fast control */
 116 -       ocelot_port_writel(port, DEV_PORT_MISC_HDX_FAST_DIS, DEV_PORT_MISC);
 117 +       ocelot_port_writel(ocelot_port, DEV_PORT_MISC_HDX_FAST_DIS,
 118 +                          DEV_PORT_MISC);
 119
 120         /* SGMII only for now */
 121 -       ocelot_port_writel(port, PCS1G_MODE_CFG_SGMII_MODE_ENA, PCS1G_MODE_CFG);
 122 -       ocelot_port_writel(port, PCS1G_SD_CFG_SD_SEL, PCS1G_SD_CFG);
 123 +       ocelot_port_writel(ocelot_port, PCS1G_MODE_CFG_SGMII_MODE_ENA,
 124 +                          PCS1G_MODE_CFG);
 125 +       ocelot_port_writel(ocelot_port, PCS1G_SD_CFG_SD_SEL, PCS1G_SD_CFG);
 126
 127         /* Enable PCS */
 128 -       ocelot_port_writel(port, PCS1G_CFG_PCS_ENA, PCS1G_CFG);
 129 +       ocelot_port_writel(ocelot_port, PCS1G_CFG_PCS_ENA, PCS1G_CFG);
 130
 131         /* No aneg on SGMII */
 132 -       ocelot_port_writel(port, 0, PCS1G_ANEG_CFG);
 133 +       ocelot_port_writel(ocelot_port, 0, PCS1G_ANEG_CFG);
 134
 135         /* No loopback */
 136 -       ocelot_port_writel(port, 0, PCS1G_LB_CFG);
 137 +       ocelot_port_writel(ocelot_port, 0, PCS1G_LB_CFG);
 138
 139         /* Set Max Length and maximum tags allowed */
 140 -       ocelot_port_writel(port, VLAN_ETH_FRAME_LEN, DEV_MAC_MAXLEN_CFG);
 141 -       ocelot_port_writel(port, DEV_MAC_TAGS_CFG_TAG_ID(ETH_P_8021AD) |
 142 +       ocelot_port_writel(ocelot_port, VLAN_ETH_FRAME_LEN,
 143 +                          DEV_MAC_MAXLEN_CFG);
 144 +       ocelot_port_writel(ocelot_port, DEV_MAC_TAGS_CFG_TAG_ID(ETH_P_8021AD) |
 145                            DEV_MAC_TAGS_CFG_VLAN_AWR_ENA |
 146                            DEV_MAC_TAGS_CFG_VLAN_LEN_AWR_ENA,
 147                            DEV_MAC_TAGS_CFG);
 148
 149         /* Enable MAC module */
 150 -       ocelot_port_writel(port, DEV_MAC_ENA_CFG_RX_ENA |
 151 +       ocelot_port_writel(ocelot_port, DEV_MAC_ENA_CFG_RX_ENA |
 152                            DEV_MAC_ENA_CFG_TX_ENA, DEV_MAC_ENA_CFG);
 153
 154         /* Take MAC, Port, Phy (intern) and PCS (SGMII/Serdes) clock out of
 155          * reset */
 156 -       ocelot_port_writel(port, DEV_CLOCK_CFG_LINK_SPEED(speed),
 157 +       ocelot_port_writel(ocelot_port, DEV_CLOCK_CFG_LINK_SPEED(speed),
 158                            DEV_CLOCK_CFG);
 159
 160         /* Set SMAC of Pause frame (00:00:00:00:00:00) */
 161 -       ocelot_port_writel(port, 0, DEV_MAC_FC_MAC_HIGH_CFG);
 162 -       ocelot_port_writel(port, 0, DEV_MAC_FC_MAC_LOW_CFG);
 163 +       ocelot_port_writel(ocelot_port, 0, DEV_MAC_FC_MAC_HIGH_CFG);
 164 +       ocelot_port_writel(ocelot_port, 0, DEV_MAC_FC_MAC_LOW_CFG);
 165
 166         /* No PFC */
 167         ocelot_write_gix(ocelot, ANA_PFC_PFC_CFG_FC_LINK_SPEED(speed),
 168 -                        ANA_PFC_PFC_CFG, p);
 169 +                        ANA_PFC_PFC_CFG, port);
 170
 171         /* Set Pause WM hysteresis
 172          * 152 = 6 * VLAN_ETH_FRAME_LEN / OCELOT_BUFFER_CELL_SZ
 173 @@ -507,13 +511,13 @@ static void ocelot_port_adjust_link(stru
 174          */
 175         ocelot_write_rix(ocelot, SYS_PAUSE_CFG_PAUSE_ENA |
 176                          SYS_PAUSE_CFG_PAUSE_STOP(101) |
 177 -                        SYS_PAUSE_CFG_PAUSE_START(152), SYS_PAUSE_CFG, p);
 178 +                        SYS_PAUSE_CFG_PAUSE_START(152), SYS_PAUSE_CFG, port);
 179
 180         /* Core: Enable port for frame transfer */
 181         ocelot_write_rix(ocelot, QSYS_SWITCH_PORT_MODE_INGRESS_DROP_MODE |
 182                          QSYS_SWITCH_PORT_MODE_SCH_NEXT_CFG(1) |
 183                          QSYS_SWITCH_PORT_MODE_PORT_ENA,
 184 -                        QSYS_SWITCH_PORT_MODE, p);
 185 +                        QSYS_SWITCH_PORT_MODE, port);
 186
 187         /* Flow control */
 188         ocelot_write_rix(ocelot, SYS_MAC_FC_CFG_PAUSE_VAL_CFG(0xffff) |
 189 @@ -521,20 +525,21 @@ static void ocelot_port_adjust_link(stru
 190                          SYS_MAC_FC_CFG_ZERO_PAUSE_ENA |
 191                          SYS_MAC_FC_CFG_FC_LATENCY_CFG(0x7) |
 192                          SYS_MAC_FC_CFG_FC_LINK_SPEED(speed),
 193 -                        SYS_MAC_FC_CFG, p);
 194 -       ocelot_write_rix(ocelot, 0, ANA_POL_FLOWC, p);
 195 +                        SYS_MAC_FC_CFG, port);
 196 +       ocelot_write_rix(ocelot, 0, ANA_POL_FLOWC, port);
 197
 198         /* Tail dropping watermark */
 199         atop_wm = (ocelot->shared_queue_sz - 9 * VLAN_ETH_FRAME_LEN) / OCELOT_BUFFER_CELL_SZ;
 200         ocelot_write_rix(ocelot, ocelot_wm_enc(9 * VLAN_ETH_FRAME_LEN),
 201 -                        SYS_ATOP, p);
 202 +                        SYS_ATOP, port);
 203         ocelot_write(ocelot, ocelot_wm_enc(atop_wm), SYS_ATOP_TOT_CFG);
 204  }
 205
 206  static int ocelot_port_open(struct net_device *dev)
 207  {
 208 -       struct ocelot_port *port = netdev_priv(dev);
 209 -       struct ocelot *ocelot = port->ocelot;
 210 +       struct ocelot_port_private *priv = netdev_priv(dev);
 211 +       struct ocelot *ocelot = priv->port.ocelot;
 212 +       int port = priv->chip_port;
 213         int err;
 214
 215         /* Enable receiving frames on the port, and activate auto-learning of
 216 @@ -542,43 +547,44 @@ static int ocelot_port_open(struct net_d
 217          */
 218         ocelot_write_gix(ocelot, ANA_PORT_PORT_CFG_LEARNAUTO |
 219                          ANA_PORT_PORT_CFG_RECV_ENA |
 220 -                        ANA_PORT_PORT_CFG_PORTID_VAL(port->chip_port),
 221 -                        ANA_PORT_PORT_CFG, port->chip_port);
 222 +                        ANA_PORT_PORT_CFG_PORTID_VAL(port),
 223 +                        ANA_PORT_PORT_CFG, port);
 224
 225 -       if (port->serdes) {
 226 -               err = phy_set_mode_ext(port->serdes, PHY_MODE_ETHERNET,
 227 -                                      port->phy_mode);
 228 +       if (priv->serdes) {
 229 +               err = phy_set_mode_ext(priv->serdes, PHY_MODE_ETHERNET,
 230 +                                      priv->phy_mode);
 231                 if (err) {
 232                         netdev_err(dev, "Could not set mode of SerDes\n");
 233                         return err;
 234                 }
 235         }
 236
 237 -       err = phy_connect_direct(dev, port->phy, &ocelot_port_adjust_link,
 238 -                                port->phy_mode);
 239 +       err = phy_connect_direct(dev, priv->phy, &ocelot_port_adjust_link,
 240 +                                priv->phy_mode);
 241         if (err) {
 242                 netdev_err(dev, "Could not attach to PHY\n");
 243                 return err;
 244         }
 245
 246 -       dev->phydev = port->phy;
 247 +       dev->phydev = priv->phy;
 248
 249 -       phy_attached_info(port->phy);
 250 -       phy_start(port->phy);
 251 +       phy_attached_info(priv->phy);
 252 +       phy_start(priv->phy);
 253         return 0;
 254  }
 255
 256  static int ocelot_port_stop(struct net_device *dev)
 257  {
 258 -       struct ocelot_port *port = netdev_priv(dev);
 259 +       struct ocelot_port_private *priv = netdev_priv(dev);
 260 +       struct ocelot_port *port = &priv->port;
 261
 262 -       phy_disconnect(port->phy);
 263 +       phy_disconnect(priv->phy);
 264
 265         dev->phydev = NULL;
 266
 267         ocelot_port_writel(port, 0, DEV_MAC_ENA_CFG);
 268         ocelot_rmw_rix(port->ocelot, 0, QSYS_SWITCH_PORT_MODE_PORT_ENA,
 269 -                        QSYS_SWITCH_PORT_MODE, port->chip_port);
 270 +                      QSYS_SWITCH_PORT_MODE, priv->chip_port);
 271         return 0;
 272  }
 273
 274 @@ -604,13 +610,15 @@ static int ocelot_gen_ifh(u32 *ifh, stru
 275
 276  static int ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev)
 277  {
 278 +       struct ocelot_port_private *priv = netdev_priv(dev);
 279         struct skb_shared_info *shinfo = skb_shinfo(skb);
 280 -       struct ocelot_port *port = netdev_priv(dev);
 281 -       struct ocelot *ocelot = port->ocelot;
 282 -       u32 val, ifh[IFH_LEN];
 283 +       struct ocelot_port *ocelot_port = &priv->port;
 284 +       struct ocelot *ocelot = ocelot_port->ocelot;
 285         struct frame_info info = {};
 286         u8 grp = 0; /* Send everything on CPU group 0 */
 287         unsigned int i, count, last;
 288 +       int port = priv->chip_port;
 289 +       u32 val, ifh[IFH_LEN];
 290
 291         val = ocelot_read(ocelot, QS_INJ_STATUS);
 292         if (!(val & QS_INJ_STATUS_FIFO_RDY(BIT(grp))) ||
 293 @@ -620,15 +628,15 @@ static int ocelot_port_xmit(struct sk_bu
 294         ocelot_write_rix(ocelot, QS_INJ_CTRL_GAP_SIZE(1) |
 295                          QS_INJ_CTRL_SOF, QS_INJ_CTRL, grp);
 296
 297 -       info.port = BIT(port->chip_port);
 298 +       info.port = BIT(port);
 299         info.tag_type = IFH_TAG_TYPE_C;
 300         info.vid = skb_vlan_tag_get(skb);
 301
 302         /* Check if timestamping is needed */
 303         if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP) {
 304 -               info.rew_op = port->ptp_cmd;
 305 -               if (port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
 306 -                       info.rew_op |= (port->ts_id  % 4) << 3;
 307 +               info.rew_op = ocelot_port->ptp_cmd;
 308 +               if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
 309 +                       info.rew_op |= (ocelot_port->ts_id  % 4) << 3;
 310         }
 311
 312         ocelot_gen_ifh(ifh, &info);
 313 @@ -663,7 +671,7 @@ static int ocelot_port_xmit(struct sk_bu
 314         dev->stats.tx_bytes += skb->len;
 315
 316         if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP &&
 317 -           port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
 318 +           ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
 319                 struct ocelot_skb *oskb =
 320                         kzalloc(sizeof(struct ocelot_skb), GFP_ATOMIC);
 321
 322 @@ -673,10 +681,10 @@ static int ocelot_port_xmit(struct sk_bu
 323                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
 324
 325                 oskb->skb = skb;
 326 -               oskb->id = port->ts_id % 4;
 327 -               port->ts_id++;
 328 +               oskb->id = ocelot_port->ts_id % 4;
 329 +               ocelot_port->ts_id++;
 330
 331 -               list_add_tail(&oskb->head, &port->skbs);
 332 +               list_add_tail(&oskb->head, &ocelot_port->skbs);
 333
 334                 return NETDEV_TX_OK;
 335         }
 336 @@ -715,25 +723,29 @@ EXPORT_SYMBOL(ocelot_get_hwtimestamp);
 337
 338  static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr)
 339  {
 340 -       struct ocelot_port *port = netdev_priv(dev);
 341 +       struct ocelot_port_private *priv = netdev_priv(dev);
 342 +       struct ocelot_port *ocelot_port = &priv->port;
 343 +       struct ocelot *ocelot = ocelot_port->ocelot;
 344
 345 -       return ocelot_mact_forget(port->ocelot, addr, port->pvid);
 346 +       return ocelot_mact_forget(ocelot, addr, ocelot_port->pvid);
 347  }
 348
 349  static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr)
 350  {
 351 -       struct ocelot_port *port = netdev_priv(dev);
 352 +       struct ocelot_port_private *priv = netdev_priv(dev);
 353 +       struct ocelot_port *ocelot_port = &priv->port;
 354 +       struct ocelot *ocelot = ocelot_port->ocelot;
 355
 356 -       return ocelot_mact_learn(port->ocelot, PGID_CPU, addr, port->pvid,
 357 +       return ocelot_mact_learn(ocelot, PGID_CPU, addr, ocelot_port->pvid,
 358                                  ENTRYTYPE_LOCKED);
 359  }
 360
 361  static void ocelot_set_rx_mode(struct net_device *dev)
 362  {
 363 -       struct ocelot_port *port = netdev_priv(dev);
 364 -       struct ocelot *ocelot = port->ocelot;
 365 -       int i;
 366 +       struct ocelot_port_private *priv = netdev_priv(dev);
 367 +       struct ocelot *ocelot = priv->port.ocelot;
 368         u32 val;
 369 +       int i;
 370
 371         /* This doesn't handle promiscuous mode because the bridge core is
 372          * setting IFF_PROMISC on all slave interfaces and all frames would be
 373 @@ -749,10 +761,11 @@ static void ocelot_set_rx_mode(struct ne
 374  static int ocelot_port_get_phys_port_name(struct net_device *dev,
 375                                           char *buf, size_t len)
 376  {
 377 -       struct ocelot_port *port = netdev_priv(dev);
 378 +       struct ocelot_port_private *priv = netdev_priv(dev);
 379 +       int port = priv->chip_port;
 380         int ret;
 381
 382 -       ret = snprintf(buf, len, "p%d", port->chip_port);
 383 +       ret = snprintf(buf, len, "p%d", port);
 384         if (ret >= len)
 385                 return -EINVAL;
 386
 387 @@ -761,15 +774,16 @@ static int ocelot_port_get_phys_port_nam
 388
 389  static int ocelot_port_set_mac_address(struct net_device *dev, void *p)
 390  {
 391 -       struct ocelot_port *port = netdev_priv(dev);
 392 -       struct ocelot *ocelot = port->ocelot;
 393 +       struct ocelot_port_private *priv = netdev_priv(dev);
 394 +       struct ocelot_port *ocelot_port = &priv->port;
 395 +       struct ocelot *ocelot = ocelot_port->ocelot;
 396         const struct sockaddr *addr = p;
 397
 398         /* Learn the new net device MAC address in the mac table. */
 399 -       ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data, port->pvid,
 400 +       ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data, ocelot_port->pvid,
 401                           ENTRYTYPE_LOCKED);
 402         /* Then forget the previous one. */
 403 -       ocelot_mact_forget(ocelot, dev->dev_addr, port->pvid);
 404 +       ocelot_mact_forget(ocelot, dev->dev_addr, ocelot_port->pvid);
 405
 406         ether_addr_copy(dev->dev_addr, addr->sa_data);
 407         return 0;
 408 @@ -778,11 +792,12 @@ static int ocelot_port_set_mac_address(s
 409  static void ocelot_get_stats64(struct net_device *dev,
 410                                struct rtnl_link_stats64 *stats)
 411  {
 412 -       struct ocelot_port *port = netdev_priv(dev);
 413 -       struct ocelot *ocelot = port->ocelot;
 414 +       struct ocelot_port_private *priv = netdev_priv(dev);
 415 +       struct ocelot *ocelot = priv->port.ocelot;
 416 +       int port = priv->chip_port;
 417
 418         /* Configure the port to read the stats from */
 419 -       ocelot_write(ocelot, SYS_STAT_CFG_STAT_VIEW(port->chip_port),
 420 +       ocelot_write(ocelot, SYS_STAT_CFG_STAT_VIEW(port),
 421                      SYS_STAT_CFG);
 422
 423         /* Get Rx stats */
 424 @@ -814,12 +829,13 @@ static void ocelot_get_stats64(struct ne
 425  }
 426
 427  static int ocelot_fdb_add(struct ocelot *ocelot, int port,
 428 -                         const unsigned char *addr, u16 vid)
 429 +                         const unsigned char *addr, u16 vid,
 430 +                         bool vlan_aware)
 431  {
 432         struct ocelot_port *ocelot_port = ocelot->ports[port];
 433
 434         if (!vid) {
 435 -               if (!ocelot_port->vlan_aware)
 436 +               if (!vlan_aware)
 437                         /* If the bridge is not VLAN aware and no VID was
 438                          * provided, set it to pvid to ensure the MAC entry
 439                          * matches incoming untagged packets
 440 @@ -841,10 +857,11 @@ static int ocelot_port_fdb_add(struct nd
 441                                u16 vid, u16 flags,
 442                                struct netlink_ext_ack *extack)
 443  {
 444 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 445 -       struct ocelot *ocelot = ocelot_port->ocelot;
 446 +       struct ocelot_port_private *priv = netdev_priv(dev);
 447 +       struct ocelot *ocelot = priv->port.ocelot;
 448 +       int port = priv->chip_port;
 449
 450 -       return ocelot_fdb_add(ocelot, ocelot_port->chip_port, addr, vid);
 451 +       return ocelot_fdb_add(ocelot, port, addr, vid, priv->vlan_aware);
 452  }
 453
 454  static int ocelot_fdb_del(struct ocelot *ocelot, int port,
 455 @@ -857,10 +874,11 @@ static int ocelot_port_fdb_del(struct nd
 456                                struct net_device *dev,
 457                                const unsigned char *addr, u16 vid)
 458  {
 459 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 460 -       struct ocelot *ocelot = ocelot_port->ocelot;
 461 +       struct ocelot_port_private *priv = netdev_priv(dev);
 462 +       struct ocelot *ocelot = priv->port.ocelot;
 463 +       int port = priv->chip_port;
 464
 465 -       return ocelot_fdb_del(ocelot, ocelot_port->chip_port, addr, vid);
 466 +       return ocelot_fdb_del(ocelot, port, addr, vid);
 467  }
 468
 469  struct ocelot_dump_ctx {
 470 @@ -999,18 +1017,18 @@ static int ocelot_port_fdb_dump(struct s
 471                                 struct net_device *dev,
 472                                 struct net_device *filter_dev, int *idx)
 473  {
 474 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 475 -       struct ocelot *ocelot = ocelot_port->ocelot;
 476 +       struct ocelot_port_private *priv = netdev_priv(dev);
 477 +       struct ocelot *ocelot = priv->port.ocelot;
 478         struct ocelot_dump_ctx dump = {
 479                 .dev = dev,
 480                 .skb = skb,
 481                 .cb = cb,
 482                 .idx = *idx,
 483         };
 484 +       int port = priv->chip_port;
 485         int ret;
 486
 487 -       ret = ocelot_fdb_dump(ocelot, ocelot_port->chip_port,
 488 -                             ocelot_port_fdb_do_dump, &dump);
 489 +       ret = ocelot_fdb_dump(ocelot, port, ocelot_port_fdb_do_dump, &dump);
 490
 491         *idx = dump.idx;
 492
 493 @@ -1033,12 +1051,12 @@ static int ocelot_set_features(struct ne
 494                                netdev_features_t features)
 495  {
 496         netdev_features_t changed = dev->features ^ features;
 497 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 498 -       struct ocelot *ocelot = ocelot_port->ocelot;
 499 -       int port = ocelot_port->chip_port;
 500 +       struct ocelot_port_private *priv = netdev_priv(dev);
 501 +       struct ocelot *ocelot = priv->port.ocelot;
 502 +       int port = priv->chip_port;
 503
 504         if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) &&
 505 -           ocelot_port->tc.offload_cnt) {
 506 +           priv->tc.offload_cnt) {
 507                 netdev_err(dev,
 508                            "Cannot disable HW TC offload while offloads active\n");
 509                 return -EBUSY;
 510 @@ -1053,8 +1071,8 @@ static int ocelot_set_features(struct ne
 511  static int ocelot_get_port_parent_id(struct net_device *dev,
 512                                      struct netdev_phys_item_id *ppid)
 513  {
 514 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 515 -       struct ocelot *ocelot = ocelot_port->ocelot;
 516 +       struct ocelot_port_private *priv = netdev_priv(dev);
 517 +       struct ocelot *ocelot = priv->port.ocelot;
 518
 519         ppid->id_len = sizeof(ocelot->base_mac);
 520         memcpy(&ppid->id, &ocelot->base_mac, ppid->id_len);
 521 @@ -1136,9 +1154,9 @@ static int ocelot_hwstamp_set(struct oce
 522
 523  static int ocelot_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 524  {
 525 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 526 -       struct ocelot *ocelot = ocelot_port->ocelot;
 527 -       int port = ocelot_port->chip_port;
 528 +       struct ocelot_port_private *priv = netdev_priv(dev);
 529 +       struct ocelot *ocelot = priv->port.ocelot;
 530 +       int port = priv->chip_port;
 531
 532         /* The function is only used for PTP operations for now */
 533         if (!ocelot->ptp)
 534 @@ -1175,8 +1193,8 @@ static const struct net_device_ops ocelo
 535
 536  static void ocelot_get_strings(struct net_device *netdev, u32 sset, u8 *data)
 537  {
 538 -       struct ocelot_port *port = netdev_priv(netdev);
 539 -       struct ocelot *ocelot = port->ocelot;
 540 +       struct ocelot_port_private *priv = netdev_priv(netdev);
 541 +       struct ocelot *ocelot = priv->port.ocelot;
 542         int i;
 543
 544         if (sset != ETH_SS_STATS)
 545 @@ -1230,8 +1248,9 @@ static void ocelot_check_stats_work(stru
 546  static void ocelot_get_ethtool_stats(struct net_device *dev,
 547                                      struct ethtool_stats *stats, u64 *data)
 548  {
 549 -       struct ocelot_port *port = netdev_priv(dev);
 550 -       struct ocelot *ocelot = port->ocelot;
 551 +       struct ocelot_port_private *priv = netdev_priv(dev);
 552 +       struct ocelot *ocelot = priv->port.ocelot;
 553 +       int port = priv->chip_port;
 554         int i;
 555
 556         /* check and update now */
 557 @@ -1239,13 +1258,13 @@ static void ocelot_get_ethtool_stats(str
 558
 559         /* Copy all counters */
 560         for (i = 0; i < ocelot->num_stats; i++)
 561 -               *data++ = ocelot->stats[port->chip_port * ocelot->num_stats + i];
 562 +               *data++ = ocelot->stats[port * ocelot->num_stats + i];
 563  }
 564
 565  static int ocelot_get_sset_count(struct net_device *dev, int sset)
 566  {
 567 -       struct ocelot_port *port = netdev_priv(dev);
 568 -       struct ocelot *ocelot = port->ocelot;
 569 +       struct ocelot_port_private *priv = netdev_priv(dev);
 570 +       struct ocelot *ocelot = priv->port.ocelot;
 571
 572         if (sset != ETH_SS_STATS)
 573                 return -EOPNOTSUPP;
 574 @@ -1255,8 +1274,8 @@ static int ocelot_get_sset_count(struct
 575  static int ocelot_get_ts_info(struct net_device *dev,
 576                               struct ethtool_ts_info *info)
 577  {
 578 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 579 -       struct ocelot *ocelot = ocelot_port->ocelot;
 580 +       struct ocelot_port_private *priv = netdev_priv(dev);
 581 +       struct ocelot *ocelot = priv->port.ocelot;
 582
 583         if (!ocelot->ptp)
 584                 return ethtool_op_get_ts_info(dev, info);
 585 @@ -1388,9 +1407,9 @@ static int ocelot_port_attr_set(struct n
 586                                 const struct switchdev_attr *attr,
 587                                 struct switchdev_trans *trans)
 588  {
 589 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 590 -       struct ocelot *ocelot = ocelot_port->ocelot;
 591 -       int port = ocelot_port->chip_port;
 592 +       struct ocelot_port_private *priv = netdev_priv(dev);
 593 +       struct ocelot *ocelot = priv->port.ocelot;
 594 +       int port = priv->chip_port;
 595         int err = 0;
 596
 597         switch (attr->id) {
 598 @@ -1402,8 +1421,8 @@ static int ocelot_port_attr_set(struct n
 599                 ocelot_port_attr_ageing_set(ocelot, port, attr->u.ageing_time);
 600                 break;
 601         case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
 602 -               ocelot_port_vlan_filtering(ocelot, port,
 603 -                                          attr->u.vlan_filtering);
 604 +               priv->vlan_aware = attr->u.vlan_filtering;
 605 +               ocelot_port_vlan_filtering(ocelot, port, priv->vlan_aware);
 606                 break;
 607         case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
 608                 ocelot_port_attr_mc_set(ocelot, port, !attr->u.mc_disabled);
 609 @@ -1468,15 +1487,17 @@ static int ocelot_port_obj_add_mdb(struc
 610                                    const struct switchdev_obj_port_mdb *mdb,
 611                                    struct switchdev_trans *trans)
 612  {
 613 -       struct ocelot_port *port = netdev_priv(dev);
 614 -       struct ocelot *ocelot = port->ocelot;
 615 -       struct ocelot_multicast *mc;
 616 +       struct ocelot_port_private *priv = netdev_priv(dev);
 617 +       struct ocelot_port *ocelot_port = &priv->port;
 618 +       struct ocelot *ocelot = ocelot_port->ocelot;
 619         unsigned char addr[ETH_ALEN];
 620 +       struct ocelot_multicast *mc;
 621 +       int port = priv->chip_port;
 622         u16 vid = mdb->vid;
 623         bool new = false;
 624
 625         if (!vid)
 626 -               vid = port->pvid;
 627 +               vid = ocelot_port->pvid;
 628
 629         mc = ocelot_multicast_get(ocelot, mdb->addr, vid);
 630         if (!mc) {
 631 @@ -1500,7 +1521,7 @@ static int ocelot_port_obj_add_mdb(struc
 632                 ocelot_mact_forget(ocelot, addr, vid);
 633         }
 634
 635 -       mc->ports |= BIT(port->chip_port);
 636 +       mc->ports |= BIT(port);
 637         addr[2] = mc->ports << 0;
 638         addr[1] = mc->ports << 8;
 639
 640 @@ -1510,14 +1531,16 @@ static int ocelot_port_obj_add_mdb(struc
 641  static int ocelot_port_obj_del_mdb(struct net_device *dev,
 642                                    const struct switchdev_obj_port_mdb *mdb)
 643  {
 644 -       struct ocelot_port *port = netdev_priv(dev);
 645 -       struct ocelot *ocelot = port->ocelot;
 646 -       struct ocelot_multicast *mc;
 647 +       struct ocelot_port_private *priv = netdev_priv(dev);
 648 +       struct ocelot_port *ocelot_port = &priv->port;
 649 +       struct ocelot *ocelot = ocelot_port->ocelot;
 650         unsigned char addr[ETH_ALEN];
 651 +       struct ocelot_multicast *mc;
 652 +       int port = priv->chip_port;
 653         u16 vid = mdb->vid;
 654
 655         if (!vid)
 656 -               vid = port->pvid;
 657 +               vid = ocelot_port->pvid;
 658
 659         mc = ocelot_multicast_get(ocelot, mdb->addr, vid);
 660         if (!mc)
 661 @@ -1529,7 +1552,7 @@ static int ocelot_port_obj_del_mdb(struc
 662         addr[0] = 0;
 663         ocelot_mact_forget(ocelot, addr, vid);
 664
 665 -       mc->ports &= ~BIT(port->chip_port);
 666 +       mc->ports &= ~BIT(port);
 667         if (!mc->ports) {
 668                 list_del(&mc->list);
 669                 devm_kfree(ocelot->dev, mc);
 670 @@ -1683,9 +1706,9 @@ static int ocelot_port_lag_join(struct o
 671
 672         rcu_read_lock();
 673         for_each_netdev_in_bond_rcu(bond, ndev) {
 674 -               struct ocelot_port *port = netdev_priv(ndev);
 675 +               struct ocelot_port_private *priv = netdev_priv(ndev);
 676
 677 -               bond_mask |= BIT(port->chip_port);
 678 +               bond_mask |= BIT(priv->chip_port);
 679         }
 680         rcu_read_unlock();
 681
 682 @@ -1753,20 +1776,23 @@ static int ocelot_netdevice_port_event(s
 683                                        unsigned long event,
 684                                        struct netdev_notifier_changeupper_info *info)
 685  {
 686 -       struct ocelot_port *ocelot_port = netdev_priv(dev);
 687 +       struct ocelot_port_private *priv = netdev_priv(dev);
 688 +       struct ocelot_port *ocelot_port = &priv->port;
 689         struct ocelot *ocelot = ocelot_port->ocelot;
 690 -       int port = ocelot_port->chip_port;
 691 +       int port = priv->chip_port;
 692         int err = 0;
 693
 694         switch (event) {
 695         case NETDEV_CHANGEUPPER:
 696                 if (netif_is_bridge_master(info->upper_dev)) {
 697 -                       if (info->linking)
 698 +                       if (info->linking) {
 699                                 err = ocelot_port_bridge_join(ocelot, port,
 700                                                               info->upper_dev);
 701 -                       else
 702 +                       } else {
 703                                 err = ocelot_port_bridge_leave(ocelot, port,
 704                                                                info->upper_dev);
 705 +                               priv->vlan_aware = false;
 706 +                       }
 707                 }
 708                 if (netif_is_lag_master(info->upper_dev)) {
 709                         if (info->linking)
 710 @@ -2084,21 +2110,23 @@ int ocelot_probe_port(struct ocelot *oce
 711                       void __iomem *regs,
 712                       struct phy_device *phy)
 713  {
 714 +       struct ocelot_port_private *priv;
 715         struct ocelot_port *ocelot_port;
 716         struct net_device *dev;
 717         u32 val;
 718         int err;
 719
 720 -       dev = alloc_etherdev(sizeof(struct ocelot_port));
 721 +       dev = alloc_etherdev(sizeof(struct ocelot_port_private));
 722         if (!dev)
 723                 return -ENOMEM;
 724         SET_NETDEV_DEV(dev, ocelot->dev);
 725 -       ocelot_port = netdev_priv(dev);
 726 -       ocelot_port->dev = dev;
 727 +       priv = netdev_priv(dev);
 728 +       priv->dev = dev;
 729 +       priv->phy = phy;
 730 +       priv->chip_port = port;
 731 +       ocelot_port = &priv->port;
 732         ocelot_port->ocelot = ocelot;
 733         ocelot_port->regs = regs;
 734 -       ocelot_port->chip_port = port;
 735 -       ocelot_port->phy = phy;
 736         ocelot->ports[port] = ocelot_port;
 737
 738         dev->netdev_ops = &ocelot_port_netdev_ops;
 739 --- a/drivers/net/ethernet/mscc/ocelot.h
 740 +++ b/drivers/net/ethernet/mscc/ocelot.h
 741 @@ -479,11 +479,9 @@ struct ocelot {
 742  };
 743
 744  struct ocelot_port {
 745 -       struct net_device *dev;
 746         struct ocelot *ocelot;
 747 -       struct phy_device *phy;
 748 +
 749         void __iomem *regs;
 750 -       u8 chip_port;
 751
 752         /* Ingress default VLAN (pvid) */
 753         u16 pvid;
 754 @@ -491,18 +489,23 @@ struct ocelot_port {
 755         /* Egress default VLAN (vid) */
 756         u16 vid;
 757
 758 -       u8 vlan_aware;
 759 +       u8 ptp_cmd;
 760 +       struct list_head skbs;
 761 +       u8 ts_id;
 762 +};
 763
 764 -       u64 *stats;
 765 +struct ocelot_port_private {
 766 +       struct ocelot_port port;
 767 +       struct net_device *dev;
 768 +       struct phy_device *phy;
 769 +       u8 chip_port;
 770 +
 771 +       u8 vlan_aware;
 772
 773         phy_interface_t phy_mode;
 774         struct phy *serdes;
 775
 776         struct ocelot_port_tc tc;
 777 -
 778 -       u8 ptp_cmd;
 779 -       struct list_head skbs;
 780 -       u8 ts_id;
 781  };
 782
 783  struct ocelot_skb {
 784 --- a/drivers/net/ethernet/mscc/ocelot_ace.h
 785 +++ b/drivers/net/ethernet/mscc/ocelot_ace.h
 786 @@ -224,9 +224,9 @@ int ocelot_ace_rule_stats_update(struct
 787  int ocelot_ace_init(struct ocelot *ocelot);
 788  void ocelot_ace_deinit(void);
 789
 790 -int ocelot_setup_tc_block_flower_bind(struct ocelot_port *port,
 791 +int ocelot_setup_tc_block_flower_bind(struct ocelot_port_private *priv,
 792                                       struct flow_block_offload *f);
 793 -void ocelot_setup_tc_block_flower_unbind(struct ocelot_port *port,
 794 +void ocelot_setup_tc_block_flower_unbind(struct ocelot_port_private *priv,
 795                                          struct flow_block_offload *f);
 796
 797  #endif /* _MSCC_OCELOT_ACE_H_ */
 798 --- a/drivers/net/ethernet/mscc/ocelot_board.c
 799 +++ b/drivers/net/ethernet/mscc/ocelot_board.c
 800 @@ -95,6 +95,8 @@ static irqreturn_t ocelot_xtr_irq_handle
 801
 802         do {
 803                 struct skb_shared_hwtstamps *shhwtstamps;
 804 +               struct ocelot_port_private *priv;
 805 +               struct ocelot_port *ocelot_port;
 806                 u64 tod_in_ns, full_ts_in_ns;
 807                 struct frame_info info = {};
 808                 struct net_device *dev;
 809 @@ -122,7 +124,10 @@ static irqreturn_t ocelot_xtr_irq_handle
 810
 811                 ocelot_parse_ifh(ifh, &info);
 812
 813 -               dev = ocelot->ports[info.port]->dev;
 814 +               ocelot_port = ocelot->ports[info.port];
 815 +               priv = container_of(ocelot_port, struct ocelot_port_private,
 816 +                                   port);
 817 +               dev = priv->dev;
 818
 819                 skb = netdev_alloc_skb(dev, info.len);
 820
 821 @@ -371,6 +376,8 @@ static int mscc_ocelot_probe(struct plat
 822         ocelot_init(ocelot);
 823
 824         for_each_available_child_of_node(ports, portnp) {
 825 +               struct ocelot_port_private *priv;
 826 +               struct ocelot_port *ocelot_port;
 827                 struct device_node *phy_node;
 828                 struct phy_device *phy;
 829                 struct resource *res;
 830 @@ -406,13 +413,17 @@ static int mscc_ocelot_probe(struct plat
 831                         goto out_put_ports;
 832                 }
 833
 834 +               ocelot_port = ocelot->ports[port];
 835 +               priv = container_of(ocelot_port, struct ocelot_port_private,
 836 +                                   port);
 837 +
 838                 phy_mode = of_get_phy_mode(portnp);
 839                 if (phy_mode < 0)
 840 -                       ocelot->ports[port]->phy_mode = PHY_INTERFACE_MODE_NA;
 841 -               else
 842 -                       ocelot->ports[port]->phy_mode = phy_mode;
 843 +                       phy_mode = PHY_INTERFACE_MODE_NA;
 844 +
 845 +               priv->phy_mode = phy_mode;
 846
 847 -               switch (ocelot->ports[port]->phy_mode) {
 848 +               switch (priv->phy_mode) {
 849                 case PHY_INTERFACE_MODE_NA:
 850                         continue;
 851                 case PHY_INTERFACE_MODE_SGMII:
 852 @@ -421,7 +432,7 @@ static int mscc_ocelot_probe(struct plat
 853                         /* Ensure clock signals and speed is set on all
 854                          * QSGMII links
 855                          */
 856 -                       ocelot_port_writel(ocelot->ports[port],
 857 +                       ocelot_port_writel(ocelot_port,
 858                                            DEV_CLOCK_CFG_LINK_SPEED
 859                                            (OCELOT_SPEED_1000),
 860                                            DEV_CLOCK_CFG);
 861 @@ -449,7 +460,7 @@ static int mscc_ocelot_probe(struct plat
 862                         goto out_put_ports;
 863                 }
 864
 865 -               ocelot->ports[port]->serdes = serdes;
 866 +               priv->serdes = serdes;
 867         }
 868
 869         register_netdevice_notifier(&ocelot_netdevice_nb);
 870 --- a/drivers/net/ethernet/mscc/ocelot_flower.c
 871 +++ b/drivers/net/ethernet/mscc/ocelot_flower.c
 872 @@ -10,7 +10,7 @@
 873
 874  struct ocelot_port_block {
 875         struct ocelot_acl_block *block;
 876 -       struct ocelot_port *port;
 877 +       struct ocelot_port_private *priv;
 878  };
 879
 880  static int ocelot_flower_parse_action(struct flow_cls_offload *f,
 881 @@ -177,8 +177,8 @@ struct ocelot_ace_rule *ocelot_ace_rule_
 882         if (!rule)
 883                 return NULL;
 884
 885 -       rule->port = block->port;
 886 -       rule->chip_port = block->port->chip_port;
 887 +       rule->port = &block->priv->port;
 888 +       rule->chip_port = block->priv->chip_port;
 889         return rule;
 890  }
 891
 892 @@ -202,7 +202,7 @@ static int ocelot_flower_replace(struct
 893         if (ret)
 894                 return ret;
 895
 896 -       port_block->port->tc.offload_cnt++;
 897 +       port_block->priv->tc.offload_cnt++;
 898         return 0;
 899  }
 900
 901 @@ -213,14 +213,14 @@ static int ocelot_flower_destroy(struct
 902         int ret;
 903
 904         rule.prio = f->common.prio;
 905 -       rule.port = port_block->port;
 906 +       rule.port = &port_block->priv->port;
 907         rule.id = f->cookie;
 908
 909         ret = ocelot_ace_rule_offload_del(&rule);
 910         if (ret)
 911                 return ret;
 912
 913 -       port_block->port->tc.offload_cnt--;
 914 +       port_block->priv->tc.offload_cnt--;
 915         return 0;
 916  }
 917
 918 @@ -231,7 +231,7 @@ static int ocelot_flower_stats_update(st
 919         int ret;
 920
 921         rule.prio = f->common.prio;
 922 -       rule.port = port_block->port;
 923 +       rule.port = &port_block->priv->port;
 924         rule.id = f->cookie;
 925         ret = ocelot_ace_rule_stats_update(&rule);
 926         if (ret)
 927 @@ -261,7 +261,7 @@ static int ocelot_setup_tc_block_cb_flow
 928  {
 929         struct ocelot_port_block *port_block = cb_priv;
 930
 931 -       if (!tc_cls_can_offload_and_chain0(port_block->port->dev, type_data))
 932 +       if (!tc_cls_can_offload_and_chain0(port_block->priv->dev, type_data))
 933                 return -EOPNOTSUPP;
 934
 935         switch (type) {
 936 @@ -275,7 +275,7 @@ static int ocelot_setup_tc_block_cb_flow
 937  }
 938
 939  static struct ocelot_port_block*
 940 -ocelot_port_block_create(struct ocelot_port *port)
 941 +ocelot_port_block_create(struct ocelot_port_private *priv)
 942  {
 943         struct ocelot_port_block *port_block;
 944
 945 @@ -283,7 +283,7 @@ ocelot_port_block_create(struct ocelot_p
 946         if (!port_block)
 947                 return NULL;
 948
 949 -       port_block->port = port;
 950 +       port_block->priv = priv;
 951
 952         return port_block;
 953  }
 954 @@ -300,7 +300,7 @@ static void ocelot_tc_block_unbind(void
 955         ocelot_port_block_destroy(port_block);
 956  }
 957
 958 -int ocelot_setup_tc_block_flower_bind(struct ocelot_port *port,
 959 +int ocelot_setup_tc_block_flower_bind(struct ocelot_port_private *priv,
 960                                       struct flow_block_offload *f)
 961  {
 962         struct ocelot_port_block *port_block;
 963 @@ -311,14 +311,14 @@ int ocelot_setup_tc_block_flower_bind(st
 964                 return -EOPNOTSUPP;
 965
 966         block_cb = flow_block_cb_lookup(f->block,
 967 -                                       ocelot_setup_tc_block_cb_flower, port);
 968 +                                       ocelot_setup_tc_block_cb_flower, priv);
 969         if (!block_cb) {
 970 -               port_block = ocelot_port_block_create(port);
 971 +               port_block = ocelot_port_block_create(priv);
 972                 if (!port_block)
 973                         return -ENOMEM;
 974
 975                 block_cb = flow_block_cb_alloc(ocelot_setup_tc_block_cb_flower,
 976 -                                              port, port_block,
 977 +                                              priv, port_block,
 978                                                ocelot_tc_block_unbind);
 979                 if (IS_ERR(block_cb)) {
 980                         ret = PTR_ERR(block_cb);
 981 @@ -339,13 +339,13 @@ err_cb_register:
 982         return ret;
 983  }
 984
 985 -void ocelot_setup_tc_block_flower_unbind(struct ocelot_port *port,
 986 +void ocelot_setup_tc_block_flower_unbind(struct ocelot_port_private *priv,
 987                                          struct flow_block_offload *f)
 988  {
 989         struct flow_block_cb *block_cb;
 990
 991         block_cb = flow_block_cb_lookup(f->block,
 992 -                                       ocelot_setup_tc_block_cb_flower, port);
 993 +                                       ocelot_setup_tc_block_cb_flower, priv);
 994         if (!block_cb)
 995                 return;
 996
 997 --- a/drivers/net/ethernet/mscc/ocelot_tc.c
 998 +++ b/drivers/net/ethernet/mscc/ocelot_tc.c
 999 @@ -9,17 +9,19 @@
1000  #include "ocelot_ace.h"
1001  #include <net/pkt_cls.h>
1002
1003 -static int ocelot_setup_tc_cls_matchall(struct ocelot_port *port,
1004 +static int ocelot_setup_tc_cls_matchall(struct ocelot_port_private *priv,
1005                                         struct tc_cls_matchall_offload *f,
1006                                         bool ingress)
1007  {
1008         struct netlink_ext_ack *extack = f->common.extack;
1009 +       struct ocelot *ocelot = priv->port.ocelot;
1010         struct ocelot_policer pol = { 0 };
1011         struct flow_action_entry *action;
1012 +       int port = priv->chip_port;
1013         int err;
1014
1015 -       netdev_dbg(port->dev, "%s: port %u command %d cookie %lu\n",
1016 -                  __func__, port->chip_port, f->command, f->cookie);
1017 +       netdev_dbg(priv->dev, "%s: port %u command %d cookie %lu\n",
1018 +                  __func__, port, f->command, f->cookie);
1019
1020         if (!ingress) {
1021                 NL_SET_ERR_MSG_MOD(extack, "Only ingress is supported");
1022 @@ -34,7 +36,7 @@ static int ocelot_setup_tc_cls_matchall(
1023                         return -EOPNOTSUPP;
1024                 }
1025
1026 -               if (port->tc.block_shared) {
1027 +               if (priv->tc.block_shared) {
1028                         NL_SET_ERR_MSG_MOD(extack,
1029                                            "Rate limit is not supported on shared blocks");
1030                         return -EOPNOTSUPP;
1031 @@ -47,7 +49,7 @@ static int ocelot_setup_tc_cls_matchall(
1032                         return -EOPNOTSUPP;
1033                 }
1034
1035 -               if (port->tc.police_id && port->tc.police_id != f->cookie) {
1036 +               if (priv->tc.police_id && priv->tc.police_id != f->cookie) {
1037                         NL_SET_ERR_MSG_MOD(extack,
1038                                            "Only one policer per port is supported\n");
1039                         return -EEXIST;
1040 @@ -58,28 +60,27 @@ static int ocelot_setup_tc_cls_matchall(
1041                                          PSCHED_NS2TICKS(action->police.burst),
1042                                          PSCHED_TICKS_PER_SEC);
1043
1044 -               err = ocelot_port_policer_add(port->ocelot, port->chip_port,
1045 -                                             &pol);
1046 +               err = ocelot_port_policer_add(ocelot, port, &pol);
1047                 if (err) {
1048                         NL_SET_ERR_MSG_MOD(extack, "Could not add policer\n");
1049                         return err;
1050                 }
1051
1052 -               port->tc.police_id = f->cookie;
1053 -               port->tc.offload_cnt++;
1054 +               priv->tc.police_id = f->cookie;
1055 +               priv->tc.offload_cnt++;
1056                 return 0;
1057         case TC_CLSMATCHALL_DESTROY:
1058 -               if (port->tc.police_id != f->cookie)
1059 +               if (priv->tc.police_id != f->cookie)
1060                         return -ENOENT;
1061
1062 -               err = ocelot_port_policer_del(port->ocelot, port->chip_port);
1063 +               err = ocelot_port_policer_del(ocelot, port);
1064                 if (err) {
1065                         NL_SET_ERR_MSG_MOD(extack,
1066                                            "Could not delete policer\n");
1067                         return err;
1068                 }
1069 -               port->tc.police_id = 0;
1070 -               port->tc.offload_cnt--;
1071 +               priv->tc.police_id = 0;
1072 +               priv->tc.offload_cnt--;
1073                 return 0;
1074         case TC_CLSMATCHALL_STATS: /* fall through */
1075         default:
1076 @@ -91,21 +92,21 @@ static int ocelot_setup_tc_block_cb(enum
1077                                     void *type_data,
1078                                     void *cb_priv, bool ingress)
1079  {
1080 -       struct ocelot_port *port = cb_priv;
1081 +       struct ocelot_port_private *priv = cb_priv;
1082
1083 -       if (!tc_cls_can_offload_and_chain0(port->dev, type_data))
1084 +       if (!tc_cls_can_offload_and_chain0(priv->dev, type_data))
1085                 return -EOPNOTSUPP;
1086
1087         switch (type) {
1088         case TC_SETUP_CLSMATCHALL:
1089 -               netdev_dbg(port->dev, "tc_block_cb: TC_SETUP_CLSMATCHALL %s\n",
1090 +               netdev_dbg(priv->dev, "tc_block_cb: TC_SETUP_CLSMATCHALL %s\n",
1091                            ingress ? "ingress" : "egress");
1092
1093 -               return ocelot_setup_tc_cls_matchall(port, type_data, ingress);
1094 +               return ocelot_setup_tc_cls_matchall(priv, type_data, ingress);
1095         case TC_SETUP_CLSFLOWER:
1096                 return 0;
1097         default:
1098 -               netdev_dbg(port->dev, "tc_block_cb: type %d %s\n",
1099 +               netdev_dbg(priv->dev, "tc_block_cb: type %d %s\n",
1100                            type,
1101                            ingress ? "ingress" : "egress");
1102
1103 @@ -131,19 +132,19 @@ static int ocelot_setup_tc_block_cb_eg(e
1104
1105  static LIST_HEAD(ocelot_block_cb_list);
1106
1107 -static int ocelot_setup_tc_block(struct ocelot_port *port,
1108 +static int ocelot_setup_tc_block(struct ocelot_port_private *priv,
1109                                  struct flow_block_offload *f)
1110  {
1111         struct flow_block_cb *block_cb;
1112         flow_setup_cb_t *cb;
1113         int err;
1114
1115 -       netdev_dbg(port->dev, "tc_block command %d, binder_type %d\n",
1116 +       netdev_dbg(priv->dev, "tc_block command %d, binder_type %d\n",
1117                    f->command, f->binder_type);
1118
1119         if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) {
1120                 cb = ocelot_setup_tc_block_cb_ig;
1121 -               port->tc.block_shared = f->block_shared;
1122 +               priv->tc.block_shared = f->block_shared;
1123         } else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) {
1124                 cb = ocelot_setup_tc_block_cb_eg;
1125         } else {
1126 @@ -154,14 +155,14 @@ static int ocelot_setup_tc_block(struct
1127
1128         switch (f->command) {
1129         case FLOW_BLOCK_BIND:
1130 -               if (flow_block_cb_is_busy(cb, port, &ocelot_block_cb_list))
1131 +               if (flow_block_cb_is_busy(cb, priv, &ocelot_block_cb_list))
1132                         return -EBUSY;
1133
1134 -               block_cb = flow_block_cb_alloc(cb, port, port, NULL);
1135 +               block_cb = flow_block_cb_alloc(cb, priv, priv, NULL);
1136                 if (IS_ERR(block_cb))
1137                         return PTR_ERR(block_cb);
1138
1139 -               err = ocelot_setup_tc_block_flower_bind(port, f);
1140 +               err = ocelot_setup_tc_block_flower_bind(priv, f);
1141                 if (err < 0) {
1142                         flow_block_cb_free(block_cb);
1143                         return err;
1144 @@ -170,11 +171,11 @@ static int ocelot_setup_tc_block(struct
1145                 list_add_tail(&block_cb->driver_list, f->driver_block_list);
1146                 return 0;
1147         case FLOW_BLOCK_UNBIND:
1148 -               block_cb = flow_block_cb_lookup(f->block, cb, port);
1149 +               block_cb = flow_block_cb_lookup(f->block, cb, priv);
1150                 if (!block_cb)
1151                         return -ENOENT;
1152
1153 -               ocelot_setup_tc_block_flower_unbind(port, f);
1154 +               ocelot_setup_tc_block_flower_unbind(priv, f);
1155                 flow_block_cb_remove(block_cb, f);
1156                 list_del(&block_cb->driver_list);
1157                 return 0;
1158 @@ -186,11 +187,11 @@ static int ocelot_setup_tc_block(struct
1159  int ocelot_setup_tc(struct net_device *dev, enum tc_setup_type type,
1160                     void *type_data)
1161  {
1162 -       struct ocelot_port *port = netdev_priv(dev);
1163 +       struct ocelot_port_private *priv = netdev_priv(dev);
1164
1165         switch (type) {
1166         case TC_SETUP_BLOCK:
1167 -               return ocelot_setup_tc_block(port, type_data);
1168 +               return ocelot_setup_tc_block(priv, type_data);
1169         default:
1170                 return -EOPNOTSUPP;
1171         }