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 tc_action;
  26 struct phy_device;
  27 struct fixed_phy_status;
  28 struct phylink_link_state;
  29
  30 #define DSA_TAG_PROTO_NONE_VALUE                0
  31 #define DSA_TAG_PROTO_BRCM_VALUE                1
  32 #define DSA_TAG_PROTO_BRCM_PREPEND_VALUE        2
  33 #define DSA_TAG_PROTO_DSA_VALUE                 3
  34 #define DSA_TAG_PROTO_EDSA_VALUE                4
  35 #define DSA_TAG_PROTO_GSWIP_VALUE               5
  36 #define DSA_TAG_PROTO_KSZ9477_VALUE             6
  37 #define DSA_TAG_PROTO_KSZ9893_VALUE             7
  38 #define DSA_TAG_PROTO_LAN9303_VALUE             8
  39 #define DSA_TAG_PROTO_MTK_VALUE                 9
  40 #define DSA_TAG_PROTO_QCA_VALUE                 10
  41 #define DSA_TAG_PROTO_TRAILER_VALUE             11
  42 #define DSA_TAG_PROTO_8021Q_VALUE               12
  43 #define DSA_TAG_PROTO_SJA1105_VALUE             13
  44 #define DSA_TAG_PROTO_KSZ8795_VALUE             14
  45 #define DSA_TAG_PROTO_OCELOT_VALUE              15
  46
  47 enum dsa_tag_protocol {
  48         DSA_TAG_PROTO_NONE              = DSA_TAG_PROTO_NONE_VALUE,
  49         DSA_TAG_PROTO_BRCM              = DSA_TAG_PROTO_BRCM_VALUE,
  50         DSA_TAG_PROTO_BRCM_PREPEND      = DSA_TAG_PROTO_BRCM_PREPEND_VALUE,
  51         DSA_TAG_PROTO_DSA               = DSA_TAG_PROTO_DSA_VALUE,
  52         DSA_TAG_PROTO_EDSA              = DSA_TAG_PROTO_EDSA_VALUE,
  53         DSA_TAG_PROTO_GSWIP             = DSA_TAG_PROTO_GSWIP_VALUE,
  54         DSA_TAG_PROTO_KSZ9477           = DSA_TAG_PROTO_KSZ9477_VALUE,
  55         DSA_TAG_PROTO_KSZ9893           = DSA_TAG_PROTO_KSZ9893_VALUE,
  56         DSA_TAG_PROTO_LAN9303           = DSA_TAG_PROTO_LAN9303_VALUE,
  57         DSA_TAG_PROTO_MTK               = DSA_TAG_PROTO_MTK_VALUE,
  58         DSA_TAG_PROTO_QCA               = DSA_TAG_PROTO_QCA_VALUE,
  59         DSA_TAG_PROTO_TRAILER           = DSA_TAG_PROTO_TRAILER_VALUE,
  60         DSA_TAG_PROTO_8021Q             = DSA_TAG_PROTO_8021Q_VALUE,
  61         DSA_TAG_PROTO_SJA1105           = DSA_TAG_PROTO_SJA1105_VALUE,
  62         DSA_TAG_PROTO_KSZ8795           = DSA_TAG_PROTO_KSZ8795_VALUE,
  63         DSA_TAG_PROTO_OCELOT            = DSA_TAG_PROTO_OCELOT_VALUE,
  64 };
  65
  66 struct packet_type;
  67 struct dsa_switch;
  68
  69 struct dsa_device_ops {
  70         struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev);
  71         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
  72                                struct packet_type *pt);
  73         int (*flow_dissect)(const struct sk_buff *skb, __be16 *proto,
  74                             int *offset);
  75         /* Used to determine which traffic should match the DSA filter in
  76          * eth_type_trans, and which, if any, should bypass it and be processed
  77          * as regular on the master net device.
  78          */
  79         bool (*filter)(const struct sk_buff *skb, struct net_device *dev);
  80         unsigned int overhead;
  81         const char *name;
  82         enum dsa_tag_protocol proto;
  83 };
  84
  85 #define DSA_TAG_DRIVER_ALIAS "dsa_tag-"
  86 #define MODULE_ALIAS_DSA_TAG_DRIVER(__proto)                            \
  87         MODULE_ALIAS(DSA_TAG_DRIVER_ALIAS __stringify(__proto##_VALUE))
  88
  89 struct dsa_skb_cb {
  90         struct sk_buff *clone;
  91         bool deferred_xmit;
  92 };
  93
  94 struct __dsa_skb_cb {
  95         struct dsa_skb_cb cb;
  96         u8 priv[48 - sizeof(struct dsa_skb_cb)];
  97 };
  98
  99 #define DSA_SKB_CB(skb) ((struct dsa_skb_cb *)((skb)->cb))
 100
 101 #define DSA_SKB_CB_PRIV(skb)                    \
 102         ((void *)(skb)->cb + offsetof(struct __dsa_skb_cb, priv))
 103
 104 struct dsa_switch_tree {
 105         struct list_head        list;
 106
 107         /* Notifier chain for switch-wide events */
 108         struct raw_notifier_head        nh;
 109
 110         /* Tree identifier */
 111         unsigned int index;
 112
 113         /* Number of switches attached to this tree */
 114         struct kref refcount;
 115
 116         /* Has this tree been applied to the hardware? */
 117         bool setup;
 118
 119         /*
 120          * Configuration data for the platform device that owns
 121          * this dsa switch tree instance.
 122          */
 123         struct dsa_platform_data        *pd;
 124
 125         /* List of switch ports */
 126         struct list_head ports;
 127
 128         /* List of DSA links composing the routing table */
 129         struct list_head rtable;
 130 };
 131
 132 /* TC matchall action types, only mirroring for now */
 133 enum dsa_port_mall_action_type {
 134         DSA_PORT_MALL_MIRROR,
 135 };
 136
 137 /* TC mirroring entry */
 138 struct dsa_mall_mirror_tc_entry {
 139         u8 to_local_port;
 140         bool ingress;
 141 };
 142
 143 /* TC matchall entry */
 144 struct dsa_mall_tc_entry {
 145         struct list_head list;
 146         unsigned long cookie;
 147         enum dsa_port_mall_action_type type;
 148         union {
 149                 struct dsa_mall_mirror_tc_entry mirror;
 150         };
 151 };
 152
 153
 154 struct dsa_port {
 155         /* A CPU port is physically connected to a master device.
 156          * A user port exposed to userspace has a slave device.
 157          */
 158         union {
 159                 struct net_device *master;
 160                 struct net_device *slave;
 161         };
 162
 163         /* CPU port tagging operations used by master or slave devices */
 164         const struct dsa_device_ops *tag_ops;
 165
 166         /* Copies for faster access in master receive hot path */
 167         struct dsa_switch_tree *dst;
 168         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
 169                                struct packet_type *pt);
 170         bool (*filter)(const struct sk_buff *skb, struct net_device *dev);
 171
 172         enum {
 173                 DSA_PORT_TYPE_UNUSED = 0,
 174                 DSA_PORT_TYPE_CPU,
 175                 DSA_PORT_TYPE_DSA,
 176                 DSA_PORT_TYPE_USER,
 177         } type;
 178
 179         struct dsa_switch       *ds;
 180         unsigned int            index;
 181         const char              *name;
 182         struct dsa_port         *cpu_dp;
 183         const char              *mac;
 184         struct device_node      *dn;
 185         unsigned int            ageing_time;
 186         bool                    vlan_filtering;
 187         u8                      stp_state;
 188         struct net_device       *bridge_dev;
 189         struct devlink_port     devlink_port;
 190         struct phylink          *pl;
 191         struct phylink_config   pl_config;
 192
 193         struct work_struct      xmit_work;
 194         struct sk_buff_head     xmit_queue;
 195
 196         struct list_head list;
 197
 198         /*
 199          * Give the switch driver somewhere to hang its per-port private data
 200          * structures (accessible from the tagger).
 201          */
 202         void *priv;
 203
 204         /*
 205          * Original copy of the master netdev ethtool_ops
 206          */
 207         const struct ethtool_ops *orig_ethtool_ops;
 208
 209         /*
 210          * Original copy of the master netdev net_device_ops
 211          */
 212         const struct net_device_ops *orig_ndo_ops;
 213
 214         bool setup;
 215 };
 216
 217 /* TODO: ideally DSA ports would have a single dp->link_dp member,
 218  * and no dst->rtable nor this struct dsa_link would be needed,
 219  * but this would require some more complex tree walking,
 220  * so keep it stupid at the moment and list them all.
 221  */
 222 struct dsa_link {
 223         struct dsa_port *dp;
 224         struct dsa_port *link_dp;
 225         struct list_head list;
 226 };
 227
 228 struct dsa_switch {
 229         bool setup;
 230
 231         struct device *dev;
 232
 233         /*
 234          * Parent switch tree, and switch index.
 235          */
 236         struct dsa_switch_tree  *dst;
 237         unsigned int            index;
 238
 239         /* Listener for switch fabric events */
 240         struct notifier_block   nb;
 241
 242         /*
 243          * Give the switch driver somewhere to hang its private data
 244          * structure.
 245          */
 246         void *priv;
 247
 248         /*
 249          * Configuration data for this switch.
 250          */
 251         struct dsa_chip_data    *cd;
 252
 253         /*
 254          * The switch operations.
 255          */
 256         const struct dsa_switch_ops     *ops;
 257
 258         /*
 259          * Slave mii_bus and devices for the individual ports.
 260          */
 261         u32                     phys_mii_mask;
 262         struct mii_bus          *slave_mii_bus;
 263
 264         /* Ageing Time limits in msecs */
 265         unsigned int ageing_time_min;
 266         unsigned int ageing_time_max;
 267
 268         /* devlink used to represent this switch device */
 269         struct devlink          *devlink;
 270
 271         /* Number of switch port queues */
 272         unsigned int            num_tx_queues;
 273
 274         /* Disallow bridge core from requesting different VLAN awareness
 275          * settings on ports if not hardware-supported
 276          */
 277         bool                    vlan_filtering_is_global;
 278
 279         /* In case vlan_filtering_is_global is set, the VLAN awareness state
 280          * should be retrieved from here and not from the per-port settings.
 281          */
 282         bool                    vlan_filtering;
 283
 284         size_t num_ports;
 285 };
 286
 287 static inline struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p)
 288 {
 289         struct dsa_switch_tree *dst = ds->dst;
 290         struct dsa_port *dp;
 291
 292         list_for_each_entry(dp, &dst->ports, list)
 293                 if (dp->ds == ds && dp->index == p)
 294                         return dp;
 295
 296         return NULL;
 297 }
 298
 299 static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
 300 {
 301         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
 302 }
 303
 304 static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
 305 {
 306         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
 307 }
 308
 309 static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
 310 {
 311         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
 312 }
 313
 314 static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
 315 {
 316         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
 317 }
 318
 319 static inline u32 dsa_user_ports(struct dsa_switch *ds)
 320 {
 321         u32 mask = 0;
 322         int p;
 323
 324         for (p = 0; p < ds->num_ports; p++)
 325                 if (dsa_is_user_port(ds, p))
 326                         mask |= BIT(p);
 327
 328         return mask;
 329 }
 330
 331 /* Return the local port used to reach an arbitrary switch device */
 332 static inline unsigned int dsa_routing_port(struct dsa_switch *ds, int device)
 333 {
 334         struct dsa_switch_tree *dst = ds->dst;
 335         struct dsa_link *dl;
 336
 337         list_for_each_entry(dl, &dst->rtable, list)
 338                 if (dl->dp->ds == ds && dl->link_dp->ds->index == device)
 339                         return dl->dp->index;
 340
 341         return ds->num_ports;
 342 }
 343
 344 /* Return the local port used to reach an arbitrary switch port */
 345 static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
 346                                             int port)
 347 {
 348         if (device == ds->index)
 349                 return port;
 350         else
 351                 return dsa_routing_port(ds, device);
 352 }
 353
 354 /* Return the local port used to reach the dedicated CPU port */
 355 static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
 356 {
 357         const struct dsa_port *dp = dsa_to_port(ds, port);
 358         const struct dsa_port *cpu_dp = dp->cpu_dp;
 359
 360         if (!cpu_dp)
 361                 return port;
 362
 363         return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
 364 }
 365
 366 static inline bool dsa_port_is_vlan_filtering(const struct dsa_port *dp)
 367 {
 368         const struct dsa_switch *ds = dp->ds;
 369
 370         if (ds->vlan_filtering_is_global)
 371                 return ds->vlan_filtering;
 372         else
 373                 return dp->vlan_filtering;
 374 }
 375
 376 typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
 377                               bool is_static, void *data);
 378 struct dsa_switch_ops {
 379         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
 380                                                   int port);
 381
 382         int     (*setup)(struct dsa_switch *ds);
 383         void    (*teardown)(struct dsa_switch *ds);
 384         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
 385
 386         /*
 387          * Access to the switch's PHY registers.
 388          */
 389         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
 390         int     (*phy_write)(struct dsa_switch *ds, int port,
 391                              int regnum, u16 val);
 392
 393         /*
 394          * Link state adjustment (called from libphy)
 395          */
 396         void    (*adjust_link)(struct dsa_switch *ds, int port,
 397                                 struct phy_device *phydev);
 398         void    (*fixed_link_update)(struct dsa_switch *ds, int port,
 399                                 struct fixed_phy_status *st);
 400
 401         /*
 402          * PHYLINK integration
 403          */
 404         void    (*phylink_validate)(struct dsa_switch *ds, int port,
 405                                     unsigned long *supported,
 406                                     struct phylink_link_state *state);
 407         int     (*phylink_mac_link_state)(struct dsa_switch *ds, int port,
 408                                           struct phylink_link_state *state);
 409         void    (*phylink_mac_config)(struct dsa_switch *ds, int port,
 410                                       unsigned int mode,
 411                                       const struct phylink_link_state *state);
 412         void    (*phylink_mac_an_restart)(struct dsa_switch *ds, int port);
 413         void    (*phylink_mac_link_down)(struct dsa_switch *ds, int port,
 414                                          unsigned int mode,
 415                                          phy_interface_t interface);
 416         void    (*phylink_mac_link_up)(struct dsa_switch *ds, int port,
 417                                        unsigned int mode,
 418                                        phy_interface_t interface,
 419                                        struct phy_device *phydev);
 420         void    (*phylink_fixed_state)(struct dsa_switch *ds, int port,
 421                                        struct phylink_link_state *state);
 422         /*
 423          * ethtool hardware statistics.
 424          */
 425         void    (*get_strings)(struct dsa_switch *ds, int port,
 426                                u32 stringset, uint8_t *data);
 427         void    (*get_ethtool_stats)(struct dsa_switch *ds,
 428                                      int port, uint64_t *data);
 429         int     (*get_sset_count)(struct dsa_switch *ds, int port, int sset);
 430         void    (*get_ethtool_phy_stats)(struct dsa_switch *ds,
 431                                          int port, uint64_t *data);
 432
 433         /*
 434          * ethtool Wake-on-LAN
 435          */
 436         void    (*get_wol)(struct dsa_switch *ds, int port,
 437                            struct ethtool_wolinfo *w);
 438         int     (*set_wol)(struct dsa_switch *ds, int port,
 439                            struct ethtool_wolinfo *w);
 440
 441         /*
 442          * ethtool timestamp info
 443          */
 444         int     (*get_ts_info)(struct dsa_switch *ds, int port,
 445                                struct ethtool_ts_info *ts);
 446
 447         /*
 448          * Suspend and resume
 449          */
 450         int     (*suspend)(struct dsa_switch *ds);
 451         int     (*resume)(struct dsa_switch *ds);
 452
 453         /*
 454          * Port enable/disable
 455          */
 456         int     (*port_enable)(struct dsa_switch *ds, int port,
 457                                struct phy_device *phy);
 458         void    (*port_disable)(struct dsa_switch *ds, int port);
 459
 460         /*
 461          * Port's MAC EEE settings
 462          */
 463         int     (*set_mac_eee)(struct dsa_switch *ds, int port,
 464                                struct ethtool_eee *e);
 465         int     (*get_mac_eee)(struct dsa_switch *ds, int port,
 466                                struct ethtool_eee *e);
 467
 468         /* EEPROM access */
 469         int     (*get_eeprom_len)(struct dsa_switch *ds);
 470         int     (*get_eeprom)(struct dsa_switch *ds,
 471                               struct ethtool_eeprom *eeprom, u8 *data);
 472         int     (*set_eeprom)(struct dsa_switch *ds,
 473                               struct ethtool_eeprom *eeprom, u8 *data);
 474
 475         /*
 476          * Register access.
 477          */
 478         int     (*get_regs_len)(struct dsa_switch *ds, int port);
 479         void    (*get_regs)(struct dsa_switch *ds, int port,
 480                             struct ethtool_regs *regs, void *p);
 481
 482         /*
 483          * Bridge integration
 484          */
 485         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
 486         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
 487                                     struct net_device *bridge);
 488         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
 489                                      struct net_device *bridge);
 490         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
 491                                       u8 state);
 492         void    (*port_fast_age)(struct dsa_switch *ds, int port);
 493         int     (*port_egress_floods)(struct dsa_switch *ds, int port,
 494                                       bool unicast, bool multicast);
 495
 496         /*
 497          * VLAN support
 498          */
 499         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
 500                                        bool vlan_filtering);
 501         int (*port_vlan_prepare)(struct dsa_switch *ds, int port,
 502                                  const struct switchdev_obj_port_vlan *vlan);
 503         void (*port_vlan_add)(struct dsa_switch *ds, int port,
 504                               const struct switchdev_obj_port_vlan *vlan);
 505         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
 506                                  const struct switchdev_obj_port_vlan *vlan);
 507         /*
 508          * Forwarding database
 509          */
 510         int     (*port_fdb_add)(struct dsa_switch *ds, int port,
 511                                 const unsigned char *addr, u16 vid);
 512         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
 513                                 const unsigned char *addr, u16 vid);
 514         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
 515                                  dsa_fdb_dump_cb_t *cb, void *data);
 516
 517         /*
 518          * Multicast database
 519          */
 520         int (*port_mdb_prepare)(struct dsa_switch *ds, int port,
 521                                 const struct switchdev_obj_port_mdb *mdb);
 522         void (*port_mdb_add)(struct dsa_switch *ds, int port,
 523                              const struct switchdev_obj_port_mdb *mdb);
 524         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
 525                                 const struct switchdev_obj_port_mdb *mdb);
 526         /*
 527          * RXNFC
 528          */
 529         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
 530                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
 531         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
 532                              struct ethtool_rxnfc *nfc);
 533
 534         /*
 535          * TC integration
 536          */
 537         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
 538                                    struct dsa_mall_mirror_tc_entry *mirror,
 539                                    bool ingress);
 540         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
 541                                    struct dsa_mall_mirror_tc_entry *mirror);
 542         int     (*port_setup_tc)(struct dsa_switch *ds, int port,
 543                                  enum tc_setup_type type, void *type_data);
 544
 545         /*
 546          * Cross-chip operations
 547          */
 548         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index,
 549                                          int port, struct net_device *br);
 550         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index,
 551                                           int port, struct net_device *br);
 552
 553         /*
 554          * PTP functionality
 555          */
 556         int     (*port_hwtstamp_get)(struct dsa_switch *ds, int port,
 557                                      struct ifreq *ifr);
 558         int     (*port_hwtstamp_set)(struct dsa_switch *ds, int port,
 559                                      struct ifreq *ifr);
 560         bool    (*port_txtstamp)(struct dsa_switch *ds, int port,
 561                                  struct sk_buff *clone, unsigned int type);
 562         bool    (*port_rxtstamp)(struct dsa_switch *ds, int port,
 563                                  struct sk_buff *skb, unsigned int type);
 564
 565         /*
 566          * Deferred frame Tx
 567          */
 568         netdev_tx_t (*port_deferred_xmit)(struct dsa_switch *ds, int port,
 569                                           struct sk_buff *skb);
 570         /* Devlink parameters */
 571         int     (*devlink_param_get)(struct dsa_switch *ds, u32 id,
 572                                      struct devlink_param_gset_ctx *ctx);
 573         int     (*devlink_param_set)(struct dsa_switch *ds, u32 id,
 574                                      struct devlink_param_gset_ctx *ctx);
 575 };
 576
 577 #define DSA_DEVLINK_PARAM_DRIVER(_id, _name, _type, _cmodes)            \
 578         DEVLINK_PARAM_DRIVER(_id, _name, _type, _cmodes,                \
 579                              dsa_devlink_param_get, dsa_devlink_param_set, NULL)
 580
 581 int dsa_devlink_param_get(struct devlink *dl, u32 id,
 582                           struct devlink_param_gset_ctx *ctx);
 583 int dsa_devlink_param_set(struct devlink *dl, u32 id,
 584                           struct devlink_param_gset_ctx *ctx);
 585 int dsa_devlink_params_register(struct dsa_switch *ds,
 586                                 const struct devlink_param *params,
 587                                 size_t params_count);
 588 void dsa_devlink_params_unregister(struct dsa_switch *ds,
 589                                    const struct devlink_param *params,
 590                                    size_t params_count);
 591 int dsa_devlink_resource_register(struct dsa_switch *ds,
 592                                   const char *resource_name,
 593                                   u64 resource_size,
 594                                   u64 resource_id,
 595                                   u64 parent_resource_id,
 596                                   const struct devlink_resource_size_params *size_params);
 597
 598 void dsa_devlink_resources_unregister(struct dsa_switch *ds);
 599
 600 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
 601                                            u64 resource_id,
 602                                            devlink_resource_occ_get_t *occ_get,
 603                                            void *occ_get_priv);
 604 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
 605                                              u64 resource_id);
 606
 607 struct dsa_devlink_priv {
 608         struct dsa_switch *ds;
 609 };
 610
 611 struct dsa_switch_driver {
 612         struct list_head        list;
 613         const struct dsa_switch_ops *ops;
 614 };
 615
 616 struct net_device *dsa_dev_to_net_device(struct device *dev);
 617
 618 /* Keep inline for faster access in hot path */
 619 static inline bool netdev_uses_dsa(struct net_device *dev)
 620 {
 621 #if IS_ENABLED(CONFIG_NET_DSA)
 622         return dev->dsa_ptr && dev->dsa_ptr->rcv;
 623 #endif
 624         return false;
 625 }
 626
 627 static inline bool dsa_can_decode(const struct sk_buff *skb,
 628                                   struct net_device *dev)
 629 {
 630 #if IS_ENABLED(CONFIG_NET_DSA)
 631         return !dev->dsa_ptr->filter || dev->dsa_ptr->filter(skb, dev);
 632 #endif
 633         return false;
 634 }
 635
 636 void dsa_unregister_switch(struct dsa_switch *ds);
 637 int dsa_register_switch(struct dsa_switch *ds);
 638 #ifdef CONFIG_PM_SLEEP
 639 int dsa_switch_suspend(struct dsa_switch *ds);
 640 int dsa_switch_resume(struct dsa_switch *ds);
 641 #else
 642 static inline int dsa_switch_suspend(struct dsa_switch *ds)
 643 {
 644         return 0;
 645 }
 646 static inline int dsa_switch_resume(struct dsa_switch *ds)
 647 {
 648         return 0;
 649 }
 650 #endif /* CONFIG_PM_SLEEP */
 651
 652 enum dsa_notifier_type {
 653         DSA_PORT_REGISTER,
 654         DSA_PORT_UNREGISTER,
 655 };
 656
 657 struct dsa_notifier_info {
 658         struct net_device *dev;
 659 };
 660
 661 struct dsa_notifier_register_info {
 662         struct dsa_notifier_info info;  /* must be first */
 663         struct net_device *master;
 664         unsigned int port_number;
 665         unsigned int switch_number;
 666 };
 667
 668 static inline struct net_device *
 669 dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
 670 {
 671         return info->dev;
 672 }
 673
 674 #if IS_ENABLED(CONFIG_NET_DSA)
 675 int register_dsa_notifier(struct notifier_block *nb);
 676 int unregister_dsa_notifier(struct notifier_block *nb);
 677 int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 678                        struct dsa_notifier_info *info);
 679 #else
 680 static inline int register_dsa_notifier(struct notifier_block *nb)
 681 {
 682         return 0;
 683 }
 684
 685 static inline int unregister_dsa_notifier(struct notifier_block *nb)
 686 {
 687         return 0;
 688 }
 689
 690 static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 691                                      struct dsa_notifier_info *info)
 692 {
 693         return NOTIFY_DONE;
 694 }
 695 #endif
 696
 697 /* Broadcom tag specific helpers to insert and extract queue/port number */
 698 #define BRCM_TAG_SET_PORT_QUEUE(p, q)   ((p) << 8 | q)
 699 #define BRCM_TAG_GET_PORT(v)            ((v) >> 8)
 700 #define BRCM_TAG_GET_QUEUE(v)           ((v) & 0xff)
 701
 702
 703 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev);
 704 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data);
 705 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data);
 706 int dsa_port_get_phy_sset_count(struct dsa_port *dp);
 707 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up);
 708
 709 struct dsa_tag_driver {
 710         const struct dsa_device_ops *ops;
 711         struct list_head list;
 712         struct module *owner;
 713 };
 714
 715 void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[],
 716                               unsigned int count,
 717                               struct module *owner);
 718 void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[],
 719                                 unsigned int count);
 720
 721 #define dsa_tag_driver_module_drivers(__dsa_tag_drivers_array, __count) \
 722 static int __init dsa_tag_driver_module_init(void)                      \
 723 {                                                                       \
 724         dsa_tag_drivers_register(__dsa_tag_drivers_array, __count,      \
 725                                  THIS_MODULE);                          \
 726         return 0;                                                       \
 727 }                                                                       \
 728 module_init(dsa_tag_driver_module_init);                                \
 729                                                                         \
 730 static void __exit dsa_tag_driver_module_exit(void)                     \
 731 {                                                                       \
 732         dsa_tag_drivers_unregister(__dsa_tag_drivers_array, __count);   \
 733 }                                                                       \
 734 module_exit(dsa_tag_driver_module_exit)
 735
 736 /**
 737  * module_dsa_tag_drivers() - Helper macro for registering DSA tag
 738  * drivers
 739  * @__ops_array: Array of tag driver strucutres
 740  *
 741  * Helper macro for DSA tag drivers which do not do anything special
 742  * in module init/exit. Each module may only use this macro once, and
 743  * calling it replaces module_init() and module_exit().
 744  */
 745 #define module_dsa_tag_drivers(__ops_array)                             \
 746 dsa_tag_driver_module_drivers(__ops_array, ARRAY_SIZE(__ops_array))
 747
 748 #define DSA_TAG_DRIVER_NAME(__ops) dsa_tag_driver ## _ ## __ops
 749
 750 /* Create a static structure we can build a linked list of dsa_tag
 751  * drivers
 752  */
 753 #define DSA_TAG_DRIVER(__ops)                                           \
 754 static struct dsa_tag_driver DSA_TAG_DRIVER_NAME(__ops) = {             \
 755         .ops = &__ops,                                                  \
 756 }
 757
 758 /**
 759  * module_dsa_tag_driver() - Helper macro for registering a single DSA tag
 760  * driver
 761  * @__ops: Single tag driver structures
 762  *
 763  * Helper macro for DSA tag drivers which do not do anything special
 764  * in module init/exit. Each module may only use this macro once, and
 765  * calling it replaces module_init() and module_exit().
 766  */
 767 #define module_dsa_tag_driver(__ops)                                    \
 768 DSA_TAG_DRIVER(__ops);                                                  \
 769                                                                         \
 770 static struct dsa_tag_driver *dsa_tag_driver_array[] =  {               \
 771         &DSA_TAG_DRIVER_NAME(__ops)                                     \
 772 };                                                                      \
 773 module_dsa_tag_drivers(dsa_tag_driver_array)
 774 #endif
 775