include/net/dsa.h

   1 /*
   2  * include/net/dsa.h - Driver for Distributed Switch Architecture switch chips
   3  * Copyright (c) 2008-2009 Marvell Semiconductor
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  */
  10
  11 #ifndef __LINUX_NET_DSA_H
  12 #define __LINUX_NET_DSA_H
  13
  14 #include <linux/if.h>
  15 #include <linux/if_ether.h>
  16 #include <linux/list.h>
  17 #include <linux/notifier.h>
  18 #include <linux/timer.h>
  19 #include <linux/workqueue.h>
  20 #include <linux/of.h>
  21 #include <linux/ethtool.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
  29 enum dsa_tag_protocol {
  30         DSA_TAG_PROTO_NONE = 0,
  31         DSA_TAG_PROTO_BRCM,
  32         DSA_TAG_PROTO_BRCM_PREPEND,
  33         DSA_TAG_PROTO_DSA,
  34         DSA_TAG_PROTO_EDSA,
  35         DSA_TAG_PROTO_KSZ,
  36         DSA_TAG_PROTO_LAN9303,
  37         DSA_TAG_PROTO_MTK,
  38         DSA_TAG_PROTO_QCA,
  39         DSA_TAG_PROTO_TRAILER,
  40         DSA_TAG_LAST,           /* MUST BE LAST */
  41 };
  42
  43 #define DSA_MAX_SWITCHES        4
  44 #define DSA_MAX_PORTS           12
  45
  46 #define DSA_RTABLE_NONE         -1
  47
  48 struct dsa_chip_data {
  49         /*
  50          * How to access the switch configuration registers.
  51          */
  52         struct device   *host_dev;
  53         int             sw_addr;
  54
  55         /*
  56          * Reference to network devices
  57          */
  58         struct device   *netdev[DSA_MAX_PORTS];
  59
  60         /* set to size of eeprom if supported by the switch */
  61         int             eeprom_len;
  62
  63         /* Device tree node pointer for this specific switch chip
  64          * used during switch setup in case additional properties
  65          * and resources needs to be used
  66          */
  67         struct device_node *of_node;
  68
  69         /*
  70          * The names of the switch's ports.  Use "cpu" to
  71          * designate the switch port that the cpu is connected to,
  72          * "dsa" to indicate that this port is a DSA link to
  73          * another switch, NULL to indicate the port is unused,
  74          * or any other string to indicate this is a physical port.
  75          */
  76         char            *port_names[DSA_MAX_PORTS];
  77         struct device_node *port_dn[DSA_MAX_PORTS];
  78
  79         /*
  80          * An array of which element [a] indicates which port on this
  81          * switch should be used to send packets to that are destined
  82          * for switch a. Can be NULL if there is only one switch chip.
  83          */
  84         s8              rtable[DSA_MAX_SWITCHES];
  85 };
  86
  87 struct dsa_platform_data {
  88         /*
  89          * Reference to a Linux network interface that connects
  90          * to the root switch chip of the tree.
  91          */
  92         struct device   *netdev;
  93         struct net_device *of_netdev;
  94
  95         /*
  96          * Info structs describing each of the switch chips
  97          * connected via this network interface.
  98          */
  99         int             nr_chips;
 100         struct dsa_chip_data    *chip;
 101 };
 102
 103 struct packet_type;
 104
 105 struct dsa_device_ops {
 106         struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev);
 107         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
 108                                struct packet_type *pt);
 109         int (*flow_dissect)(const struct sk_buff *skb, __be16 *proto,
 110                             int *offset);
 111 };
 112
 113 struct dsa_switch_tree {
 114         struct list_head        list;
 115
 116         /* Notifier chain for switch-wide events */
 117         struct raw_notifier_head        nh;
 118
 119         /* Tree identifier */
 120         unsigned int index;
 121
 122         /* Number of switches attached to this tree */
 123         struct kref refcount;
 124
 125         /* Has this tree been applied to the hardware? */
 126         bool setup;
 127
 128         /*
 129          * Configuration data for the platform device that owns
 130          * this dsa switch tree instance.
 131          */
 132         struct dsa_platform_data        *pd;
 133
 134         /*
 135          * The switch port to which the CPU is attached.
 136          */
 137         struct dsa_port         *cpu_dp;
 138
 139         /*
 140          * Data for the individual switch chips.
 141          */
 142         struct dsa_switch       *ds[DSA_MAX_SWITCHES];
 143 };
 144
 145 /* TC matchall action types, only mirroring for now */
 146 enum dsa_port_mall_action_type {
 147         DSA_PORT_MALL_MIRROR,
 148 };
 149
 150 /* TC mirroring entry */
 151 struct dsa_mall_mirror_tc_entry {
 152         u8 to_local_port;
 153         bool ingress;
 154 };
 155
 156 /* TC matchall entry */
 157 struct dsa_mall_tc_entry {
 158         struct list_head list;
 159         unsigned long cookie;
 160         enum dsa_port_mall_action_type type;
 161         union {
 162                 struct dsa_mall_mirror_tc_entry mirror;
 163         };
 164 };
 165
 166
 167 struct dsa_port {
 168         /* A CPU port is physically connected to a master device.
 169          * A user port exposed to userspace has a slave device.
 170          */
 171         union {
 172                 struct net_device *master;
 173                 struct net_device *slave;
 174         };
 175
 176         /* CPU port tagging operations used by master or slave devices */
 177         const struct dsa_device_ops *tag_ops;
 178
 179         /* Copies for faster access in master receive hot path */
 180         struct dsa_switch_tree *dst;
 181         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
 182                                struct packet_type *pt);
 183
 184         enum {
 185                 DSA_PORT_TYPE_UNUSED = 0,
 186                 DSA_PORT_TYPE_CPU,
 187                 DSA_PORT_TYPE_DSA,
 188                 DSA_PORT_TYPE_USER,
 189         } type;
 190
 191         struct dsa_switch       *ds;
 192         unsigned int            index;
 193         const char              *name;
 194         const struct dsa_port   *cpu_dp;
 195         struct device_node      *dn;
 196         unsigned int            ageing_time;
 197         u8                      stp_state;
 198         struct net_device       *bridge_dev;
 199         struct devlink_port     devlink_port;
 200         /*
 201          * Original copy of the master netdev ethtool_ops
 202          */
 203         const struct ethtool_ops *orig_ethtool_ops;
 204 };
 205
 206 struct dsa_switch {
 207         struct device *dev;
 208
 209         /*
 210          * Parent switch tree, and switch index.
 211          */
 212         struct dsa_switch_tree  *dst;
 213         unsigned int            index;
 214
 215         /* Listener for switch fabric events */
 216         struct notifier_block   nb;
 217
 218         /*
 219          * Give the switch driver somewhere to hang its private data
 220          * structure.
 221          */
 222         void *priv;
 223
 224         /*
 225          * Configuration data for this switch.
 226          */
 227         struct dsa_chip_data    *cd;
 228
 229         /*
 230          * The switch operations.
 231          */
 232         const struct dsa_switch_ops     *ops;
 233
 234         /*
 235          * An array of which element [a] indicates which port on this
 236          * switch should be used to send packets to that are destined
 237          * for switch a. Can be NULL if there is only one switch chip.
 238          */
 239         s8              rtable[DSA_MAX_SWITCHES];
 240
 241         /*
 242          * Slave mii_bus and devices for the individual ports.
 243          */
 244         u32                     phys_mii_mask;
 245         struct mii_bus          *slave_mii_bus;
 246
 247         /* Ageing Time limits in msecs */
 248         unsigned int ageing_time_min;
 249         unsigned int ageing_time_max;
 250
 251         /* devlink used to represent this switch device */
 252         struct devlink          *devlink;
 253
 254         /* Number of switch port queues */
 255         unsigned int            num_tx_queues;
 256
 257         /* Dynamically allocated ports, keep last */
 258         size_t num_ports;
 259         struct dsa_port ports[];
 260 };
 261
 262 static inline const struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p)
 263 {
 264         return &ds->ports[p];
 265 }
 266
 267 static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
 268 {
 269         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
 270 }
 271
 272 static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
 273 {
 274         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
 275 }
 276
 277 static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
 278 {
 279         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
 280 }
 281
 282 static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
 283 {
 284         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
 285 }
 286
 287 static inline u32 dsa_user_ports(struct dsa_switch *ds)
 288 {
 289         u32 mask = 0;
 290         int p;
 291
 292         for (p = 0; p < ds->num_ports; p++)
 293                 if (dsa_is_user_port(ds, p))
 294                         mask |= BIT(p);
 295
 296         return mask;
 297 }
 298
 299 static inline u8 dsa_upstream_port(struct dsa_switch *ds)
 300 {
 301         struct dsa_switch_tree *dst = ds->dst;
 302
 303         /*
 304          * If this is the root switch (i.e. the switch that connects
 305          * to the CPU), return the cpu port number on this switch.
 306          * Else return the (DSA) port number that connects to the
 307          * switch that is one hop closer to the cpu.
 308          */
 309         if (dst->cpu_dp->ds == ds)
 310                 return dst->cpu_dp->index;
 311         else
 312                 return ds->rtable[dst->cpu_dp->ds->index];
 313 }
 314
 315 typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
 316                               bool is_static, void *data);
 317 struct dsa_switch_ops {
 318         /*
 319          * Legacy probing.
 320          */
 321         const char      *(*probe)(struct device *dsa_dev,
 322                                   struct device *host_dev, int sw_addr,
 323                                   void **priv);
 324
 325         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
 326                                                   int port);
 327
 328         int     (*setup)(struct dsa_switch *ds);
 329         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
 330
 331         /*
 332          * Access to the switch's PHY registers.
 333          */
 334         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
 335         int     (*phy_write)(struct dsa_switch *ds, int port,
 336                              int regnum, u16 val);
 337
 338         /*
 339          * Link state adjustment (called from libphy)
 340          */
 341         void    (*adjust_link)(struct dsa_switch *ds, int port,
 342                                 struct phy_device *phydev);
 343         void    (*fixed_link_update)(struct dsa_switch *ds, int port,
 344                                 struct fixed_phy_status *st);
 345
 346         /*
 347          * ethtool hardware statistics.
 348          */
 349         void    (*get_strings)(struct dsa_switch *ds, int port, uint8_t *data);
 350         void    (*get_ethtool_stats)(struct dsa_switch *ds,
 351                                      int port, uint64_t *data);
 352         int     (*get_sset_count)(struct dsa_switch *ds);
 353
 354         /*
 355          * ethtool Wake-on-LAN
 356          */
 357         void    (*get_wol)(struct dsa_switch *ds, int port,
 358                            struct ethtool_wolinfo *w);
 359         int     (*set_wol)(struct dsa_switch *ds, int port,
 360                            struct ethtool_wolinfo *w);
 361
 362         /*
 363          * Suspend and resume
 364          */
 365         int     (*suspend)(struct dsa_switch *ds);
 366         int     (*resume)(struct dsa_switch *ds);
 367
 368         /*
 369          * Port enable/disable
 370          */
 371         int     (*port_enable)(struct dsa_switch *ds, int port,
 372                                struct phy_device *phy);
 373         void    (*port_disable)(struct dsa_switch *ds, int port,
 374                                 struct phy_device *phy);
 375
 376         /*
 377          * Port's MAC EEE settings
 378          */
 379         int     (*set_mac_eee)(struct dsa_switch *ds, int port,
 380                                struct ethtool_eee *e);
 381         int     (*get_mac_eee)(struct dsa_switch *ds, int port,
 382                                struct ethtool_eee *e);
 383
 384         /* EEPROM access */
 385         int     (*get_eeprom_len)(struct dsa_switch *ds);
 386         int     (*get_eeprom)(struct dsa_switch *ds,
 387                               struct ethtool_eeprom *eeprom, u8 *data);
 388         int     (*set_eeprom)(struct dsa_switch *ds,
 389                               struct ethtool_eeprom *eeprom, u8 *data);
 390
 391         /*
 392          * Register access.
 393          */
 394         int     (*get_regs_len)(struct dsa_switch *ds, int port);
 395         void    (*get_regs)(struct dsa_switch *ds, int port,
 396                             struct ethtool_regs *regs, void *p);
 397
 398         /*
 399          * Bridge integration
 400          */
 401         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
 402         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
 403                                     struct net_device *bridge);
 404         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
 405                                      struct net_device *bridge);
 406         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
 407                                       u8 state);
 408         void    (*port_fast_age)(struct dsa_switch *ds, int port);
 409
 410         /*
 411          * VLAN support
 412          */
 413         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
 414                                        bool vlan_filtering);
 415         int     (*port_vlan_prepare)(struct dsa_switch *ds, int port,
 416                                      const struct switchdev_obj_port_vlan *vlan,
 417                                      struct switchdev_trans *trans);
 418         void    (*port_vlan_add)(struct dsa_switch *ds, int port,
 419                                  const struct switchdev_obj_port_vlan *vlan,
 420                                  struct switchdev_trans *trans);
 421         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
 422                                  const struct switchdev_obj_port_vlan *vlan);
 423         /*
 424          * Forwarding database
 425          */
 426         int     (*port_fdb_add)(struct dsa_switch *ds, int port,
 427                                 const unsigned char *addr, u16 vid);
 428         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
 429                                 const unsigned char *addr, u16 vid);
 430         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
 431                                  dsa_fdb_dump_cb_t *cb, void *data);
 432
 433         /*
 434          * Multicast database
 435          */
 436         int     (*port_mdb_prepare)(struct dsa_switch *ds, int port,
 437                                     const struct switchdev_obj_port_mdb *mdb,
 438                                     struct switchdev_trans *trans);
 439         void    (*port_mdb_add)(struct dsa_switch *ds, int port,
 440                                 const struct switchdev_obj_port_mdb *mdb,
 441                                 struct switchdev_trans *trans);
 442         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
 443                                 const struct switchdev_obj_port_mdb *mdb);
 444         /*
 445          * RXNFC
 446          */
 447         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
 448                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
 449         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
 450                              struct ethtool_rxnfc *nfc);
 451
 452         /*
 453          * TC integration
 454          */
 455         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
 456                                    struct dsa_mall_mirror_tc_entry *mirror,
 457                                    bool ingress);
 458         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
 459                                    struct dsa_mall_mirror_tc_entry *mirror);
 460
 461         /*
 462          * Cross-chip operations
 463          */
 464         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index,
 465                                          int port, struct net_device *br);
 466         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index,
 467                                           int port, struct net_device *br);
 468 };
 469
 470 struct dsa_switch_driver {
 471         struct list_head        list;
 472         const struct dsa_switch_ops *ops;
 473 };
 474
 475 /* Legacy driver registration */
 476 void register_switch_driver(struct dsa_switch_driver *type);
 477 void unregister_switch_driver(struct dsa_switch_driver *type);
 478 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev);
 479
 480 struct net_device *dsa_dev_to_net_device(struct device *dev);
 481
 482 /* Keep inline for faster access in hot path */
 483 static inline bool netdev_uses_dsa(struct net_device *dev)
 484 {
 485 #if IS_ENABLED(CONFIG_NET_DSA)
 486         return dev->dsa_ptr && dev->dsa_ptr->rcv;
 487 #endif
 488         return false;
 489 }
 490
 491 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n);
 492 void dsa_unregister_switch(struct dsa_switch *ds);
 493 int dsa_register_switch(struct dsa_switch *ds);
 494 #ifdef CONFIG_PM_SLEEP
 495 int dsa_switch_suspend(struct dsa_switch *ds);
 496 int dsa_switch_resume(struct dsa_switch *ds);
 497 #else
 498 static inline int dsa_switch_suspend(struct dsa_switch *ds)
 499 {
 500         return 0;
 501 }
 502 static inline int dsa_switch_resume(struct dsa_switch *ds)
 503 {
 504         return 0;
 505 }
 506 #endif /* CONFIG_PM_SLEEP */
 507
 508 enum dsa_notifier_type {
 509         DSA_PORT_REGISTER,
 510         DSA_PORT_UNREGISTER,
 511 };
 512
 513 struct dsa_notifier_info {
 514         struct net_device *dev;
 515 };
 516
 517 struct dsa_notifier_register_info {
 518         struct dsa_notifier_info info;  /* must be first */
 519         struct net_device *master;
 520         unsigned int port_number;
 521         unsigned int switch_number;
 522 };
 523
 524 static inline struct net_device *
 525 dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
 526 {
 527         return info->dev;
 528 }
 529
 530 #if IS_ENABLED(CONFIG_NET_DSA)
 531 int register_dsa_notifier(struct notifier_block *nb);
 532 int unregister_dsa_notifier(struct notifier_block *nb);
 533 int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 534                        struct dsa_notifier_info *info);
 535 #else
 536 static inline int register_dsa_notifier(struct notifier_block *nb)
 537 {
 538         return 0;
 539 }
 540
 541 static inline int unregister_dsa_notifier(struct notifier_block *nb)
 542 {
 543         return 0;
 544 }
 545
 546 static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 547                                      struct dsa_notifier_info *info)
 548 {
 549         return NOTIFY_DONE;
 550 }
 551 #endif
 552
 553 /* Broadcom tag specific helpers to insert and extract queue/port number */
 554 #define BRCM_TAG_SET_PORT_QUEUE(p, q)   ((p) << 8 | q)
 555 #define BRCM_TAG_GET_PORT(v)            ((v) >> 8)
 556 #define BRCM_TAG_GET_QUEUE(v)           ((v) & 0xff)
 557
 558 #endif