The location of the bridge device pointer and number is going to change.
It is not going to be kept individually per port, but in a common
structure allocated dynamically and which will have lockdep validation.
Use the helpers to access these elements so that we have a migration
path to the new organization.
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
        b53_read16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), &pvlan);
 
        b53_for_each_port(dev, i) {
-               if (dsa_to_port(ds, i)->bridge_dev != br)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != br)
                        continue;
 
                /* Add this local port to the remote port VLAN control
 
        b53_for_each_port(dev, i) {
                /* Don't touch the remaining ports */
-               if (dsa_to_port(ds, i)->bridge_dev != br)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != br)
                        continue;
 
                b53_read16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(i), ®);
 
        struct lan9303 *chip = ds->priv;
 
        dev_dbg(chip->dev, "%s(port %d)\n", __func__, port);
-       if (dsa_to_port(ds, 1)->bridge_dev == dsa_to_port(ds, 2)->bridge_dev) {
+       if (dsa_port_bridge_same(dsa_to_port(ds, 1), dsa_to_port(ds, 2))) {
                lan9303_bridge_ports(chip);
                chip->is_bridged = true;  /* unleash stp_state_set() */
        }
 
                                     bool vlan_filtering,
                                     struct netlink_ext_ack *extack)
 {
-       struct net_device *bridge = dsa_to_port(ds, port)->bridge_dev;
+       struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
        struct gswip_priv *priv = ds->priv;
 
        /* Do not allow changing the VLAN filtering options while in bridge */
                                   const struct switchdev_obj_port_vlan *vlan,
                                   struct netlink_ext_ack *extack)
 {
+       struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
        struct gswip_priv *priv = ds->priv;
-       struct net_device *bridge = dsa_to_port(ds, port)->bridge_dev;
        unsigned int max_ports = priv->hw_info->max_ports;
        int pos = max_ports;
        int i, idx = -1;
                               const struct switchdev_obj_port_vlan *vlan,
                               struct netlink_ext_ack *extack)
 {
+       struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
        struct gswip_priv *priv = ds->priv;
-       struct net_device *bridge = dsa_to_port(ds, port)->bridge_dev;
        bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
        bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
        int err;
 static int gswip_port_vlan_del(struct dsa_switch *ds, int port,
                               const struct switchdev_obj_port_vlan *vlan)
 {
+       struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
        struct gswip_priv *priv = ds->priv;
-       struct net_device *bridge = dsa_to_port(ds, port)->bridge_dev;
        bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
 
        /* We have to receive all packets on the CPU port and should not
 static int gswip_port_fdb(struct dsa_switch *ds, int port,
                          const unsigned char *addr, u16 vid, bool add)
 {
+       struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
        struct gswip_priv *priv = ds->priv;
-       struct net_device *bridge = dsa_to_port(ds, port)->bridge_dev;
        struct gswip_pce_table_entry mac_bridge = {0,};
        unsigned int cpu_port = priv->hw_info->cpu_port;
        int fid = -1;
 
                        continue;
                if (port == i)
                        continue;
-               if (!dp->bridge_dev || dp->bridge_dev != other_dp->bridge_dev)
+               if (!dsa_port_bridge_same(dp, other_dp))
                        continue;
 
                if (other_p->stp_state == BR_STATE_FORWARDING &&
 
                 * same bridge. If the port is disabled, port matrix is kept
                 * and not being setup until the port becomes enabled.
                 */
-               if (other_dp->bridge_dev != bridge)
+               if (dsa_port_bridge_dev_get(other_dp) != bridge)
                        continue;
 
                if (priv->ports[other_port].enable)
        /* This is called after .port_bridge_leave when leaving a VLAN-aware
         * bridge. Don't set standalone ports to fallback mode.
         */
-       if (dsa_to_port(ds, port)->bridge_dev)
+       if (dsa_port_bridge_dev_get(dsa_to_port(ds, port)))
                mt7530_rmw(priv, MT7530_PCR_P(port), PCR_PORT_VLAN_MASK,
                           MT7530_PORT_FALLBACK_MODE);
 
                 * in the same bridge. If the port is disabled, port matrix
                 * is kept and not being setup until the port becomes enabled.
                 */
-               if (other_dp->bridge_dev != bridge)
+               if (dsa_port_bridge_dev_get(other_dp) != bridge)
                        continue;
 
                if (priv->ports[other_port].enable)
 
        /* dev is a virtual bridge */
        } else {
                list_for_each_entry(dp, &dst->ports, list) {
-                       if (!dp->bridge_num)
+                       unsigned int bridge_num = dsa_port_bridge_num_get(dp);
+
+                       if (!bridge_num)
                                continue;
 
-                       if (dp->bridge_num + dst->last_switch != dev)
+                       if (bridge_num + dst->last_switch != dev)
                                continue;
 
                        found = true;
        dsa_switch_for_each_port(other_dp, ds)
                if (other_dp->type == DSA_PORT_TYPE_CPU ||
                    other_dp->type == DSA_PORT_TYPE_DSA ||
-                   (dp->bridge_dev && dp->bridge_dev == other_dp->bridge_dev))
+                   dsa_port_bridge_same(dp, other_dp))
                        pvlan |= BIT(other_dp->index);
 
        return pvlan;
                return 0;
 
        dsa_switch_for_each_user_port(other_dp, ds) {
+               struct net_device *other_br;
+
                if (vlan.member[other_dp->index] ==
                    MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER)
                        continue;
 
-               if (dp->bridge_dev == other_dp->bridge_dev)
+               if (dsa_port_bridge_same(dp, other_dp))
                        break; /* same bridge, check next VLAN */
 
-               if (!other_dp->bridge_dev)
+               other_br = dsa_port_bridge_dev_get(other_dp);
+               if (!other_br)
                        continue;
 
                dev_err(ds->dev, "p%d: hw VLAN %d already used by port %d in %s\n",
-                       port, vlan.vid, other_dp->index,
-                       netdev_name(other_dp->bridge_dev));
+                       port, vlan.vid, other_dp->index, netdev_name(other_br));
                return -EOPNOTSUPP;
        }
 
 static int mv88e6xxx_port_commit_pvid(struct mv88e6xxx_chip *chip, int port)
 {
        struct dsa_port *dp = dsa_to_port(chip->ds, port);
+       struct net_device *br = dsa_port_bridge_dev_get(dp);
        struct mv88e6xxx_port *p = &chip->ports[port];
        u16 pvid = MV88E6XXX_VID_STANDALONE;
        bool drop_untagged = false;
        int err;
 
-       if (dp->bridge_dev) {
-               if (br_vlan_enabled(dp->bridge_dev)) {
+       if (br) {
+               if (br_vlan_enabled(br)) {
                        pvid = p->bridge_pvid.vid;
                        drop_untagged = !p->bridge_pvid.valid;
                } else {
        int err;
 
        list_for_each_entry(dp, &dst->ports, list) {
-               if (dp->bridge_dev == br) {
+               if (dsa_port_bridge_dev_get(dp) == br) {
                        if (dp->ds == ds) {
                                /* This is a local bridge group member,
                                 * remap its Port VLAN Map.
 
        for (i = 0; i < QCA8K_NUM_PORTS; i++) {
                if (dsa_is_cpu_port(ds, i))
                        continue;
-               if (dsa_to_port(ds, i)->bridge_dev != br)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != br)
                        continue;
                /* Add this port to the portvlan mask of the other ports
                 * in the bridge
        for (i = 0; i < QCA8K_NUM_PORTS; i++) {
                if (dsa_is_cpu_port(ds, i))
                        continue;
-               if (dsa_to_port(ds, i)->bridge_dev != br)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != br)
                        continue;
                /* Remove this port to the portvlan mask of the other ports
                 * in the bridge
 
                if (i == port)
                        continue;
                /* Not on this bridge */
-               if (dsa_to_port(ds, i)->bridge_dev != bridge)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != bridge)
                        continue;
                /* Join this port to each other port on the bridge */
                ret = regmap_update_bits(smi->map, RTL8366RB_PORT_ISO(i),
                if (i == port)
                        continue;
                /* Not on this bridge */
-               if (dsa_to_port(ds, i)->bridge_dev != bridge)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != bridge)
                        continue;
                /* Remove this port from any other port on the bridge */
                ret = regmap_update_bits(smi->map, RTL8366RB_PORT_ISO(i),
 
 static int sja1105_commit_pvid(struct dsa_switch *ds, int port)
 {
        struct dsa_port *dp = dsa_to_port(ds, port);
+       struct net_device *br = dsa_port_bridge_dev_get(dp);
        struct sja1105_private *priv = ds->priv;
        struct sja1105_vlan_lookup_entry *vlan;
        bool drop_untagged = false;
        int match, rc;
        u16 pvid;
 
-       if (dp->bridge_dev && br_vlan_enabled(dp->bridge_dev))
+       if (br && br_vlan_enabled(br))
                pvid = priv->bridge_pvid[port];
        else
                pvid = priv->tag_8021q_pvid[port];
                 */
                if (i == port)
                        continue;
-               if (dsa_to_port(ds, i)->bridge_dev != br)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != br)
                        continue;
                sja1105_port_allow_traffic(l2_fwd, i, port, member);
                sja1105_port_allow_traffic(l2_fwd, port, i, member);
 
        if (netif_is_bridge_master(upper)) {
                list_for_each_entry(dp, &dst->ports, list) {
-                       if (dp->bridge_dev && dp->bridge_dev != upper &&
-                           br_vlan_enabled(dp->bridge_dev)) {
+                       struct net_device *br = dsa_port_bridge_dev_get(dp);
+
+                       if (br && br != upper && br_vlan_enabled(br)) {
                                NL_SET_ERR_MSG_MOD(extack,
                                                   "Only one VLAN-aware bridge is supported");
                                return -EBUSY;
 
 
                cpu_mask |= BIT(i);
 
-               if (dsa_to_port(ds, i)->bridge_dev == bridge)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) == bridge)
                        continue;
 
                mask |= BIT(i);
        }
 
        for (i = 0; i < ds->num_ports; i++) {
-               if (dsa_to_port(ds, i)->bridge_dev != bridge)
+               if (dsa_port_bridge_dev_get(dsa_to_port(ds, i)) != bridge)
                        continue;
 
                /* 1 = Disable forwarding to the port */