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 /* Return the local port used to reach an arbitrary switch port */
 300 static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
 301                                             int port)
 302 {
 303         if (device == ds->index)
 304                 return port;
 305         else
 306                 return ds->rtable[device];
 307 }
 308
 309 /* Return the local port used to reach the dedicated CPU port */
 310 static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
 311 {
 312         const struct dsa_port *dp = dsa_to_port(ds, port);
 313         const struct dsa_port *cpu_dp = dp->cpu_dp;
 314
 315         if (!cpu_dp)
 316                 return port;
 317
 318         return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
 319 }
 320
 321 typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
 322                               bool is_static, void *data);
 323 struct dsa_switch_ops {
 324 #if IS_ENABLED(CONFIG_NET_DSA_LEGACY)
 325         /*
 326          * Legacy probing.
 327          */
 328         const char      *(*probe)(struct device *dsa_dev,
 329                                   struct device *host_dev, int sw_addr,
 330                                   void **priv);
 331 #endif
 332
 333         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
 334                                                   int port);
 335
 336         int     (*setup)(struct dsa_switch *ds);
 337         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
 338
 339         /*
 340          * Access to the switch's PHY registers.
 341          */
 342         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
 343         int     (*phy_write)(struct dsa_switch *ds, int port,
 344                              int regnum, u16 val);
 345
 346         /*
 347          * Link state adjustment (called from libphy)
 348          */
 349         void    (*adjust_link)(struct dsa_switch *ds, int port,
 350                                 struct phy_device *phydev);
 351         void    (*fixed_link_update)(struct dsa_switch *ds, int port,
 352                                 struct fixed_phy_status *st);
 353
 354         /*
 355          * ethtool hardware statistics.
 356          */
 357         void    (*get_strings)(struct dsa_switch *ds, int port, uint8_t *data);
 358         void    (*get_ethtool_stats)(struct dsa_switch *ds,
 359                                      int port, uint64_t *data);
 360         int     (*get_sset_count)(struct dsa_switch *ds);
 361
 362         /*
 363          * ethtool Wake-on-LAN
 364          */
 365         void    (*get_wol)(struct dsa_switch *ds, int port,
 366                            struct ethtool_wolinfo *w);
 367         int     (*set_wol)(struct dsa_switch *ds, int port,
 368                            struct ethtool_wolinfo *w);
 369
 370         /*
 371          * Suspend and resume
 372          */
 373         int     (*suspend)(struct dsa_switch *ds);
 374         int     (*resume)(struct dsa_switch *ds);
 375
 376         /*
 377          * Port enable/disable
 378          */
 379         int     (*port_enable)(struct dsa_switch *ds, int port,
 380                                struct phy_device *phy);
 381         void    (*port_disable)(struct dsa_switch *ds, int port,
 382                                 struct phy_device *phy);
 383
 384         /*
 385          * Port's MAC EEE settings
 386          */
 387         int     (*set_mac_eee)(struct dsa_switch *ds, int port,
 388                                struct ethtool_eee *e);
 389         int     (*get_mac_eee)(struct dsa_switch *ds, int port,
 390                                struct ethtool_eee *e);
 391
 392         /* EEPROM access */
 393         int     (*get_eeprom_len)(struct dsa_switch *ds);
 394         int     (*get_eeprom)(struct dsa_switch *ds,
 395                               struct ethtool_eeprom *eeprom, u8 *data);
 396         int     (*set_eeprom)(struct dsa_switch *ds,
 397                               struct ethtool_eeprom *eeprom, u8 *data);
 398
 399         /*
 400          * Register access.
 401          */
 402         int     (*get_regs_len)(struct dsa_switch *ds, int port);
 403         void    (*get_regs)(struct dsa_switch *ds, int port,
 404                             struct ethtool_regs *regs, void *p);
 405
 406         /*
 407          * Bridge integration
 408          */
 409         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
 410         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
 411                                     struct net_device *bridge);
 412         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
 413                                      struct net_device *bridge);
 414         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
 415                                       u8 state);
 416         void    (*port_fast_age)(struct dsa_switch *ds, int port);
 417
 418         /*
 419          * VLAN support
 420          */
 421         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
 422                                        bool vlan_filtering);
 423         int (*port_vlan_prepare)(struct dsa_switch *ds, int port,
 424                                  const struct switchdev_obj_port_vlan *vlan);
 425         void (*port_vlan_add)(struct dsa_switch *ds, int port,
 426                               const struct switchdev_obj_port_vlan *vlan);
 427         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
 428                                  const struct switchdev_obj_port_vlan *vlan);
 429         /*
 430          * Forwarding database
 431          */
 432         int     (*port_fdb_add)(struct dsa_switch *ds, int port,
 433                                 const unsigned char *addr, u16 vid);
 434         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
 435                                 const unsigned char *addr, u16 vid);
 436         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
 437                                  dsa_fdb_dump_cb_t *cb, void *data);
 438
 439         /*
 440          * Multicast database
 441          */
 442         int (*port_mdb_prepare)(struct dsa_switch *ds, int port,
 443                                 const struct switchdev_obj_port_mdb *mdb);
 444         void (*port_mdb_add)(struct dsa_switch *ds, int port,
 445                              const struct switchdev_obj_port_mdb *mdb);
 446         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
 447                                 const struct switchdev_obj_port_mdb *mdb);
 448         /*
 449          * RXNFC
 450          */
 451         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
 452                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
 453         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
 454                              struct ethtool_rxnfc *nfc);
 455
 456         /*
 457          * TC integration
 458          */
 459         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
 460                                    struct dsa_mall_mirror_tc_entry *mirror,
 461                                    bool ingress);
 462         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
 463                                    struct dsa_mall_mirror_tc_entry *mirror);
 464
 465         /*
 466          * Cross-chip operations
 467          */
 468         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index,
 469                                          int port, struct net_device *br);
 470         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index,
 471                                           int port, struct net_device *br);
 472 };
 473
 474 struct dsa_switch_driver {
 475         struct list_head        list;
 476         const struct dsa_switch_ops *ops;
 477 };
 478
 479 #if IS_ENABLED(CONFIG_NET_DSA_LEGACY)
 480 /* Legacy driver registration */
 481 void register_switch_driver(struct dsa_switch_driver *type);
 482 void unregister_switch_driver(struct dsa_switch_driver *type);
 483 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev);
 484
 485 #else
 486 static inline void register_switch_driver(struct dsa_switch_driver *type) { }
 487 static inline void unregister_switch_driver(struct dsa_switch_driver *type) { }
 488 static inline struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev)
 489 {
 490         return NULL;
 491 }
 492 #endif
 493 struct net_device *dsa_dev_to_net_device(struct device *dev);
 494
 495 /* Keep inline for faster access in hot path */
 496 static inline bool netdev_uses_dsa(struct net_device *dev)
 497 {
 498 #if IS_ENABLED(CONFIG_NET_DSA)
 499         return dev->dsa_ptr && dev->dsa_ptr->rcv;
 500 #endif
 501         return false;
 502 }
 503
 504 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n);
 505 void dsa_unregister_switch(struct dsa_switch *ds);
 506 int dsa_register_switch(struct dsa_switch *ds);
 507 #ifdef CONFIG_PM_SLEEP
 508 int dsa_switch_suspend(struct dsa_switch *ds);
 509 int dsa_switch_resume(struct dsa_switch *ds);
 510 #else
 511 static inline int dsa_switch_suspend(struct dsa_switch *ds)
 512 {
 513         return 0;
 514 }
 515 static inline int dsa_switch_resume(struct dsa_switch *ds)
 516 {
 517         return 0;
 518 }
 519 #endif /* CONFIG_PM_SLEEP */
 520
 521 enum dsa_notifier_type {
 522         DSA_PORT_REGISTER,
 523         DSA_PORT_UNREGISTER,
 524 };
 525
 526 struct dsa_notifier_info {
 527         struct net_device *dev;
 528 };
 529
 530 struct dsa_notifier_register_info {
 531         struct dsa_notifier_info info;  /* must be first */
 532         struct net_device *master;
 533         unsigned int port_number;
 534         unsigned int switch_number;
 535 };
 536
 537 static inline struct net_device *
 538 dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
 539 {
 540         return info->dev;
 541 }
 542
 543 #if IS_ENABLED(CONFIG_NET_DSA)
 544 int register_dsa_notifier(struct notifier_block *nb);
 545 int unregister_dsa_notifier(struct notifier_block *nb);
 546 int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 547                        struct dsa_notifier_info *info);
 548 #else
 549 static inline int register_dsa_notifier(struct notifier_block *nb)
 550 {
 551         return 0;
 552 }
 553
 554 static inline int unregister_dsa_notifier(struct notifier_block *nb)
 555 {
 556         return 0;
 557 }
 558
 559 static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
 560                                      struct dsa_notifier_info *info)
 561 {
 562         return NOTIFY_DONE;
 563 }
 564 #endif
 565
 566 /* Broadcom tag specific helpers to insert and extract queue/port number */
 567 #define BRCM_TAG_SET_PORT_QUEUE(p, q)   ((p) << 8 | q)
 568 #define BRCM_TAG_GET_PORT(v)            ((v) >> 8)
 569 #define BRCM_TAG_GET_QUEUE(v)           ((v) & 0xff)
 570
 571 #endif