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
  46 enum dsa_tag_protocol {
  47         DSA_TAG_PROTO_NONE              = DSA_TAG_PROTO_NONE_VALUE,
  48         DSA_TAG_PROTO_BRCM              = DSA_TAG_PROTO_BRCM_VALUE,
  49         DSA_TAG_PROTO_BRCM_PREPEND      = DSA_TAG_PROTO_BRCM_PREPEND_VALUE,
  50         DSA_TAG_PROTO_DSA               = DSA_TAG_PROTO_DSA_VALUE,
  51         DSA_TAG_PROTO_EDSA              = DSA_TAG_PROTO_EDSA_VALUE,
  52         DSA_TAG_PROTO_GSWIP             = DSA_TAG_PROTO_GSWIP_VALUE,
  53         DSA_TAG_PROTO_KSZ9477           = DSA_TAG_PROTO_KSZ9477_VALUE,
  54         DSA_TAG_PROTO_KSZ9893           = DSA_TAG_PROTO_KSZ9893_VALUE,
  55         DSA_TAG_PROTO_LAN9303           = DSA_TAG_PROTO_LAN9303_VALUE,
  56         DSA_TAG_PROTO_MTK               = DSA_TAG_PROTO_MTK_VALUE,
  57         DSA_TAG_PROTO_QCA               = DSA_TAG_PROTO_QCA_VALUE,
  58         DSA_TAG_PROTO_TRAILER           = DSA_TAG_PROTO_TRAILER_VALUE,
  59         DSA_TAG_PROTO_8021Q             = DSA_TAG_PROTO_8021Q_VALUE,
  60         DSA_TAG_PROTO_SJA1105           = DSA_TAG_PROTO_SJA1105_VALUE,
  61         DSA_TAG_PROTO_KSZ8795           = DSA_TAG_PROTO_KSZ8795_VALUE,
  62 };
  63
  64 struct packet_type;
  65 struct dsa_switch;
  66
  67 struct dsa_device_ops {
  68         struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev);
  69         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
  70                                struct packet_type *pt);
  71         int (*flow_dissect)(const struct sk_buff *skb, __be16 *proto,
  72                             int *offset);
  73         /* Used to determine which traffic should match the DSA filter in
  74          * eth_type_trans, and which, if any, should bypass it and be processed
  75          * as regular on the master net device.
  76          */
  77         bool (*filter)(const struct sk_buff *skb, struct net_device *dev);
  78         unsigned int overhead;
  79         const char *name;
  80         enum dsa_tag_protocol proto;
  81 };
  82
  83 #define DSA_TAG_DRIVER_ALIAS "dsa_tag-"
  84 #define MODULE_ALIAS_DSA_TAG_DRIVER(__proto)                            \
  85         MODULE_ALIAS(DSA_TAG_DRIVER_ALIAS __stringify(__proto##_VALUE))
  86
  87 struct dsa_skb_cb {
  88         struct sk_buff *clone;
  89         bool deferred_xmit;
  90 };
  91
  92 struct __dsa_skb_cb {
  93         struct dsa_skb_cb cb;
  94         u8 priv[48 - sizeof(struct dsa_skb_cb)];
  95 };
  96
  97 #define DSA_SKB_CB(skb) ((struct dsa_skb_cb *)((skb)->cb))
  98
  99 #define DSA_SKB_CB_PRIV(skb)                    \
 100         ((void *)(skb)->cb + offsetof(struct __dsa_skb_cb, priv))
 101
 102 struct dsa_switch_tree {
 103         struct list_head        list;
 104
 105         /* Notifier chain for switch-wide events */
 106         struct raw_notifier_head        nh;
 107
 108         /* Tree identifier */
 109         unsigned int index;
 110
 111         /* Number of switches attached to this tree */
 112         struct kref refcount;
 113
 114         /* Has this tree been applied to the hardware? */
 115         bool setup;
 116
 117         /*
 118          * Configuration data for the platform device that owns
 119          * this dsa switch tree instance.
 120          */
 121         struct dsa_platform_data        *pd;
 122
 123         /* List of switch ports */
 124         struct list_head ports;
 125
 126         /*
 127          * Data for the individual switch chips.
 128          */
 129         struct dsa_switch       *ds[DSA_MAX_SWITCHES];
 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 struct dsa_switch {
 218         bool setup;
 219
 220         struct device *dev;
 221
 222         /*
 223          * Parent switch tree, and switch index.
 224          */
 225         struct dsa_switch_tree  *dst;
 226         unsigned int            index;
 227
 228         /* Listener for switch fabric events */
 229         struct notifier_block   nb;
 230
 231         /*
 232          * Give the switch driver somewhere to hang its private data
 233          * structure.
 234          */
 235         void *priv;
 236
 237         /*
 238          * Configuration data for this switch.
 239          */
 240         struct dsa_chip_data    *cd;
 241
 242         /*
 243          * The switch operations.
 244          */
 245         const struct dsa_switch_ops     *ops;
 246
 247         /*
 248          * An array of which element [a] indicates which port on this
 249          * switch should be used to send packets to that are destined
 250          * for switch a. Can be NULL if there is only one switch chip.
 251          */
 252         s8              rtable[DSA_MAX_SWITCHES];
 253
 254         /*
 255          * Slave mii_bus and devices for the individual ports.
 256          */
 257         u32                     phys_mii_mask;
 258         struct mii_bus          *slave_mii_bus;
 259
 260         /* Ageing Time limits in msecs */
 261         unsigned int ageing_time_min;
 262         unsigned int ageing_time_max;
 263
 264         /* devlink used to represent this switch device */
 265         struct devlink          *devlink;
 266
 267         /* Number of switch port queues */
 268         unsigned int            num_tx_queues;
 269
 270         /* Disallow bridge core from requesting different VLAN awareness
 271          * settings on ports if not hardware-supported
 272          */
 273         bool                    vlan_filtering_is_global;
 274
 275         /* In case vlan_filtering_is_global is set, the VLAN awareness state
 276          * should be retrieved from here and not from the per-port settings.
 277          */
 278         bool                    vlan_filtering;
 279
 280         size_t num_ports;
 281 };
 282
 283 static inline struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p)
 284 {
 285         struct dsa_switch_tree *dst = ds->dst;
 286         struct dsa_port *dp = NULL;
 287
 288         list_for_each_entry(dp, &dst->ports, list)
 289                 if (dp->ds == ds && dp->index == p)
 290                         break;
 291
 292         return dp;
 293 }
 294
 295 static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
 296 {
 297         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
 298 }
 299
 300 static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
 301 {
 302         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
 303 }
 304
 305 static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
 306 {
 307         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
 308 }
 309
 310 static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
 311 {
 312         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
 313 }
 314
 315 static inline u32 dsa_user_ports(struct dsa_switch *ds)
 316 {
 317         u32 mask = 0;
 318         int p;
 319
 320         for (p = 0; p < ds->num_ports; p++)
 321                 if (dsa_is_user_port(ds, p))
 322                         mask |= BIT(p);
 323
 324         return mask;
 325 }
 326
 327 /* Return the local port used to reach an arbitrary switch port */
 328 static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
 329                                             int port)
 330 {
 331         if (device == ds->index)
 332                 return port;
 333         else
 334                 return ds->rtable[device];
 335 }
 336
 337 /* Return the local port used to reach the dedicated CPU port */
 338 static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
 339 {
 340         const struct dsa_port *dp = dsa_to_port(ds, port);
 341         const struct dsa_port *cpu_dp = dp->cpu_dp;
 342
 343         if (!cpu_dp)
 344                 return port;
 345
 346         return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
 347 }
 348
 349 static inline bool dsa_port_is_vlan_filtering(const struct dsa_port *dp)
 350 {
 351         const struct dsa_switch *ds = dp->ds;
 352
 353         if (ds->vlan_filtering_is_global)
 354                 return ds->vlan_filtering;
 355         else
 356                 return dp->vlan_filtering;
 357 }
 358
 359 typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
 360                               bool is_static, void *data);
 361 struct dsa_switch_ops {
 362         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
 363                                                   int port);
 364
 365         int     (*setup)(struct dsa_switch *ds);
 366         void    (*teardown)(struct dsa_switch *ds);
 367         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
 368
 369         /*
 370          * Access to the switch's PHY registers.
 371          */
 372         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
 373         int     (*phy_write)(struct dsa_switch *ds, int port,
 374                              int regnum, u16 val);
 375
 376         /*
 377          * Link state adjustment (called from libphy)
 378          */
 379         void    (*adjust_link)(struct dsa_switch *ds, int port,
 380                                 struct phy_device *phydev);
 381         void    (*fixed_link_update)(struct dsa_switch *ds, int port,
 382                                 struct fixed_phy_status *st);
 383
 384         /*
 385          * PHYLINK integration
 386          */
 387         void    (*phylink_validate)(struct dsa_switch *ds, int port,
 388                                     unsigned long *supported,
 389                                     struct phylink_link_state *state);
 390         int     (*phylink_mac_link_state)(struct dsa_switch *ds, int port,
 391                                           struct phylink_link_state *state);
 392         void    (*phylink_mac_config)(struct dsa_switch *ds, int port,
 393                                       unsigned int mode,
 394                                       const struct phylink_link_state *state);
 395         void    (*phylink_mac_an_restart)(struct dsa_switch *ds, int port);
 396         void    (*phylink_mac_link_down)(struct dsa_switch *ds, int port,
 397                                          unsigned int mode,
 398                                          phy_interface_t interface);
 399         void    (*phylink_mac_link_up)(struct dsa_switch *ds, int port,
 400                                        unsigned int mode,
 401                                        phy_interface_t interface,
 402                                        struct phy_device *phydev);
 403         void    (*phylink_fixed_state)(struct dsa_switch *ds, int port,
 404                                        struct phylink_link_state *state);
 405         /*
 406          * ethtool hardware statistics.
 407          */
 408         void    (*get_strings)(struct dsa_switch *ds, int port,
 409                                u32 stringset, uint8_t *data);
 410         void    (*get_ethtool_stats)(struct dsa_switch *ds,
 411                                      int port, uint64_t *data);
 412         int     (*get_sset_count)(struct dsa_switch *ds, int port, int sset);
 413         void    (*get_ethtool_phy_stats)(struct dsa_switch *ds,
 414                                          int port, uint64_t *data);
 415
 416         /*
 417          * ethtool Wake-on-LAN
 418          */
 419         void    (*get_wol)(struct dsa_switch *ds, int port,
 420                            struct ethtool_wolinfo *w);
 421         int     (*set_wol)(struct dsa_switch *ds, int port,
 422                            struct ethtool_wolinfo *w);
 423
 424         /*
 425          * ethtool timestamp info
 426          */
 427         int     (*get_ts_info)(struct dsa_switch *ds, int port,
 428                                struct ethtool_ts_info *ts);
 429
 430         /*
 431          * Suspend and resume
 432          */
 433         int     (*suspend)(struct dsa_switch *ds);
 434         int     (*resume)(struct dsa_switch *ds);
 435
 436         /*
 437          * Port enable/disable
 438          */
 439         int     (*port_enable)(struct dsa_switch *ds, int port,
 440                                struct phy_device *phy);
 441         void    (*port_disable)(struct dsa_switch *ds, int port);
 442
 443         /*
 444          * Port's MAC EEE settings
 445          */
 446         int     (*set_mac_eee)(struct dsa_switch *ds, int port,
 447                                struct ethtool_eee *e);
 448         int     (*get_mac_eee)(struct dsa_switch *ds, int port,
 449                                struct ethtool_eee *e);
 450
 451         /* EEPROM access */
 452         int     (*get_eeprom_len)(struct dsa_switch *ds);
 453         int     (*get_eeprom)(struct dsa_switch *ds,
 454                               struct ethtool_eeprom *eeprom, u8 *data);
 455         int     (*set_eeprom)(struct dsa_switch *ds,
 456                               struct ethtool_eeprom *eeprom, u8 *data);
 457
 458         /*
 459          * Register access.
 460          */
 461         int     (*get_regs_len)(struct dsa_switch *ds, int port);
 462         void    (*get_regs)(struct dsa_switch *ds, int port,
 463                             struct ethtool_regs *regs, void *p);
 464
 465         /*
 466          * Bridge integration
 467          */
 468         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
 469         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
 470                                     struct net_device *bridge);
 471         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
 472                                      struct net_device *bridge);
 473         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
 474                                       u8 state);
 475         void    (*port_fast_age)(struct dsa_switch *ds, int port);
 476         int     (*port_egress_floods)(struct dsa_switch *ds, int port,
 477                                       bool unicast, bool multicast);
 478
 479         /*
 480          * VLAN support
 481          */
 482         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
 483                                        bool vlan_filtering);
 484         int (*port_vlan_prepare)(struct dsa_switch *ds, int port,
 485                                  const struct switchdev_obj_port_vlan *vlan);
 486         void (*port_vlan_add)(struct dsa_switch *ds, int port,
 487                               const struct switchdev_obj_port_vlan *vlan);
 488         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
 489                                  const struct switchdev_obj_port_vlan *vlan);
 490         /*
 491          * Forwarding database
 492          */
 493         int     (*port_fdb_add)(struct dsa_switch *ds, int port,
 494                                 const unsigned char *addr, u16 vid);
 495         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
 496                                 const unsigned char *addr, u16 vid);
 497         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
 498                                  dsa_fdb_dump_cb_t *cb, void *data);
 499
 500         /*
 501          * Multicast database
 502          */
 503         int (*port_mdb_prepare)(struct dsa_switch *ds, int port,
 504                                 const struct switchdev_obj_port_mdb *mdb);
 505         void (*port_mdb_add)(struct dsa_switch *ds, int port,
 506                              const struct switchdev_obj_port_mdb *mdb);
 507         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
 508                                 const struct switchdev_obj_port_mdb *mdb);
 509         /*
 510          * RXNFC
 511          */
 512         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
 513                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
 514         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
 515                              struct ethtool_rxnfc *nfc);
 516
 517         /*
 518          * TC integration
 519          */
 520         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
 521                                    struct dsa_mall_mirror_tc_entry *mirror,
 522                                    bool ingress);
 523         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
 524                                    struct dsa_mall_mirror_tc_entry *mirror);
 525         int     (*port_setup_tc)(struct dsa_switch *ds, int port,
 526                                  enum tc_setup_type type, void *type_data);
 527
 528         /*
 529          * Cross-chip operations
 530          */
 531         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index,
 532                                          int port, struct net_device *br);
 533         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index,
 534                                           int port, struct net_device *br);
 535
 536         /*
 537          * PTP functionality
 538          */
 539         int     (*port_hwtstamp_get)(struct dsa_switch *ds, int port,
 540                                      struct ifreq *ifr);
 541         int     (*port_hwtstamp_set)(struct dsa_switch *ds, int port,
 542                                      struct ifreq *ifr);
 543         bool    (*port_txtstamp)(struct dsa_switch *ds, int port,
 544                                  struct sk_buff *clone, unsigned int type);
 545         bool    (*port_rxtstamp)(struct dsa_switch *ds, int port,
 546                                  struct sk_buff *skb, unsigned int type);
 547
 548         /*
 549          * Deferred frame Tx
 550          */
 551         netdev_tx_t (*port_deferred_xmit)(struct dsa_switch *ds, int port,
 552                                           struct sk_buff *skb);
 553 };
 554
 555 struct dsa_switch_driver {
 556         struct list_head        list;
 557         const struct dsa_switch_ops *ops;
 558 };
 559
 560 struct net_device *dsa_dev_to_net_device(struct device *dev);
 561
 562 /* Keep inline for faster access in hot path */
 563 static inline bool netdev_uses_dsa(struct net_device *dev)
 564 {
 565 #if IS_ENABLED(CONFIG_NET_DSA)
 566         return dev->dsa_ptr && dev->dsa_ptr->rcv;
 567 #endif
 568         return false;
 569 }
 570
 571 static inline bool dsa_can_decode(const struct sk_buff *skb,
 572                                   struct net_device *dev)
 573 {
 574 #if IS_ENABLED(CONFIG_NET_DSA)
 575         return !dev->dsa_ptr->filter || dev->dsa_ptr->filter(skb, dev);
 576 #endif
 577         return false;
 578 }
 579
 580 void dsa_unregister_switch(struct dsa_switch *ds);
 581 int dsa_register_switch(struct dsa_switch *ds);
 582 #ifdef CONFIG_PM_SLEEP
 583 int dsa_switch_suspend(struct dsa_switch *ds);
 584 int dsa_switch_resume(struct dsa_switch *ds);
 585 #else
 586 static inline int dsa_switch_suspend(struct dsa_switch *ds)
 587 {
 588         return 0;
 589 }
 590 static inline int dsa_switch_resume(struct dsa_switch *ds)
 591 {
 592         return 0;
 593 }
 594 #endif /* CONFIG_PM_SLEEP */
 595
 596 enum dsa_notifier_type {
 597         DSA_PORT_REGISTER,
 598         DSA_PORT_UNREGISTER,
 599 };
 600
 601 struct dsa_notifier_info {
 602         struct net_device *dev;
 603 };
 604
 605 struct dsa_notifier_register_info {
 606         struct dsa_notifier_info info;  /* must be first */
 607         struct net_device *master;
 608         unsigned int port_number;
 609         unsigned int switch_number;
 610 };
 611
 612 static inline struct net_device *
 613 dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
 614 {
 615         return info->dev;
 616 }
 617
 618 #if IS_ENABLED(CONFIG_NET_DSA)
 619 int register_dsa_notifier(struct notifier_block *nb);
 620 int unregister_dsa_notifier(struct notifier_block *nb);
 621 int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 622                        struct dsa_notifier_info *info);
 623 #else
 624 static inline int register_dsa_notifier(struct notifier_block *nb)
 625 {
 626         return 0;
 627 }
 628
 629 static inline int unregister_dsa_notifier(struct notifier_block *nb)
 630 {
 631         return 0;
 632 }
 633
 634 static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 635                                      struct dsa_notifier_info *info)
 636 {
 637         return NOTIFY_DONE;
 638 }
 639 #endif
 640
 641 /* Broadcom tag specific helpers to insert and extract queue/port number */
 642 #define BRCM_TAG_SET_PORT_QUEUE(p, q)   ((p) << 8 | q)
 643 #define BRCM_TAG_GET_PORT(v)            ((v) >> 8)
 644 #define BRCM_TAG_GET_QUEUE(v)           ((v) & 0xff)
 645
 646
 647 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev);
 648 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data);
 649 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data);
 650 int dsa_port_get_phy_sset_count(struct dsa_port *dp);
 651 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up);
 652
 653 struct dsa_tag_driver {
 654         const struct dsa_device_ops *ops;
 655         struct list_head list;
 656         struct module *owner;
 657 };
 658
 659 void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[],
 660                               unsigned int count,
 661                               struct module *owner);
 662 void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[],
 663                                 unsigned int count);
 664
 665 #define dsa_tag_driver_module_drivers(__dsa_tag_drivers_array, __count) \
 666 static int __init dsa_tag_driver_module_init(void)                      \
 667 {                                                                       \
 668         dsa_tag_drivers_register(__dsa_tag_drivers_array, __count,      \
 669                                  THIS_MODULE);                          \
 670         return 0;                                                       \
 671 }                                                                       \
 672 module_init(dsa_tag_driver_module_init);                                \
 673                                                                         \
 674 static void __exit dsa_tag_driver_module_exit(void)                     \
 675 {                                                                       \
 676         dsa_tag_drivers_unregister(__dsa_tag_drivers_array, __count);   \
 677 }                                                                       \
 678 module_exit(dsa_tag_driver_module_exit)
 679
 680 /**
 681  * module_dsa_tag_drivers() - Helper macro for registering DSA tag
 682  * drivers
 683  * @__ops_array: Array of tag driver strucutres
 684  *
 685  * Helper macro for DSA tag drivers which do not do anything special
 686  * in module init/exit. Each module may only use this macro once, and
 687  * calling it replaces module_init() and module_exit().
 688  */
 689 #define module_dsa_tag_drivers(__ops_array)                             \
 690 dsa_tag_driver_module_drivers(__ops_array, ARRAY_SIZE(__ops_array))
 691
 692 #define DSA_TAG_DRIVER_NAME(__ops) dsa_tag_driver ## _ ## __ops
 693
 694 /* Create a static structure we can build a linked list of dsa_tag
 695  * drivers
 696  */
 697 #define DSA_TAG_DRIVER(__ops)                                           \
 698 static struct dsa_tag_driver DSA_TAG_DRIVER_NAME(__ops) = {             \
 699         .ops = &__ops,                                                  \
 700 }
 701
 702 /**
 703  * module_dsa_tag_driver() - Helper macro for registering a single DSA tag
 704  * driver
 705  * @__ops: Single tag driver structures
 706  *
 707  * Helper macro for DSA tag drivers which do not do anything special
 708  * in module init/exit. Each module may only use this macro once, and
 709  * calling it replaces module_init() and module_exit().
 710  */
 711 #define module_dsa_tag_driver(__ops)                                    \
 712 DSA_TAG_DRIVER(__ops);                                                  \
 713                                                                         \
 714 static struct dsa_tag_driver *dsa_tag_driver_array[] =  {               \
 715         &DSA_TAG_DRIVER_NAME(__ops)                                     \
 716 };                                                                      \
 717 module_dsa_tag_drivers(dsa_tag_driver_array)
 718 #endif
 719