include/net/dsa.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * include/net/dsa.h - Driver for Distributed Switch Architecture switch chips
   4  * Copyright (c) 2008-2009 Marvell Semiconductor
   5  */
   6
   7 #ifndef __LINUX_NET_DSA_H
   8 #define __LINUX_NET_DSA_H
   9
  10 #include <linux/if.h>
  11 #include <linux/if_ether.h>
  12 #include <linux/list.h>
  13 #include <linux/notifier.h>
  14 #include <linux/timer.h>
  15 #include <linux/workqueue.h>
  16 #include <linux/of.h>
  17 #include <linux/ethtool.h>
  18 #include <linux/net_tstamp.h>
  19 #include <linux/phy.h>
  20 #include <linux/platform_data/dsa.h>
  21 #include <linux/phylink.h>
  22 #include <net/devlink.h>
  23 #include <net/switchdev.h>
  24
  25 struct dsa_8021q_context;
  26 struct tc_action;
  27
  28 #define DSA_TAG_PROTO_NONE_VALUE                0
  29 #define DSA_TAG_PROTO_BRCM_VALUE                1
  30 #define DSA_TAG_PROTO_BRCM_PREPEND_VALUE        2
  31 #define DSA_TAG_PROTO_DSA_VALUE                 3
  32 #define DSA_TAG_PROTO_EDSA_VALUE                4
  33 #define DSA_TAG_PROTO_GSWIP_VALUE               5
  34 #define DSA_TAG_PROTO_KSZ9477_VALUE             6
  35 #define DSA_TAG_PROTO_KSZ9893_VALUE             7
  36 #define DSA_TAG_PROTO_LAN9303_VALUE             8
  37 #define DSA_TAG_PROTO_MTK_VALUE                 9
  38 #define DSA_TAG_PROTO_QCA_VALUE                 10
  39 #define DSA_TAG_PROTO_TRAILER_VALUE             11
  40 #define DSA_TAG_PROTO_8021Q_VALUE               12
  41 #define DSA_TAG_PROTO_SJA1105_VALUE             13
  42 #define DSA_TAG_PROTO_KSZ8795_VALUE             14
  43 #define DSA_TAG_PROTO_OCELOT_VALUE              15
  44 #define DSA_TAG_PROTO_AR9331_VALUE              16
  45 #define DSA_TAG_PROTO_RTL4_A_VALUE              17
  46 #define DSA_TAG_PROTO_HELLCREEK_VALUE           18
  47 #define DSA_TAG_PROTO_XRS700X_VALUE             19
  48 #define DSA_TAG_PROTO_OCELOT_8021Q_VALUE        20
  49 #define DSA_TAG_PROTO_SEVILLE_VALUE             21
  50 #define DSA_TAG_PROTO_BRCM_LEGACY_VALUE         22
  51 #define DSA_TAG_PROTO_SJA1110_VALUE             23
  52 #define DSA_TAG_PROTO_RTL8_4_VALUE              24
  53 #define DSA_TAG_PROTO_RTL8_4T_VALUE             25
  54 #define DSA_TAG_PROTO_RZN1_A5PSW_VALUE          26
  55 #define DSA_TAG_PROTO_LAN937X_VALUE             27
  56 #define DSA_TAG_PROTO_VSC73XX_8021Q_VALUE       28
  57
  58 enum dsa_tag_protocol {
  59         DSA_TAG_PROTO_NONE              = DSA_TAG_PROTO_NONE_VALUE,
  60         DSA_TAG_PROTO_BRCM              = DSA_TAG_PROTO_BRCM_VALUE,
  61         DSA_TAG_PROTO_BRCM_LEGACY       = DSA_TAG_PROTO_BRCM_LEGACY_VALUE,
  62         DSA_TAG_PROTO_BRCM_PREPEND      = DSA_TAG_PROTO_BRCM_PREPEND_VALUE,
  63         DSA_TAG_PROTO_DSA               = DSA_TAG_PROTO_DSA_VALUE,
  64         DSA_TAG_PROTO_EDSA              = DSA_TAG_PROTO_EDSA_VALUE,
  65         DSA_TAG_PROTO_GSWIP             = DSA_TAG_PROTO_GSWIP_VALUE,
  66         DSA_TAG_PROTO_KSZ9477           = DSA_TAG_PROTO_KSZ9477_VALUE,
  67         DSA_TAG_PROTO_KSZ9893           = DSA_TAG_PROTO_KSZ9893_VALUE,
  68         DSA_TAG_PROTO_LAN9303           = DSA_TAG_PROTO_LAN9303_VALUE,
  69         DSA_TAG_PROTO_MTK               = DSA_TAG_PROTO_MTK_VALUE,
  70         DSA_TAG_PROTO_QCA               = DSA_TAG_PROTO_QCA_VALUE,
  71         DSA_TAG_PROTO_TRAILER           = DSA_TAG_PROTO_TRAILER_VALUE,
  72         DSA_TAG_PROTO_8021Q             = DSA_TAG_PROTO_8021Q_VALUE,
  73         DSA_TAG_PROTO_SJA1105           = DSA_TAG_PROTO_SJA1105_VALUE,
  74         DSA_TAG_PROTO_KSZ8795           = DSA_TAG_PROTO_KSZ8795_VALUE,
  75         DSA_TAG_PROTO_OCELOT            = DSA_TAG_PROTO_OCELOT_VALUE,
  76         DSA_TAG_PROTO_AR9331            = DSA_TAG_PROTO_AR9331_VALUE,
  77         DSA_TAG_PROTO_RTL4_A            = DSA_TAG_PROTO_RTL4_A_VALUE,
  78         DSA_TAG_PROTO_HELLCREEK         = DSA_TAG_PROTO_HELLCREEK_VALUE,
  79         DSA_TAG_PROTO_XRS700X           = DSA_TAG_PROTO_XRS700X_VALUE,
  80         DSA_TAG_PROTO_OCELOT_8021Q      = DSA_TAG_PROTO_OCELOT_8021Q_VALUE,
  81         DSA_TAG_PROTO_SEVILLE           = DSA_TAG_PROTO_SEVILLE_VALUE,
  82         DSA_TAG_PROTO_SJA1110           = DSA_TAG_PROTO_SJA1110_VALUE,
  83         DSA_TAG_PROTO_RTL8_4            = DSA_TAG_PROTO_RTL8_4_VALUE,
  84         DSA_TAG_PROTO_RTL8_4T           = DSA_TAG_PROTO_RTL8_4T_VALUE,
  85         DSA_TAG_PROTO_RZN1_A5PSW        = DSA_TAG_PROTO_RZN1_A5PSW_VALUE,
  86         DSA_TAG_PROTO_LAN937X           = DSA_TAG_PROTO_LAN937X_VALUE,
  87         DSA_TAG_PROTO_VSC73XX_8021Q     = DSA_TAG_PROTO_VSC73XX_8021Q_VALUE,
  88 };
  89
  90 struct dsa_switch;
  91
  92 struct dsa_device_ops {
  93         struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev);
  94         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev);
  95         void (*flow_dissect)(const struct sk_buff *skb, __be16 *proto,
  96                              int *offset);
  97         int (*connect)(struct dsa_switch *ds);
  98         void (*disconnect)(struct dsa_switch *ds);
  99         unsigned int needed_headroom;
 100         unsigned int needed_tailroom;
 101         const char *name;
 102         enum dsa_tag_protocol proto;
 103         /* Some tagging protocols either mangle or shift the destination MAC
 104          * address, in which case the DSA conduit would drop packets on ingress
 105          * if what it understands out of the destination MAC address is not in
 106          * its RX filter.
 107          */
 108         bool promisc_on_conduit;
 109 };
 110
 111 struct dsa_lag {
 112         struct net_device *dev;
 113         unsigned int id;
 114         struct mutex fdb_lock;
 115         struct list_head fdbs;
 116         refcount_t refcount;
 117 };
 118
 119 struct dsa_switch_tree {
 120         struct list_head        list;
 121
 122         /* List of switch ports */
 123         struct list_head ports;
 124
 125         /* Notifier chain for switch-wide events */
 126         struct raw_notifier_head        nh;
 127
 128         /* Tree identifier */
 129         unsigned int index;
 130
 131         /* Number of switches attached to this tree */
 132         struct kref refcount;
 133
 134         /* Maps offloaded LAG netdevs to a zero-based linear ID for
 135          * drivers that need it.
 136          */
 137         struct dsa_lag **lags;
 138
 139         /* Tagging protocol operations */
 140         const struct dsa_device_ops *tag_ops;
 141
 142         /* Default tagging protocol preferred by the switches in this
 143          * tree.
 144          */
 145         enum dsa_tag_protocol default_proto;
 146
 147         /* Has this tree been applied to the hardware? */
 148         bool setup;
 149
 150         /*
 151          * Configuration data for the platform device that owns
 152          * this dsa switch tree instance.
 153          */
 154         struct dsa_platform_data        *pd;
 155
 156         /* List of DSA links composing the routing table */
 157         struct list_head rtable;
 158
 159         /* Length of "lags" array */
 160         unsigned int lags_len;
 161
 162         /* Track the largest switch index within a tree */
 163         unsigned int last_switch;
 164 };
 165
 166 /* LAG IDs are one-based, the dst->lags array is zero-based */
 167 #define dsa_lags_foreach_id(_id, _dst)                          \
 168         for ((_id) = 1; (_id) <= (_dst)->lags_len; (_id)++)     \
 169                 if ((_dst)->lags[(_id) - 1])
 170
 171 #define dsa_lag_foreach_port(_dp, _dst, _lag)                   \
 172         list_for_each_entry((_dp), &(_dst)->ports, list)        \
 173                 if (dsa_port_offloads_lag((_dp), (_lag)))
 174
 175 #define dsa_hsr_foreach_port(_dp, _ds, _hsr)                    \
 176         list_for_each_entry((_dp), &(_ds)->dst->ports, list)    \
 177                 if ((_dp)->ds == (_ds) && (_dp)->hsr_dev == (_hsr))
 178
 179 static inline struct dsa_lag *dsa_lag_by_id(struct dsa_switch_tree *dst,
 180                                             unsigned int id)
 181 {
 182         /* DSA LAG IDs are one-based, dst->lags is zero-based */
 183         return dst->lags[id - 1];
 184 }
 185
 186 static inline int dsa_lag_id(struct dsa_switch_tree *dst,
 187                              struct net_device *lag_dev)
 188 {
 189         unsigned int id;
 190
 191         dsa_lags_foreach_id(id, dst) {
 192                 struct dsa_lag *lag = dsa_lag_by_id(dst, id);
 193
 194                 if (lag->dev == lag_dev)
 195                         return lag->id;
 196         }
 197
 198         return -ENODEV;
 199 }
 200
 201 /* TC matchall action types */
 202 enum dsa_port_mall_action_type {
 203         DSA_PORT_MALL_MIRROR,
 204         DSA_PORT_MALL_POLICER,
 205 };
 206
 207 /* TC mirroring entry */
 208 struct dsa_mall_mirror_tc_entry {
 209         u8 to_local_port;
 210         bool ingress;
 211 };
 212
 213 /* TC port policer entry */
 214 struct dsa_mall_policer_tc_entry {
 215         u32 burst;
 216         u64 rate_bytes_per_sec;
 217 };
 218
 219 /* TC matchall entry */
 220 struct dsa_mall_tc_entry {
 221         struct list_head list;
 222         unsigned long cookie;
 223         enum dsa_port_mall_action_type type;
 224         union {
 225                 struct dsa_mall_mirror_tc_entry mirror;
 226                 struct dsa_mall_policer_tc_entry policer;
 227         };
 228 };
 229
 230 struct dsa_bridge {
 231         struct net_device *dev;
 232         unsigned int num;
 233         bool tx_fwd_offload;
 234         refcount_t refcount;
 235 };
 236
 237 struct dsa_port {
 238         /* A CPU port is physically connected to a conduit device. A user port
 239          * exposes a network device to user-space, called 'user' here.
 240          */
 241         union {
 242                 struct net_device *conduit;
 243                 struct net_device *user;
 244         };
 245
 246         /* Copy of the tagging protocol operations, for quicker access
 247          * in the data path. Valid only for the CPU ports.
 248          */
 249         const struct dsa_device_ops *tag_ops;
 250
 251         /* Copies for faster access in conduit receive hot path */
 252         struct dsa_switch_tree *dst;
 253         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev);
 254
 255         struct dsa_switch       *ds;
 256
 257         unsigned int            index;
 258
 259         enum {
 260                 DSA_PORT_TYPE_UNUSED = 0,
 261                 DSA_PORT_TYPE_CPU,
 262                 DSA_PORT_TYPE_DSA,
 263                 DSA_PORT_TYPE_USER,
 264         } type;
 265
 266         const char              *name;
 267         struct dsa_port         *cpu_dp;
 268         u8                      mac[ETH_ALEN];
 269
 270         u8                      stp_state;
 271
 272         /* Warning: the following bit fields are not atomic, and updating them
 273          * can only be done from code paths where concurrency is not possible
 274          * (probe time or under rtnl_lock).
 275          */
 276         u8                      vlan_filtering:1;
 277
 278         /* Managed by DSA on user ports and by drivers on CPU and DSA ports */
 279         u8                      learning:1;
 280
 281         u8                      lag_tx_enabled:1;
 282
 283         /* conduit state bits, valid only on CPU ports */
 284         u8                      conduit_admin_up:1;
 285         u8                      conduit_oper_up:1;
 286
 287         /* Valid only on user ports */
 288         u8                      cpu_port_in_lag:1;
 289
 290         u8                      setup:1;
 291
 292         struct device_node      *dn;
 293         unsigned int            ageing_time;
 294
 295         struct dsa_bridge       *bridge;
 296         struct devlink_port     devlink_port;
 297         struct phylink          *pl;
 298         struct phylink_config   pl_config;
 299         struct dsa_lag          *lag;
 300         struct net_device       *hsr_dev;
 301
 302         struct list_head list;
 303
 304         /*
 305          * Original copy of the conduit netdev ethtool_ops
 306          */
 307         const struct ethtool_ops *orig_ethtool_ops;
 308
 309         /* List of MAC addresses that must be forwarded on this port.
 310          * These are only valid on CPU ports and DSA links.
 311          */
 312         struct mutex            addr_lists_lock;
 313         struct list_head        fdbs;
 314         struct list_head        mdbs;
 315
 316         struct mutex            vlans_lock;
 317         union {
 318                 /* List of VLANs that CPU and DSA ports are members of.
 319                  * Access to this is serialized by the sleepable @vlans_lock.
 320                  */
 321                 struct list_head        vlans;
 322                 /* List of VLANs that user ports are members of.
 323                  * Access to this is serialized by netif_addr_lock_bh().
 324                  */
 325                 struct list_head        user_vlans;
 326         };
 327 };
 328
 329 static inline struct dsa_port *
 330 dsa_phylink_to_port(struct phylink_config *config)
 331 {
 332         return container_of(config, struct dsa_port, pl_config);
 333 }
 334
 335 /* TODO: ideally DSA ports would have a single dp->link_dp member,
 336  * and no dst->rtable nor this struct dsa_link would be needed,
 337  * but this would require some more complex tree walking,
 338  * so keep it stupid at the moment and list them all.
 339  */
 340 struct dsa_link {
 341         struct dsa_port *dp;
 342         struct dsa_port *link_dp;
 343         struct list_head list;
 344 };
 345
 346 enum dsa_db_type {
 347         DSA_DB_PORT,
 348         DSA_DB_LAG,
 349         DSA_DB_BRIDGE,
 350 };
 351
 352 struct dsa_db {
 353         enum dsa_db_type type;
 354
 355         union {
 356                 const struct dsa_port *dp;
 357                 struct dsa_lag lag;
 358                 struct dsa_bridge bridge;
 359         };
 360 };
 361
 362 struct dsa_mac_addr {
 363         unsigned char addr[ETH_ALEN];
 364         u16 vid;
 365         refcount_t refcount;
 366         struct list_head list;
 367         struct dsa_db db;
 368 };
 369
 370 struct dsa_vlan {
 371         u16 vid;
 372         refcount_t refcount;
 373         struct list_head list;
 374 };
 375
 376 struct dsa_switch {
 377         struct device *dev;
 378
 379         /*
 380          * Parent switch tree, and switch index.
 381          */
 382         struct dsa_switch_tree  *dst;
 383         unsigned int            index;
 384
 385         /* Warning: the following bit fields are not atomic, and updating them
 386          * can only be done from code paths where concurrency is not possible
 387          * (probe time or under rtnl_lock).
 388          */
 389         u32                     setup:1;
 390
 391         /* Disallow bridge core from requesting different VLAN awareness
 392          * settings on ports if not hardware-supported
 393          */
 394         u32                     vlan_filtering_is_global:1;
 395
 396         /* Keep VLAN filtering enabled on ports not offloading any upper */
 397         u32                     needs_standalone_vlan_filtering:1;
 398
 399         /* Pass .port_vlan_add and .port_vlan_del to drivers even for bridges
 400          * that have vlan_filtering=0. All drivers should ideally set this (and
 401          * then the option would get removed), but it is unknown whether this
 402          * would break things or not.
 403          */
 404         u32                     configure_vlan_while_not_filtering:1;
 405
 406         /* Pop the default_pvid of VLAN-unaware bridge ports from tagged frames.
 407          * DEPRECATED: Do NOT set this field in new drivers. Instead look at
 408          * the dsa_software_vlan_untag() comments.
 409          */
 410         u32                     untag_bridge_pvid:1;
 411         /* Pop the default_pvid of VLAN-aware bridge ports from tagged frames.
 412          * Useful if the switch cannot preserve the VLAN tag as seen on the
 413          * wire for user port ingress, and chooses to send all frames as
 414          * VLAN-tagged to the CPU, including those which were originally
 415          * untagged.
 416          */
 417         u32                     untag_vlan_aware_bridge_pvid:1;
 418
 419         /* Let DSA manage the FDB entries towards the
 420          * CPU, based on the software bridge database.
 421          */
 422         u32                     assisted_learning_on_cpu_port:1;
 423
 424         /* In case vlan_filtering_is_global is set, the VLAN awareness state
 425          * should be retrieved from here and not from the per-port settings.
 426          */
 427         u32                     vlan_filtering:1;
 428
 429         /* For switches that only have the MRU configurable. To ensure the
 430          * configured MTU is not exceeded, normalization of MRU on all bridged
 431          * interfaces is needed.
 432          */
 433         u32                     mtu_enforcement_ingress:1;
 434
 435         /* Drivers that isolate the FDBs of multiple bridges must set this
 436          * to true to receive the bridge as an argument in .port_fdb_{add,del}
 437          * and .port_mdb_{add,del}. Otherwise, the bridge.num will always be
 438          * passed as zero.
 439          */
 440         u32                     fdb_isolation:1;
 441
 442         /* Drivers that have global DSCP mapping settings must set this to
 443          * true to automatically apply the settings to all ports.
 444          */
 445         u32                     dscp_prio_mapping_is_global:1;
 446
 447         /* Listener for switch fabric events */
 448         struct notifier_block   nb;
 449
 450         /*
 451          * Give the switch driver somewhere to hang its private data
 452          * structure.
 453          */
 454         void *priv;
 455
 456         void *tagger_data;
 457
 458         /*
 459          * Configuration data for this switch.
 460          */
 461         struct dsa_chip_data    *cd;
 462
 463         /*
 464          * The switch operations.
 465          */
 466         const struct dsa_switch_ops     *ops;
 467
 468         /*
 469          * Allow a DSA switch driver to override the phylink MAC ops
 470          */
 471         const struct phylink_mac_ops    *phylink_mac_ops;
 472
 473         /*
 474          * User mii_bus and devices for the individual ports.
 475          */
 476         u32                     phys_mii_mask;
 477         struct mii_bus          *user_mii_bus;
 478
 479         /* Ageing Time limits in msecs */
 480         unsigned int ageing_time_min;
 481         unsigned int ageing_time_max;
 482
 483         /* Storage for drivers using tag_8021q */
 484         struct dsa_8021q_context *tag_8021q_ctx;
 485
 486         /* devlink used to represent this switch device */
 487         struct devlink          *devlink;
 488
 489         /* Number of switch port queues */
 490         unsigned int            num_tx_queues;
 491
 492         /* Drivers that benefit from having an ID associated with each
 493          * offloaded LAG should set this to the maximum number of
 494          * supported IDs. DSA will then maintain a mapping of _at
 495          * least_ these many IDs, accessible to drivers via
 496          * dsa_lag_id().
 497          */
 498         unsigned int            num_lag_ids;
 499
 500         /* Drivers that support bridge forwarding offload or FDB isolation
 501          * should set this to the maximum number of bridges spanning the same
 502          * switch tree (or all trees, in the case of cross-tree bridging
 503          * support) that can be offloaded.
 504          */
 505         unsigned int            max_num_bridges;
 506
 507         unsigned int            num_ports;
 508 };
 509
 510 static inline struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p)
 511 {
 512         struct dsa_switch_tree *dst = ds->dst;
 513         struct dsa_port *dp;
 514
 515         list_for_each_entry(dp, &dst->ports, list)
 516                 if (dp->ds == ds && dp->index == p)
 517                         return dp;
 518
 519         return NULL;
 520 }
 521
 522 static inline bool dsa_port_is_dsa(struct dsa_port *port)
 523 {
 524         return port->type == DSA_PORT_TYPE_DSA;
 525 }
 526
 527 static inline bool dsa_port_is_cpu(struct dsa_port *port)
 528 {
 529         return port->type == DSA_PORT_TYPE_CPU;
 530 }
 531
 532 static inline bool dsa_port_is_user(struct dsa_port *dp)
 533 {
 534         return dp->type == DSA_PORT_TYPE_USER;
 535 }
 536
 537 static inline bool dsa_port_is_unused(struct dsa_port *dp)
 538 {
 539         return dp->type == DSA_PORT_TYPE_UNUSED;
 540 }
 541
 542 static inline bool dsa_port_conduit_is_operational(struct dsa_port *dp)
 543 {
 544         return dsa_port_is_cpu(dp) && dp->conduit_admin_up &&
 545                dp->conduit_oper_up;
 546 }
 547
 548 static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
 549 {
 550         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
 551 }
 552
 553 static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
 554 {
 555         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
 556 }
 557
 558 static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
 559 {
 560         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
 561 }
 562
 563 static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
 564 {
 565         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
 566 }
 567
 568 #define dsa_tree_for_each_user_port(_dp, _dst) \
 569         list_for_each_entry((_dp), &(_dst)->ports, list) \
 570                 if (dsa_port_is_user((_dp)))
 571
 572 #define dsa_tree_for_each_user_port_continue_reverse(_dp, _dst) \
 573         list_for_each_entry_continue_reverse((_dp), &(_dst)->ports, list) \
 574                 if (dsa_port_is_user((_dp)))
 575
 576 #define dsa_tree_for_each_cpu_port(_dp, _dst) \
 577         list_for_each_entry((_dp), &(_dst)->ports, list) \
 578                 if (dsa_port_is_cpu((_dp)))
 579
 580 #define dsa_switch_for_each_port(_dp, _ds) \
 581         list_for_each_entry((_dp), &(_ds)->dst->ports, list) \
 582                 if ((_dp)->ds == (_ds))
 583
 584 #define dsa_switch_for_each_port_safe(_dp, _next, _ds) \
 585         list_for_each_entry_safe((_dp), (_next), &(_ds)->dst->ports, list) \
 586                 if ((_dp)->ds == (_ds))
 587
 588 #define dsa_switch_for_each_port_continue_reverse(_dp, _ds) \
 589         list_for_each_entry_continue_reverse((_dp), &(_ds)->dst->ports, list) \
 590                 if ((_dp)->ds == (_ds))
 591
 592 #define dsa_switch_for_each_available_port(_dp, _ds) \
 593         dsa_switch_for_each_port((_dp), (_ds)) \
 594                 if (!dsa_port_is_unused((_dp)))
 595
 596 #define dsa_switch_for_each_user_port(_dp, _ds) \
 597         dsa_switch_for_each_port((_dp), (_ds)) \
 598                 if (dsa_port_is_user((_dp)))
 599
 600 #define dsa_switch_for_each_user_port_continue_reverse(_dp, _ds) \
 601         dsa_switch_for_each_port_continue_reverse((_dp), (_ds)) \
 602                 if (dsa_port_is_user((_dp)))
 603
 604 #define dsa_switch_for_each_cpu_port(_dp, _ds) \
 605         dsa_switch_for_each_port((_dp), (_ds)) \
 606                 if (dsa_port_is_cpu((_dp)))
 607
 608 #define dsa_switch_for_each_cpu_port_continue_reverse(_dp, _ds) \
 609         dsa_switch_for_each_port_continue_reverse((_dp), (_ds)) \
 610                 if (dsa_port_is_cpu((_dp)))
 611
 612 static inline u32 dsa_user_ports(struct dsa_switch *ds)
 613 {
 614         struct dsa_port *dp;
 615         u32 mask = 0;
 616
 617         dsa_switch_for_each_user_port(dp, ds)
 618                 mask |= BIT(dp->index);
 619
 620         return mask;
 621 }
 622
 623 static inline u32 dsa_cpu_ports(struct dsa_switch *ds)
 624 {
 625         struct dsa_port *cpu_dp;
 626         u32 mask = 0;
 627
 628         dsa_switch_for_each_cpu_port(cpu_dp, ds)
 629                 mask |= BIT(cpu_dp->index);
 630
 631         return mask;
 632 }
 633
 634 /* Return the local port used to reach an arbitrary switch device */
 635 static inline unsigned int dsa_routing_port(struct dsa_switch *ds, int device)
 636 {
 637         struct dsa_switch_tree *dst = ds->dst;
 638         struct dsa_link *dl;
 639
 640         list_for_each_entry(dl, &dst->rtable, list)
 641                 if (dl->dp->ds == ds && dl->link_dp->ds->index == device)
 642                         return dl->dp->index;
 643
 644         return ds->num_ports;
 645 }
 646
 647 /* Return the local port used to reach an arbitrary switch port */
 648 static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
 649                                             int port)
 650 {
 651         if (device == ds->index)
 652                 return port;
 653         else
 654                 return dsa_routing_port(ds, device);
 655 }
 656
 657 /* Return the local port used to reach the dedicated CPU port */
 658 static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
 659 {
 660         const struct dsa_port *dp = dsa_to_port(ds, port);
 661         const struct dsa_port *cpu_dp = dp->cpu_dp;
 662
 663         if (!cpu_dp)
 664                 return port;
 665
 666         return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
 667 }
 668
 669 /* Return true if this is the local port used to reach the CPU port */
 670 static inline bool dsa_is_upstream_port(struct dsa_switch *ds, int port)
 671 {
 672         if (dsa_is_unused_port(ds, port))
 673                 return false;
 674
 675         return port == dsa_upstream_port(ds, port);
 676 }
 677
 678 /* Return true if this is a DSA port leading away from the CPU */
 679 static inline bool dsa_is_downstream_port(struct dsa_switch *ds, int port)
 680 {
 681         return dsa_is_dsa_port(ds, port) && !dsa_is_upstream_port(ds, port);
 682 }
 683
 684 /* Return the local port used to reach the CPU port */
 685 static inline unsigned int dsa_switch_upstream_port(struct dsa_switch *ds)
 686 {
 687         struct dsa_port *dp;
 688
 689         dsa_switch_for_each_available_port(dp, ds) {
 690                 return dsa_upstream_port(ds, dp->index);
 691         }
 692
 693         return ds->num_ports;
 694 }
 695
 696 /* Return true if @upstream_ds is an upstream switch of @downstream_ds, meaning
 697  * that the routing port from @downstream_ds to @upstream_ds is also the port
 698  * which @downstream_ds uses to reach its dedicated CPU.
 699  */
 700 static inline bool dsa_switch_is_upstream_of(struct dsa_switch *upstream_ds,
 701                                              struct dsa_switch *downstream_ds)
 702 {
 703         int routing_port;
 704
 705         if (upstream_ds == downstream_ds)
 706                 return true;
 707
 708         routing_port = dsa_routing_port(downstream_ds, upstream_ds->index);
 709
 710         return dsa_is_upstream_port(downstream_ds, routing_port);
 711 }
 712
 713 static inline bool dsa_port_is_vlan_filtering(const struct dsa_port *dp)
 714 {
 715         const struct dsa_switch *ds = dp->ds;
 716
 717         if (ds->vlan_filtering_is_global)
 718                 return ds->vlan_filtering;
 719         else
 720                 return dp->vlan_filtering;
 721 }
 722
 723 static inline unsigned int dsa_port_lag_id_get(struct dsa_port *dp)
 724 {
 725         return dp->lag ? dp->lag->id : 0;
 726 }
 727
 728 static inline struct net_device *dsa_port_lag_dev_get(struct dsa_port *dp)
 729 {
 730         return dp->lag ? dp->lag->dev : NULL;
 731 }
 732
 733 static inline bool dsa_port_offloads_lag(struct dsa_port *dp,
 734                                          const struct dsa_lag *lag)
 735 {
 736         return dsa_port_lag_dev_get(dp) == lag->dev;
 737 }
 738
 739 static inline struct net_device *dsa_port_to_conduit(const struct dsa_port *dp)
 740 {
 741         if (dp->cpu_port_in_lag)
 742                 return dsa_port_lag_dev_get(dp->cpu_dp);
 743
 744         return dp->cpu_dp->conduit;
 745 }
 746
 747 static inline
 748 struct net_device *dsa_port_to_bridge_port(const struct dsa_port *dp)
 749 {
 750         if (!dp->bridge)
 751                 return NULL;
 752
 753         if (dp->lag)
 754                 return dp->lag->dev;
 755         else if (dp->hsr_dev)
 756                 return dp->hsr_dev;
 757
 758         return dp->user;
 759 }
 760
 761 static inline struct net_device *
 762 dsa_port_bridge_dev_get(const struct dsa_port *dp)
 763 {
 764         return dp->bridge ? dp->bridge->dev : NULL;
 765 }
 766
 767 static inline unsigned int dsa_port_bridge_num_get(struct dsa_port *dp)
 768 {
 769         return dp->bridge ? dp->bridge->num : 0;
 770 }
 771
 772 static inline bool dsa_port_bridge_same(const struct dsa_port *a,
 773                                         const struct dsa_port *b)
 774 {
 775         struct net_device *br_a = dsa_port_bridge_dev_get(a);
 776         struct net_device *br_b = dsa_port_bridge_dev_get(b);
 777
 778         /* Standalone ports are not in the same bridge with one another */
 779         return (!br_a || !br_b) ? false : (br_a == br_b);
 780 }
 781
 782 static inline bool dsa_port_offloads_bridge_port(struct dsa_port *dp,
 783                                                  const struct net_device *dev)
 784 {
 785         return dsa_port_to_bridge_port(dp) == dev;
 786 }
 787
 788 static inline bool
 789 dsa_port_offloads_bridge_dev(struct dsa_port *dp,
 790                              const struct net_device *bridge_dev)
 791 {
 792         /* DSA ports connected to a bridge, and event was emitted
 793          * for the bridge.
 794          */
 795         return dsa_port_bridge_dev_get(dp) == bridge_dev;
 796 }
 797
 798 static inline bool dsa_port_offloads_bridge(struct dsa_port *dp,
 799                                             const struct dsa_bridge *bridge)
 800 {
 801         return dsa_port_bridge_dev_get(dp) == bridge->dev;
 802 }
 803
 804 /* Returns true if any port of this tree offloads the given net_device */
 805 static inline bool dsa_tree_offloads_bridge_port(struct dsa_switch_tree *dst,
 806                                                  const struct net_device *dev)
 807 {
 808         struct dsa_port *dp;
 809
 810         list_for_each_entry(dp, &dst->ports, list)
 811                 if (dsa_port_offloads_bridge_port(dp, dev))
 812                         return true;
 813
 814         return false;
 815 }
 816
 817 /* Returns true if any port of this tree offloads the given bridge */
 818 static inline bool
 819 dsa_tree_offloads_bridge_dev(struct dsa_switch_tree *dst,
 820                              const struct net_device *bridge_dev)
 821 {
 822         struct dsa_port *dp;
 823
 824         list_for_each_entry(dp, &dst->ports, list)
 825                 if (dsa_port_offloads_bridge_dev(dp, bridge_dev))
 826                         return true;
 827
 828         return false;
 829 }
 830
 831 static inline bool dsa_port_tree_same(const struct dsa_port *a,
 832                                       const struct dsa_port *b)
 833 {
 834         return a->ds->dst == b->ds->dst;
 835 }
 836
 837 typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
 838                               bool is_static, void *data);
 839 struct dsa_switch_ops {
 840         /*
 841          * Tagging protocol helpers called for the CPU ports and DSA links.
 842          * @get_tag_protocol retrieves the initial tagging protocol and is
 843          * mandatory. Switches which can operate using multiple tagging
 844          * protocols should implement @change_tag_protocol and report in
 845          * @get_tag_protocol the tagger in current use.
 846          */
 847         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
 848                                                   int port,
 849                                                   enum dsa_tag_protocol mprot);
 850         int     (*change_tag_protocol)(struct dsa_switch *ds,
 851                                        enum dsa_tag_protocol proto);
 852         /*
 853          * Method for switch drivers to connect to the tagging protocol driver
 854          * in current use. The switch driver can provide handlers for certain
 855          * types of packets for switch management.
 856          */
 857         int     (*connect_tag_protocol)(struct dsa_switch *ds,
 858                                         enum dsa_tag_protocol proto);
 859
 860         int     (*port_change_conduit)(struct dsa_switch *ds, int port,
 861                                        struct net_device *conduit,
 862                                        struct netlink_ext_ack *extack);
 863
 864         /* Optional switch-wide initialization and destruction methods */
 865         int     (*setup)(struct dsa_switch *ds);
 866         void    (*teardown)(struct dsa_switch *ds);
 867
 868         /* Per-port initialization and destruction methods. Mandatory if the
 869          * driver registers devlink port regions, optional otherwise.
 870          */
 871         int     (*port_setup)(struct dsa_switch *ds, int port);
 872         void    (*port_teardown)(struct dsa_switch *ds, int port);
 873
 874         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
 875
 876         /*
 877          * Access to the switch's PHY registers.
 878          */
 879         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
 880         int     (*phy_write)(struct dsa_switch *ds, int port,
 881                              int regnum, u16 val);
 882
 883         /*
 884          * PHYLINK integration
 885          */
 886         void    (*phylink_get_caps)(struct dsa_switch *ds, int port,
 887                                     struct phylink_config *config);
 888         void    (*phylink_fixed_state)(struct dsa_switch *ds, int port,
 889                                        struct phylink_link_state *state);
 890         /*
 891          * Port statistics counters.
 892          */
 893         void    (*get_strings)(struct dsa_switch *ds, int port,
 894                                u32 stringset, uint8_t *data);
 895         void    (*get_ethtool_stats)(struct dsa_switch *ds,
 896                                      int port, uint64_t *data);
 897         int     (*get_sset_count)(struct dsa_switch *ds, int port, int sset);
 898         void    (*get_ethtool_phy_stats)(struct dsa_switch *ds,
 899                                          int port, uint64_t *data);
 900         void    (*get_eth_phy_stats)(struct dsa_switch *ds, int port,
 901                                      struct ethtool_eth_phy_stats *phy_stats);
 902         void    (*get_eth_mac_stats)(struct dsa_switch *ds, int port,
 903                                      struct ethtool_eth_mac_stats *mac_stats);
 904         void    (*get_eth_ctrl_stats)(struct dsa_switch *ds, int port,
 905                                       struct ethtool_eth_ctrl_stats *ctrl_stats);
 906         void    (*get_rmon_stats)(struct dsa_switch *ds, int port,
 907                                   struct ethtool_rmon_stats *rmon_stats,
 908                                   const struct ethtool_rmon_hist_range **ranges);
 909         void    (*get_stats64)(struct dsa_switch *ds, int port,
 910                                    struct rtnl_link_stats64 *s);
 911         void    (*get_pause_stats)(struct dsa_switch *ds, int port,
 912                                    struct ethtool_pause_stats *pause_stats);
 913         void    (*self_test)(struct dsa_switch *ds, int port,
 914                              struct ethtool_test *etest, u64 *data);
 915
 916         /*
 917          * ethtool Wake-on-LAN
 918          */
 919         void    (*get_wol)(struct dsa_switch *ds, int port,
 920                            struct ethtool_wolinfo *w);
 921         int     (*set_wol)(struct dsa_switch *ds, int port,
 922                            struct ethtool_wolinfo *w);
 923
 924         /*
 925          * ethtool timestamp info
 926          */
 927         int     (*get_ts_info)(struct dsa_switch *ds, int port,
 928                                struct kernel_ethtool_ts_info *ts);
 929
 930         /*
 931          * ethtool MAC merge layer
 932          */
 933         int     (*get_mm)(struct dsa_switch *ds, int port,
 934                           struct ethtool_mm_state *state);
 935         int     (*set_mm)(struct dsa_switch *ds, int port,
 936                           struct ethtool_mm_cfg *cfg,
 937                           struct netlink_ext_ack *extack);
 938         void    (*get_mm_stats)(struct dsa_switch *ds, int port,
 939                                 struct ethtool_mm_stats *stats);
 940
 941         /*
 942          * DCB ops
 943          */
 944         int     (*port_get_default_prio)(struct dsa_switch *ds, int port);
 945         int     (*port_set_default_prio)(struct dsa_switch *ds, int port,
 946                                          u8 prio);
 947         int     (*port_get_dscp_prio)(struct dsa_switch *ds, int port, u8 dscp);
 948         int     (*port_add_dscp_prio)(struct dsa_switch *ds, int port, u8 dscp,
 949                                       u8 prio);
 950         int     (*port_del_dscp_prio)(struct dsa_switch *ds, int port, u8 dscp,
 951                                       u8 prio);
 952         int     (*port_set_apptrust)(struct dsa_switch *ds, int port,
 953                                      const u8 *sel, int nsel);
 954         int     (*port_get_apptrust)(struct dsa_switch *ds, int port, u8 *sel,
 955                                      int *nsel);
 956
 957         /*
 958          * Suspend and resume
 959          */
 960         int     (*suspend)(struct dsa_switch *ds);
 961         int     (*resume)(struct dsa_switch *ds);
 962
 963         /*
 964          * Port enable/disable
 965          */
 966         int     (*port_enable)(struct dsa_switch *ds, int port,
 967                                struct phy_device *phy);
 968         void    (*port_disable)(struct dsa_switch *ds, int port);
 969
 970
 971         /*
 972          * Notification for MAC address changes on user ports. Drivers can
 973          * currently only veto operations. They should not use the method to
 974          * program the hardware, since the operation is not rolled back in case
 975          * of other errors.
 976          */
 977         int     (*port_set_mac_address)(struct dsa_switch *ds, int port,
 978                                         const unsigned char *addr);
 979
 980         /*
 981          * Compatibility between device trees defining multiple CPU ports and
 982          * drivers which are not OK to use by default the numerically smallest
 983          * CPU port of a switch for its local ports. This can return NULL,
 984          * meaning "don't know/don't care".
 985          */
 986         struct dsa_port *(*preferred_default_local_cpu_port)(struct dsa_switch *ds);
 987
 988         /*
 989          * Port's MAC EEE settings
 990          */
 991         int     (*set_mac_eee)(struct dsa_switch *ds, int port,
 992                                struct ethtool_keee *e);
 993         int     (*get_mac_eee)(struct dsa_switch *ds, int port,
 994                                struct ethtool_keee *e);
 995
 996         /* EEPROM access */
 997         int     (*get_eeprom_len)(struct dsa_switch *ds);
 998         int     (*get_eeprom)(struct dsa_switch *ds,
 999                               struct ethtool_eeprom *eeprom, u8 *data);
1000         int     (*set_eeprom)(struct dsa_switch *ds,
1001                               struct ethtool_eeprom *eeprom, u8 *data);
1002
1003         /*
1004          * Register access.
1005          */
1006         int     (*get_regs_len)(struct dsa_switch *ds, int port);
1007         void    (*get_regs)(struct dsa_switch *ds, int port,
1008                             struct ethtool_regs *regs, void *p);
1009
1010         /*
1011          * Upper device tracking.
1012          */
1013         int     (*port_prechangeupper)(struct dsa_switch *ds, int port,
1014                                        struct netdev_notifier_changeupper_info *info);
1015
1016         /*
1017          * Bridge integration
1018          */
1019         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
1020         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
1021                                     struct dsa_bridge bridge,
1022                                     bool *tx_fwd_offload,
1023                                     struct netlink_ext_ack *extack);
1024         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
1025                                      struct dsa_bridge bridge);
1026         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
1027                                       u8 state);
1028         int     (*port_mst_state_set)(struct dsa_switch *ds, int port,
1029                                       const struct switchdev_mst_state *state);
1030         void    (*port_fast_age)(struct dsa_switch *ds, int port);
1031         int     (*port_vlan_fast_age)(struct dsa_switch *ds, int port, u16 vid);
1032         int     (*port_pre_bridge_flags)(struct dsa_switch *ds, int port,
1033                                          struct switchdev_brport_flags flags,
1034                                          struct netlink_ext_ack *extack);
1035         int     (*port_bridge_flags)(struct dsa_switch *ds, int port,
1036                                      struct switchdev_brport_flags flags,
1037                                      struct netlink_ext_ack *extack);
1038         void    (*port_set_host_flood)(struct dsa_switch *ds, int port,
1039                                        bool uc, bool mc);
1040
1041         /*
1042          * VLAN support
1043          */
1044         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
1045                                        bool vlan_filtering,
1046                                        struct netlink_ext_ack *extack);
1047         int     (*port_vlan_add)(struct dsa_switch *ds, int port,
1048                                  const struct switchdev_obj_port_vlan *vlan,
1049                                  struct netlink_ext_ack *extack);
1050         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
1051                                  const struct switchdev_obj_port_vlan *vlan);
1052         int     (*vlan_msti_set)(struct dsa_switch *ds, struct dsa_bridge bridge,
1053                                  const struct switchdev_vlan_msti *msti);
1054
1055         /*
1056          * Forwarding database
1057          */
1058         int     (*port_fdb_add)(struct dsa_switch *ds, int port,
1059                                 const unsigned char *addr, u16 vid,
1060                                 struct dsa_db db);
1061         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
1062                                 const unsigned char *addr, u16 vid,
1063                                 struct dsa_db db);
1064         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
1065                                  dsa_fdb_dump_cb_t *cb, void *data);
1066         int     (*lag_fdb_add)(struct dsa_switch *ds, struct dsa_lag lag,
1067                                const unsigned char *addr, u16 vid,
1068                                struct dsa_db db);
1069         int     (*lag_fdb_del)(struct dsa_switch *ds, struct dsa_lag lag,
1070                                const unsigned char *addr, u16 vid,
1071                                struct dsa_db db);
1072
1073         /*
1074          * Multicast database
1075          */
1076         int     (*port_mdb_add)(struct dsa_switch *ds, int port,
1077                                 const struct switchdev_obj_port_mdb *mdb,
1078                                 struct dsa_db db);
1079         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
1080                                 const struct switchdev_obj_port_mdb *mdb,
1081                                 struct dsa_db db);
1082         /*
1083          * RXNFC
1084          */
1085         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
1086                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
1087         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
1088                              struct ethtool_rxnfc *nfc);
1089
1090         /*
1091          * TC integration
1092          */
1093         int     (*cls_flower_add)(struct dsa_switch *ds, int port,
1094                                   struct flow_cls_offload *cls, bool ingress);
1095         int     (*cls_flower_del)(struct dsa_switch *ds, int port,
1096                                   struct flow_cls_offload *cls, bool ingress);
1097         int     (*cls_flower_stats)(struct dsa_switch *ds, int port,
1098                                     struct flow_cls_offload *cls, bool ingress);
1099         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
1100                                    struct dsa_mall_mirror_tc_entry *mirror,
1101                                    bool ingress, struct netlink_ext_ack *extack);
1102         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
1103                                    struct dsa_mall_mirror_tc_entry *mirror);
1104         int     (*port_policer_add)(struct dsa_switch *ds, int port,
1105                                     struct dsa_mall_policer_tc_entry *policer);
1106         void    (*port_policer_del)(struct dsa_switch *ds, int port);
1107         int     (*port_setup_tc)(struct dsa_switch *ds, int port,
1108                                  enum tc_setup_type type, void *type_data);
1109
1110         /*
1111          * Cross-chip operations
1112          */
1113         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int tree_index,
1114                                          int sw_index, int port,
1115                                          struct dsa_bridge bridge,
1116                                          struct netlink_ext_ack *extack);
1117         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int tree_index,
1118                                           int sw_index, int port,
1119                                           struct dsa_bridge bridge);
1120         int     (*crosschip_lag_change)(struct dsa_switch *ds, int sw_index,
1121                                         int port);
1122         int     (*crosschip_lag_join)(struct dsa_switch *ds, int sw_index,
1123                                       int port, struct dsa_lag lag,
1124                                       struct netdev_lag_upper_info *info,
1125                                       struct netlink_ext_ack *extack);
1126         int     (*crosschip_lag_leave)(struct dsa_switch *ds, int sw_index,
1127                                        int port, struct dsa_lag lag);
1128
1129         /*
1130          * PTP functionality
1131          */
1132         int     (*port_hwtstamp_get)(struct dsa_switch *ds, int port,
1133                                      struct ifreq *ifr);
1134         int     (*port_hwtstamp_set)(struct dsa_switch *ds, int port,
1135                                      struct ifreq *ifr);
1136         void    (*port_txtstamp)(struct dsa_switch *ds, int port,
1137                                  struct sk_buff *skb);
1138         bool    (*port_rxtstamp)(struct dsa_switch *ds, int port,
1139                                  struct sk_buff *skb, unsigned int type);
1140
1141         /* Devlink parameters, etc */
1142         int     (*devlink_param_get)(struct dsa_switch *ds, u32 id,
1143                                      struct devlink_param_gset_ctx *ctx);
1144         int     (*devlink_param_set)(struct dsa_switch *ds, u32 id,
1145                                      struct devlink_param_gset_ctx *ctx);
1146         int     (*devlink_info_get)(struct dsa_switch *ds,
1147                                     struct devlink_info_req *req,
1148                                     struct netlink_ext_ack *extack);
1149         int     (*devlink_sb_pool_get)(struct dsa_switch *ds,
1150                                        unsigned int sb_index, u16 pool_index,
1151                                        struct devlink_sb_pool_info *pool_info);
1152         int     (*devlink_sb_pool_set)(struct dsa_switch *ds, unsigned int sb_index,
1153                                        u16 pool_index, u32 size,
1154                                        enum devlink_sb_threshold_type threshold_type,
1155                                        struct netlink_ext_ack *extack);
1156         int     (*devlink_sb_port_pool_get)(struct dsa_switch *ds, int port,
1157                                             unsigned int sb_index, u16 pool_index,
1158                                             u32 *p_threshold);
1159         int     (*devlink_sb_port_pool_set)(struct dsa_switch *ds, int port,
1160                                             unsigned int sb_index, u16 pool_index,
1161                                             u32 threshold,
1162                                             struct netlink_ext_ack *extack);
1163         int     (*devlink_sb_tc_pool_bind_get)(struct dsa_switch *ds, int port,
1164                                                unsigned int sb_index, u16 tc_index,
1165                                                enum devlink_sb_pool_type pool_type,
1166                                                u16 *p_pool_index, u32 *p_threshold);
1167         int     (*devlink_sb_tc_pool_bind_set)(struct dsa_switch *ds, int port,
1168                                                unsigned int sb_index, u16 tc_index,
1169                                                enum devlink_sb_pool_type pool_type,
1170                                                u16 pool_index, u32 threshold,
1171                                                struct netlink_ext_ack *extack);
1172         int     (*devlink_sb_occ_snapshot)(struct dsa_switch *ds,
1173                                            unsigned int sb_index);
1174         int     (*devlink_sb_occ_max_clear)(struct dsa_switch *ds,
1175                                             unsigned int sb_index);
1176         int     (*devlink_sb_occ_port_pool_get)(struct dsa_switch *ds, int port,
1177                                                 unsigned int sb_index, u16 pool_index,
1178                                                 u32 *p_cur, u32 *p_max);
1179         int     (*devlink_sb_occ_tc_port_bind_get)(struct dsa_switch *ds, int port,
1180                                                    unsigned int sb_index, u16 tc_index,
1181                                                    enum devlink_sb_pool_type pool_type,
1182                                                    u32 *p_cur, u32 *p_max);
1183
1184         /*
1185          * MTU change functionality. Switches can also adjust their MRU through
1186          * this method. By MTU, one understands the SDU (L2 payload) length.
1187          * If the switch needs to account for the DSA tag on the CPU port, this
1188          * method needs to do so privately.
1189          */
1190         int     (*port_change_mtu)(struct dsa_switch *ds, int port,
1191                                    int new_mtu);
1192         int     (*port_max_mtu)(struct dsa_switch *ds, int port);
1193
1194         /*
1195          * LAG integration
1196          */
1197         int     (*port_lag_change)(struct dsa_switch *ds, int port);
1198         int     (*port_lag_join)(struct dsa_switch *ds, int port,
1199                                  struct dsa_lag lag,
1200                                  struct netdev_lag_upper_info *info,
1201                                  struct netlink_ext_ack *extack);
1202         int     (*port_lag_leave)(struct dsa_switch *ds, int port,
1203                                   struct dsa_lag lag);
1204
1205         /*
1206          * HSR integration
1207          */
1208         int     (*port_hsr_join)(struct dsa_switch *ds, int port,
1209                                  struct net_device *hsr,
1210                                  struct netlink_ext_ack *extack);
1211         int     (*port_hsr_leave)(struct dsa_switch *ds, int port,
1212                                   struct net_device *hsr);
1213
1214         /*
1215          * MRP integration
1216          */
1217         int     (*port_mrp_add)(struct dsa_switch *ds, int port,
1218                                 const struct switchdev_obj_mrp *mrp);
1219         int     (*port_mrp_del)(struct dsa_switch *ds, int port,
1220                                 const struct switchdev_obj_mrp *mrp);
1221         int     (*port_mrp_add_ring_role)(struct dsa_switch *ds, int port,
1222                                           const struct switchdev_obj_ring_role_mrp *mrp);
1223         int     (*port_mrp_del_ring_role)(struct dsa_switch *ds, int port,
1224                                           const struct switchdev_obj_ring_role_mrp *mrp);
1225
1226         /*
1227          * tag_8021q operations
1228          */
1229         int     (*tag_8021q_vlan_add)(struct dsa_switch *ds, int port, u16 vid,
1230                                       u16 flags);
1231         int     (*tag_8021q_vlan_del)(struct dsa_switch *ds, int port, u16 vid);
1232
1233         /*
1234          * DSA conduit tracking operations
1235          */
1236         void    (*conduit_state_change)(struct dsa_switch *ds,
1237                                         const struct net_device *conduit,
1238                                         bool operational);
1239 };
1240
1241 #define DSA_DEVLINK_PARAM_DRIVER(_id, _name, _type, _cmodes)            \
1242         DEVLINK_PARAM_DRIVER(_id, _name, _type, _cmodes,                \
1243                              dsa_devlink_param_get, dsa_devlink_param_set, NULL)
1244
1245 int dsa_devlink_param_get(struct devlink *dl, u32 id,
1246                           struct devlink_param_gset_ctx *ctx);
1247 int dsa_devlink_param_set(struct devlink *dl, u32 id,
1248                           struct devlink_param_gset_ctx *ctx,
1249                           struct netlink_ext_ack *extack);
1250 int dsa_devlink_params_register(struct dsa_switch *ds,
1251                                 const struct devlink_param *params,
1252                                 size_t params_count);
1253 void dsa_devlink_params_unregister(struct dsa_switch *ds,
1254                                    const struct devlink_param *params,
1255                                    size_t params_count);
1256 int dsa_devlink_resource_register(struct dsa_switch *ds,
1257                                   const char *resource_name,
1258                                   u64 resource_size,
1259                                   u64 resource_id,
1260                                   u64 parent_resource_id,
1261                                   const struct devlink_resource_size_params *size_params);
1262
1263 void dsa_devlink_resources_unregister(struct dsa_switch *ds);
1264
1265 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
1266                                            u64 resource_id,
1267                                            devlink_resource_occ_get_t *occ_get,
1268                                            void *occ_get_priv);
1269 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
1270                                              u64 resource_id);
1271 struct devlink_region *
1272 dsa_devlink_region_create(struct dsa_switch *ds,
1273                           const struct devlink_region_ops *ops,
1274                           u32 region_max_snapshots, u64 region_size);
1275 struct devlink_region *
1276 dsa_devlink_port_region_create(struct dsa_switch *ds,
1277                                int port,
1278                                const struct devlink_port_region_ops *ops,
1279                                u32 region_max_snapshots, u64 region_size);
1280 void dsa_devlink_region_destroy(struct devlink_region *region);
1281
1282 struct dsa_port *dsa_port_from_netdev(struct net_device *netdev);
1283
1284 struct dsa_devlink_priv {
1285         struct dsa_switch *ds;
1286 };
1287
1288 static inline struct dsa_switch *dsa_devlink_to_ds(struct devlink *dl)
1289 {
1290         struct dsa_devlink_priv *dl_priv = devlink_priv(dl);
1291
1292         return dl_priv->ds;
1293 }
1294
1295 static inline
1296 struct dsa_switch *dsa_devlink_port_to_ds(struct devlink_port *port)
1297 {
1298         struct devlink *dl = port->devlink;
1299         struct dsa_devlink_priv *dl_priv = devlink_priv(dl);
1300
1301         return dl_priv->ds;
1302 }
1303
1304 static inline int dsa_devlink_port_to_port(struct devlink_port *port)
1305 {
1306         return port->index;
1307 }
1308
1309 struct dsa_switch_driver {
1310         struct list_head        list;
1311         const struct dsa_switch_ops *ops;
1312 };
1313
1314 bool dsa_fdb_present_in_other_db(struct dsa_switch *ds, int port,
1315                                  const unsigned char *addr, u16 vid,
1316                                  struct dsa_db db);
1317 bool dsa_mdb_present_in_other_db(struct dsa_switch *ds, int port,
1318                                  const struct switchdev_obj_port_mdb *mdb,
1319                                  struct dsa_db db);
1320
1321 /* Keep inline for faster access in hot path */
1322 static inline bool netdev_uses_dsa(const struct net_device *dev)
1323 {
1324 #if IS_ENABLED(CONFIG_NET_DSA)
1325         return dev->dsa_ptr && dev->dsa_ptr->rcv;
1326 #endif
1327         return false;
1328 }
1329
1330 /* All DSA tags that push the EtherType to the right (basically all except tail
1331  * tags, which don't break dissection) can be treated the same from the
1332  * perspective of the flow dissector.
1333  *
1334  * We need to return:
1335  *  - offset: the (B - A) difference between:
1336  *    A. the position of the real EtherType and
1337  *    B. the current skb->data (aka ETH_HLEN bytes into the frame, aka 2 bytes
1338  *       after the normal EtherType was supposed to be)
1339  *    The offset in bytes is exactly equal to the tagger overhead (and half of
1340  *    that, in __be16 shorts).
1341  *
1342  *  - proto: the value of the real EtherType.
1343  */
1344 static inline void dsa_tag_generic_flow_dissect(const struct sk_buff *skb,
1345                                                 __be16 *proto, int *offset)
1346 {
1347 #if IS_ENABLED(CONFIG_NET_DSA)
1348         const struct dsa_device_ops *ops = skb->dev->dsa_ptr->tag_ops;
1349         int tag_len = ops->needed_headroom;
1350
1351         *offset = tag_len;
1352         *proto = ((__be16 *)skb->data)[(tag_len / 2) - 1];
1353 #endif
1354 }
1355
1356 void dsa_unregister_switch(struct dsa_switch *ds);
1357 int dsa_register_switch(struct dsa_switch *ds);
1358 void dsa_switch_shutdown(struct dsa_switch *ds);
1359 struct dsa_switch *dsa_switch_find(int tree_index, int sw_index);
1360 void dsa_flush_workqueue(void);
1361 #ifdef CONFIG_PM_SLEEP
1362 int dsa_switch_suspend(struct dsa_switch *ds);
1363 int dsa_switch_resume(struct dsa_switch *ds);
1364 #else
1365 static inline int dsa_switch_suspend(struct dsa_switch *ds)
1366 {
1367         return 0;
1368 }
1369 static inline int dsa_switch_resume(struct dsa_switch *ds)
1370 {
1371         return 0;
1372 }
1373 #endif /* CONFIG_PM_SLEEP */
1374
1375 #if IS_ENABLED(CONFIG_NET_DSA)
1376 bool dsa_user_dev_check(const struct net_device *dev);
1377 #else
1378 static inline bool dsa_user_dev_check(const struct net_device *dev)
1379 {
1380         return false;
1381 }
1382 #endif
1383
1384 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev);
1385 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up);
1386
1387 #endif