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
  24 struct tc_action;
  25 struct phy_device;
  26 struct fixed_phy_status;
  27
  28 enum dsa_tag_protocol {
  29         DSA_TAG_PROTO_NONE = 0,
  30         DSA_TAG_PROTO_DSA,
  31         DSA_TAG_PROTO_TRAILER,
  32         DSA_TAG_PROTO_EDSA,
  33         DSA_TAG_PROTO_BRCM,
  34         DSA_TAG_PROTO_QCA,
  35         DSA_TAG_LAST,           /* MUST BE LAST */
  36 };
  37
  38 #define DSA_MAX_SWITCHES        4
  39 #define DSA_MAX_PORTS           12
  40
  41 #define DSA_RTABLE_NONE         -1
  42
  43 struct dsa_chip_data {
  44         /*
  45          * How to access the switch configuration registers.
  46          */
  47         struct device   *host_dev;
  48         int             sw_addr;
  49
  50         /*
  51          * Reference to network devices
  52          */
  53         struct device   *netdev[DSA_MAX_PORTS];
  54
  55         /* set to size of eeprom if supported by the switch */
  56         int             eeprom_len;
  57
  58         /* Device tree node pointer for this specific switch chip
  59          * used during switch setup in case additional properties
  60          * and resources needs to be used
  61          */
  62         struct device_node *of_node;
  63
  64         /*
  65          * The names of the switch's ports.  Use "cpu" to
  66          * designate the switch port that the cpu is connected to,
  67          * "dsa" to indicate that this port is a DSA link to
  68          * another switch, NULL to indicate the port is unused,
  69          * or any other string to indicate this is a physical port.
  70          */
  71         char            *port_names[DSA_MAX_PORTS];
  72         struct device_node *port_dn[DSA_MAX_PORTS];
  73
  74         /*
  75          * An array of which element [a] indicates which port on this
  76          * switch should be used to send packets to that are destined
  77          * for switch a. Can be NULL if there is only one switch chip.
  78          */
  79         s8              rtable[DSA_MAX_SWITCHES];
  80 };
  81
  82 struct dsa_platform_data {
  83         /*
  84          * Reference to a Linux network interface that connects
  85          * to the root switch chip of the tree.
  86          */
  87         struct device   *netdev;
  88         struct net_device *of_netdev;
  89
  90         /*
  91          * Info structs describing each of the switch chips
  92          * connected via this network interface.
  93          */
  94         int             nr_chips;
  95         struct dsa_chip_data    *chip;
  96 };
  97
  98 struct packet_type;
  99
 100 struct dsa_switch_tree {
 101         struct list_head        list;
 102
 103         /* Notifier chain for switch-wide events */
 104         struct raw_notifier_head        nh;
 105
 106         /* Tree identifier */
 107         u32 tree;
 108
 109         /* Number of switches attached to this tree */
 110         struct kref refcount;
 111
 112         /* Has this tree been applied to the hardware? */
 113         bool applied;
 114
 115         /*
 116          * Configuration data for the platform device that owns
 117          * this dsa switch tree instance.
 118          */
 119         struct dsa_platform_data        *pd;
 120
 121         /*
 122          * Reference to network device to use, and which tagging
 123          * protocol to use.
 124          */
 125         struct net_device       *master_netdev;
 126         int                     (*rcv)(struct sk_buff *skb,
 127                                        struct net_device *dev,
 128                                        struct packet_type *pt,
 129                                        struct net_device *orig_dev);
 130
 131         /*
 132          * Original copy of the master netdev ethtool_ops
 133          */
 134         struct ethtool_ops      master_ethtool_ops;
 135         const struct ethtool_ops *master_orig_ethtool_ops;
 136
 137         /*
 138          * The switch and port to which the CPU is attached.
 139          */
 140         struct dsa_switch       *cpu_switch;
 141         s8                      cpu_port;
 142
 143         /*
 144          * Data for the individual switch chips.
 145          */
 146         struct dsa_switch       *ds[DSA_MAX_SWITCHES];
 147
 148         /*
 149          * Tagging protocol operations for adding and removing an
 150          * encapsulation tag.
 151          */
 152         const struct dsa_device_ops *tag_ops;
 153 };
 154
 155 /* TC matchall action types, only mirroring for now */
 156 enum dsa_port_mall_action_type {
 157         DSA_PORT_MALL_MIRROR,
 158 };
 159
 160 /* TC mirroring entry */
 161 struct dsa_mall_mirror_tc_entry {
 162         u8 to_local_port;
 163         bool ingress;
 164 };
 165
 166 /* TC matchall entry */
 167 struct dsa_mall_tc_entry {
 168         struct list_head list;
 169         unsigned long cookie;
 170         enum dsa_port_mall_action_type type;
 171         union {
 172                 struct dsa_mall_mirror_tc_entry mirror;
 173         };
 174 };
 175
 176
 177 struct dsa_port {
 178         struct dsa_switch       *ds;
 179         unsigned int            index;
 180         const char              *name;
 181         struct net_device       *netdev;
 182         struct device_node      *dn;
 183         unsigned int            ageing_time;
 184         u8                      stp_state;
 185         struct net_device       *bridge_dev;
 186         struct devlink_port     devlink_port;
 187 };
 188
 189 struct dsa_switch {
 190         struct device *dev;
 191
 192         /*
 193          * Parent switch tree, and switch index.
 194          */
 195         struct dsa_switch_tree  *dst;
 196         int                     index;
 197
 198         /* Listener for switch fabric events */
 199         struct notifier_block   nb;
 200
 201         /*
 202          * Give the switch driver somewhere to hang its private data
 203          * structure.
 204          */
 205         void *priv;
 206
 207         /*
 208          * Configuration data for this switch.
 209          */
 210         struct dsa_chip_data    *cd;
 211
 212         /*
 213          * The switch operations.
 214          */
 215         const struct dsa_switch_ops     *ops;
 216
 217         /*
 218          * An array of which element [a] indicates which port on this
 219          * switch should be used to send packets to that are destined
 220          * for switch a. Can be NULL if there is only one switch chip.
 221          */
 222         s8              rtable[DSA_MAX_SWITCHES];
 223
 224         /*
 225          * The lower device this switch uses to talk to the host
 226          */
 227         struct net_device *master_netdev;
 228
 229         /*
 230          * Slave mii_bus and devices for the individual ports.
 231          */
 232         u32                     dsa_port_mask;
 233         u32                     cpu_port_mask;
 234         u32                     enabled_port_mask;
 235         u32                     phys_mii_mask;
 236         struct mii_bus          *slave_mii_bus;
 237
 238         /* Ageing Time limits in msecs */
 239         unsigned int ageing_time_min;
 240         unsigned int ageing_time_max;
 241
 242         /* devlink used to represent this switch device */
 243         struct devlink          *devlink;
 244
 245         /* Dynamically allocated ports, keep last */
 246         size_t num_ports;
 247         struct dsa_port ports[];
 248 };
 249
 250 static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
 251 {
 252         return !!(ds == ds->dst->cpu_switch && p == ds->dst->cpu_port);
 253 }
 254
 255 static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
 256 {
 257         return !!((ds->dsa_port_mask) & (1 << p));
 258 }
 259
 260 static inline bool dsa_is_normal_port(struct dsa_switch *ds, int p)
 261 {
 262         return !dsa_is_cpu_port(ds, p) && !dsa_is_dsa_port(ds, p);
 263 }
 264
 265 static inline bool dsa_is_port_initialized(struct dsa_switch *ds, int p)
 266 {
 267         return ds->enabled_port_mask & (1 << p) && ds->ports[p].netdev;
 268 }
 269
 270 static inline u8 dsa_upstream_port(struct dsa_switch *ds)
 271 {
 272         struct dsa_switch_tree *dst = ds->dst;
 273
 274         /*
 275          * If this is the root switch (i.e. the switch that connects
 276          * to the CPU), return the cpu port number on this switch.
 277          * Else return the (DSA) port number that connects to the
 278          * switch that is one hop closer to the cpu.
 279          */
 280         if (dst->cpu_switch == ds)
 281                 return dst->cpu_port;
 282         else
 283                 return ds->rtable[dst->cpu_switch->index];
 284 }
 285
 286 struct switchdev_trans;
 287 struct switchdev_obj;
 288 struct switchdev_obj_port_fdb;
 289 struct switchdev_obj_port_mdb;
 290 struct switchdev_obj_port_vlan;
 291
 292 #define DSA_NOTIFIER_BRIDGE_JOIN                1
 293 #define DSA_NOTIFIER_BRIDGE_LEAVE               2
 294
 295 /* DSA_NOTIFIER_BRIDGE_* */
 296 struct dsa_notifier_bridge_info {
 297         struct net_device *br;
 298         int sw_index;
 299         int port;
 300 };
 301
 302 struct dsa_switch_ops {
 303         /*
 304          * Probing and setup.
 305          */
 306         const char      *(*probe)(struct device *dsa_dev,
 307                                   struct device *host_dev, int sw_addr,
 308                                   void **priv);
 309
 310         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds);
 311
 312         int     (*setup)(struct dsa_switch *ds);
 313         int     (*set_addr)(struct dsa_switch *ds, u8 *addr);
 314         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
 315
 316         /*
 317          * Access to the switch's PHY registers.
 318          */
 319         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
 320         int     (*phy_write)(struct dsa_switch *ds, int port,
 321                              int regnum, u16 val);
 322
 323         /*
 324          * Link state adjustment (called from libphy)
 325          */
 326         void    (*adjust_link)(struct dsa_switch *ds, int port,
 327                                 struct phy_device *phydev);
 328         void    (*fixed_link_update)(struct dsa_switch *ds, int port,
 329                                 struct fixed_phy_status *st);
 330
 331         /*
 332          * ethtool hardware statistics.
 333          */
 334         void    (*get_strings)(struct dsa_switch *ds, int port, uint8_t *data);
 335         void    (*get_ethtool_stats)(struct dsa_switch *ds,
 336                                      int port, uint64_t *data);
 337         int     (*get_sset_count)(struct dsa_switch *ds);
 338
 339         /*
 340          * ethtool Wake-on-LAN
 341          */
 342         void    (*get_wol)(struct dsa_switch *ds, int port,
 343                            struct ethtool_wolinfo *w);
 344         int     (*set_wol)(struct dsa_switch *ds, int port,
 345                            struct ethtool_wolinfo *w);
 346
 347         /*
 348          * Suspend and resume
 349          */
 350         int     (*suspend)(struct dsa_switch *ds);
 351         int     (*resume)(struct dsa_switch *ds);
 352
 353         /*
 354          * Port enable/disable
 355          */
 356         int     (*port_enable)(struct dsa_switch *ds, int port,
 357                                struct phy_device *phy);
 358         void    (*port_disable)(struct dsa_switch *ds, int port,
 359                                 struct phy_device *phy);
 360
 361         /*
 362          * EEE setttings
 363          */
 364         int     (*set_eee)(struct dsa_switch *ds, int port,
 365                            struct phy_device *phydev,
 366                            struct ethtool_eee *e);
 367         int     (*get_eee)(struct dsa_switch *ds, int port,
 368                            struct ethtool_eee *e);
 369
 370         /* EEPROM access */
 371         int     (*get_eeprom_len)(struct dsa_switch *ds);
 372         int     (*get_eeprom)(struct dsa_switch *ds,
 373                               struct ethtool_eeprom *eeprom, u8 *data);
 374         int     (*set_eeprom)(struct dsa_switch *ds,
 375                               struct ethtool_eeprom *eeprom, u8 *data);
 376
 377         /*
 378          * Register access.
 379          */
 380         int     (*get_regs_len)(struct dsa_switch *ds, int port);
 381         void    (*get_regs)(struct dsa_switch *ds, int port,
 382                             struct ethtool_regs *regs, void *p);
 383
 384         /*
 385          * Bridge integration
 386          */
 387         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
 388         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
 389                                     struct net_device *bridge);
 390         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
 391                                      struct net_device *bridge);
 392         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
 393                                       u8 state);
 394         void    (*port_fast_age)(struct dsa_switch *ds, int port);
 395
 396         /*
 397          * VLAN support
 398          */
 399         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
 400                                        bool vlan_filtering);
 401         int     (*port_vlan_prepare)(struct dsa_switch *ds, int port,
 402                                      const struct switchdev_obj_port_vlan *vlan,
 403                                      struct switchdev_trans *trans);
 404         void    (*port_vlan_add)(struct dsa_switch *ds, int port,
 405                                  const struct switchdev_obj_port_vlan *vlan,
 406                                  struct switchdev_trans *trans);
 407         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
 408                                  const struct switchdev_obj_port_vlan *vlan);
 409         int     (*port_vlan_dump)(struct dsa_switch *ds, int port,
 410                                   struct switchdev_obj_port_vlan *vlan,
 411                                   int (*cb)(struct switchdev_obj *obj));
 412
 413         /*
 414          * Forwarding database
 415          */
 416         int     (*port_fdb_prepare)(struct dsa_switch *ds, int port,
 417                                     const struct switchdev_obj_port_fdb *fdb,
 418                                     struct switchdev_trans *trans);
 419         void    (*port_fdb_add)(struct dsa_switch *ds, int port,
 420                                 const struct switchdev_obj_port_fdb *fdb,
 421                                 struct switchdev_trans *trans);
 422         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
 423                                 const struct switchdev_obj_port_fdb *fdb);
 424         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
 425                                  struct switchdev_obj_port_fdb *fdb,
 426                                  int (*cb)(struct switchdev_obj *obj));
 427
 428         /*
 429          * Multicast database
 430          */
 431         int     (*port_mdb_prepare)(struct dsa_switch *ds, int port,
 432                                     const struct switchdev_obj_port_mdb *mdb,
 433                                     struct switchdev_trans *trans);
 434         void    (*port_mdb_add)(struct dsa_switch *ds, int port,
 435                                 const struct switchdev_obj_port_mdb *mdb,
 436                                 struct switchdev_trans *trans);
 437         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
 438                                 const struct switchdev_obj_port_mdb *mdb);
 439         int     (*port_mdb_dump)(struct dsa_switch *ds, int port,
 440                                  struct switchdev_obj_port_mdb *mdb,
 441                                  int (*cb)(struct switchdev_obj *obj));
 442
 443         /*
 444          * RXNFC
 445          */
 446         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
 447                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
 448         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
 449                              struct ethtool_rxnfc *nfc);
 450
 451         /*
 452          * TC integration
 453          */
 454         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
 455                                    struct dsa_mall_mirror_tc_entry *mirror,
 456                                    bool ingress);
 457         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
 458                                    struct dsa_mall_mirror_tc_entry *mirror);
 459
 460         /*
 461          * Cross-chip operations
 462          */
 463         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index,
 464                                          int port, struct net_device *br);
 465         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index,
 466                                           int port, struct net_device *br);
 467 };
 468
 469 struct dsa_switch_driver {
 470         struct list_head        list;
 471         const struct dsa_switch_ops *ops;
 472 };
 473
 474 void register_switch_driver(struct dsa_switch_driver *type);
 475 void unregister_switch_driver(struct dsa_switch_driver *type);
 476 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev);
 477 struct net_device *dsa_dev_to_net_device(struct device *dev);
 478
 479 static inline bool dsa_uses_tagged_protocol(struct dsa_switch_tree *dst)
 480 {
 481         return dst->rcv != NULL;
 482 }
 483
 484 static inline bool netdev_uses_dsa(struct net_device *dev)
 485 {
 486 #if IS_ENABLED(CONFIG_NET_DSA)
 487         if (dev->dsa_ptr != NULL)
 488                 return dsa_uses_tagged_protocol(dev->dsa_ptr);
 489 #endif
 490         return false;
 491 }
 492
 493 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n);
 494 void dsa_unregister_switch(struct dsa_switch *ds);
 495 int dsa_register_switch(struct dsa_switch *ds, struct device *dev);
 496 #ifdef CONFIG_PM_SLEEP
 497 int dsa_switch_suspend(struct dsa_switch *ds);
 498 int dsa_switch_resume(struct dsa_switch *ds);
 499 #else
 500 static inline int dsa_switch_suspend(struct dsa_switch *ds)
 501 {
 502         return 0;
 503 }
 504 static inline int dsa_switch_resume(struct dsa_switch *ds)
 505 {
 506         return 0;
 507 }
 508 #endif /* CONFIG_PM_SLEEP */
 509
 510 #endif