~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/dsa.h

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #define DSA_TAG_PROTO_AR9331_VALUE              16
 47 #define DSA_TAG_PROTO_RTL4_A_VALUE              17
 48 
 49 enum dsa_tag_protocol {
 50         DSA_TAG_PROTO_NONE              = DSA_TAG_PROTO_NONE_VALUE,
 51         DSA_TAG_PROTO_BRCM              = DSA_TAG_PROTO_BRCM_VALUE,
 52         DSA_TAG_PROTO_BRCM_PREPEND      = DSA_TAG_PROTO_BRCM_PREPEND_VALUE,
 53         DSA_TAG_PROTO_DSA               = DSA_TAG_PROTO_DSA_VALUE,
 54         DSA_TAG_PROTO_EDSA              = DSA_TAG_PROTO_EDSA_VALUE,
 55         DSA_TAG_PROTO_GSWIP             = DSA_TAG_PROTO_GSWIP_VALUE,
 56         DSA_TAG_PROTO_KSZ9477           = DSA_TAG_PROTO_KSZ9477_VALUE,
 57         DSA_TAG_PROTO_KSZ9893           = DSA_TAG_PROTO_KSZ9893_VALUE,
 58         DSA_TAG_PROTO_LAN9303           = DSA_TAG_PROTO_LAN9303_VALUE,
 59         DSA_TAG_PROTO_MTK               = DSA_TAG_PROTO_MTK_VALUE,
 60         DSA_TAG_PROTO_QCA               = DSA_TAG_PROTO_QCA_VALUE,
 61         DSA_TAG_PROTO_TRAILER           = DSA_TAG_PROTO_TRAILER_VALUE,
 62         DSA_TAG_PROTO_8021Q             = DSA_TAG_PROTO_8021Q_VALUE,
 63         DSA_TAG_PROTO_SJA1105           = DSA_TAG_PROTO_SJA1105_VALUE,
 64         DSA_TAG_PROTO_KSZ8795           = DSA_TAG_PROTO_KSZ8795_VALUE,
 65         DSA_TAG_PROTO_OCELOT            = DSA_TAG_PROTO_OCELOT_VALUE,
 66         DSA_TAG_PROTO_AR9331            = DSA_TAG_PROTO_AR9331_VALUE,
 67         DSA_TAG_PROTO_RTL4_A            = DSA_TAG_PROTO_RTL4_A_VALUE,
 68 };
 69 
 70 struct packet_type;
 71 struct dsa_switch;
 72 
 73 struct dsa_device_ops {
 74         struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev);
 75         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
 76                                struct packet_type *pt);
 77         void (*flow_dissect)(const struct sk_buff *skb, __be16 *proto,
 78                              int *offset);
 79         /* Used to determine which traffic should match the DSA filter in
 80          * eth_type_trans, and which, if any, should bypass it and be processed
 81          * as regular on the master net device.
 82          */
 83         bool (*filter)(const struct sk_buff *skb, struct net_device *dev);
 84         unsigned int overhead;
 85         const char *name;
 86         enum dsa_tag_protocol proto;
 87         /* Some tagging protocols either mangle or shift the destination MAC
 88          * address, in which case the DSA master would drop packets on ingress
 89          * if what it understands out of the destination MAC address is not in
 90          * its RX filter.
 91          */
 92         bool promisc_on_master;
 93         bool tail_tag;
 94 };
 95 
 96 /* This structure defines the control interfaces that are overlayed by the
 97  * DSA layer on top of the DSA CPU/management net_device instance. This is
 98  * used by the core net_device layer while calling various net_device_ops
 99  * function pointers.
100  */
101 struct dsa_netdevice_ops {
102         int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr,
103                             int cmd);
104 };
105 
106 #define DSA_TAG_DRIVER_ALIAS "dsa_tag-"
107 #define MODULE_ALIAS_DSA_TAG_DRIVER(__proto)                            \
108         MODULE_ALIAS(DSA_TAG_DRIVER_ALIAS __stringify(__proto##_VALUE))
109 
110 struct dsa_skb_cb {
111         struct sk_buff *clone;
112 };
113 
114 struct __dsa_skb_cb {
115         struct dsa_skb_cb cb;
116         u8 priv[48 - sizeof(struct dsa_skb_cb)];
117 };
118 
119 #define DSA_SKB_CB(skb) ((struct dsa_skb_cb *)((skb)->cb))
120 
121 #define DSA_SKB_CB_PRIV(skb)                    \
122         ((void *)(skb)->cb + offsetof(struct __dsa_skb_cb, priv))
123 
124 struct dsa_switch_tree {
125         struct list_head        list;
126 
127         /* Notifier chain for switch-wide events */
128         struct raw_notifier_head        nh;
129 
130         /* Tree identifier */
131         unsigned int index;
132 
133         /* Number of switches attached to this tree */
134         struct kref refcount;
135 
136         /* Has this tree been applied to the hardware? */
137         bool setup;
138 
139         /*
140          * Configuration data for the platform device that owns
141          * this dsa switch tree instance.
142          */
143         struct dsa_platform_data        *pd;
144 
145         /* List of switch ports */
146         struct list_head ports;
147 
148         /* List of DSA links composing the routing table */
149         struct list_head rtable;
150 };
151 
152 /* TC matchall action types */
153 enum dsa_port_mall_action_type {
154         DSA_PORT_MALL_MIRROR,
155         DSA_PORT_MALL_POLICER,
156 };
157 
158 /* TC mirroring entry */
159 struct dsa_mall_mirror_tc_entry {
160         u8 to_local_port;
161         bool ingress;
162 };
163 
164 /* TC port policer entry */
165 struct dsa_mall_policer_tc_entry {
166         u32 burst;
167         u64 rate_bytes_per_sec;
168 };
169 
170 /* TC matchall entry */
171 struct dsa_mall_tc_entry {
172         struct list_head list;
173         unsigned long cookie;
174         enum dsa_port_mall_action_type type;
175         union {
176                 struct dsa_mall_mirror_tc_entry mirror;
177                 struct dsa_mall_policer_tc_entry policer;
178         };
179 };
180 
181 
182 struct dsa_port {
183         /* A CPU port is physically connected to a master device.
184          * A user port exposed to userspace has a slave device.
185          */
186         union {
187                 struct net_device *master;
188                 struct net_device *slave;
189         };
190 
191         /* CPU port tagging operations used by master or slave devices */
192         const struct dsa_device_ops *tag_ops;
193 
194         /* Copies for faster access in master receive hot path */
195         struct dsa_switch_tree *dst;
196         struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
197                                struct packet_type *pt);
198         bool (*filter)(const struct sk_buff *skb, struct net_device *dev);
199 
200         enum {
201                 DSA_PORT_TYPE_UNUSED = 0,
202                 DSA_PORT_TYPE_CPU,
203                 DSA_PORT_TYPE_DSA,
204                 DSA_PORT_TYPE_USER,
205         } type;
206 
207         struct dsa_switch       *ds;
208         unsigned int            index;
209         const char              *name;
210         struct dsa_port         *cpu_dp;
211         const char              *mac;
212         struct device_node      *dn;
213         unsigned int            ageing_time;
214         bool                    vlan_filtering;
215         u8                      stp_state;
216         struct net_device       *bridge_dev;
217         struct devlink_port     devlink_port;
218         bool                    devlink_port_setup;
219         struct phylink          *pl;
220         struct phylink_config   pl_config;
221 
222         struct list_head list;
223 
224         /*
225          * Give the switch driver somewhere to hang its per-port private data
226          * structures (accessible from the tagger).
227          */
228         void *priv;
229 
230         /*
231          * Original copy of the master netdev ethtool_ops
232          */
233         const struct ethtool_ops *orig_ethtool_ops;
234 
235         /*
236          * Original copy of the master netdev net_device_ops
237          */
238         const struct dsa_netdevice_ops *netdev_ops;
239 
240         bool setup;
241 };
242 
243 /* TODO: ideally DSA ports would have a single dp->link_dp member,
244  * and no dst->rtable nor this struct dsa_link would be needed,
245  * but this would require some more complex tree walking,
246  * so keep it stupid at the moment and list them all.
247  */
248 struct dsa_link {
249         struct dsa_port *dp;
250         struct dsa_port *link_dp;
251         struct list_head list;
252 };
253 
254 struct dsa_switch {
255         bool setup;
256 
257         struct device *dev;
258 
259         /*
260          * Parent switch tree, and switch index.
261          */
262         struct dsa_switch_tree  *dst;
263         unsigned int            index;
264 
265         /* Listener for switch fabric events */
266         struct notifier_block   nb;
267 
268         /*
269          * Give the switch driver somewhere to hang its private data
270          * structure.
271          */
272         void *priv;
273 
274         /*
275          * Configuration data for this switch.
276          */
277         struct dsa_chip_data    *cd;
278 
279         /*
280          * The switch operations.
281          */
282         const struct dsa_switch_ops     *ops;
283 
284         /*
285          * Slave mii_bus and devices for the individual ports.
286          */
287         u32                     phys_mii_mask;
288         struct mii_bus          *slave_mii_bus;
289 
290         /* Ageing Time limits in msecs */
291         unsigned int ageing_time_min;
292         unsigned int ageing_time_max;
293 
294         /* devlink used to represent this switch device */
295         struct devlink          *devlink;
296 
297         /* Number of switch port queues */
298         unsigned int            num_tx_queues;
299 
300         /* Disallow bridge core from requesting different VLAN awareness
301          * settings on ports if not hardware-supported
302          */
303         bool                    vlan_filtering_is_global;
304 
305         /* Pass .port_vlan_add and .port_vlan_del to drivers even for bridges
306          * that have vlan_filtering=0. All drivers should ideally set this (and
307          * then the option would get removed), but it is unknown whether this
308          * would break things or not.
309          */
310         bool                    configure_vlan_while_not_filtering;
311 
312         /* If the switch driver always programs the CPU port as egress tagged
313          * despite the VLAN configuration indicating otherwise, then setting
314          * @untag_bridge_pvid will force the DSA receive path to pop the bridge's
315          * default_pvid VLAN tagged frames to offer a consistent behavior
316          * between a vlan_filtering=0 and vlan_filtering=1 bridge device.
317          */
318         bool                    untag_bridge_pvid;
319 
320         /* In case vlan_filtering_is_global is set, the VLAN awareness state
321          * should be retrieved from here and not from the per-port settings.
322          */
323         bool                    vlan_filtering;
324 
325         /* MAC PCS does not provide link state change interrupt, and requires
326          * polling. Flag passed on to PHYLINK.
327          */
328         bool                    pcs_poll;
329 
330         /* For switches that only have the MRU configurable. To ensure the
331          * configured MTU is not exceeded, normalization of MRU on all bridged
332          * interfaces is needed.
333          */
334         bool                    mtu_enforcement_ingress;
335 
336         size_t num_ports;
337 };
338 
339 static inline struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p)
340 {
341         struct dsa_switch_tree *dst = ds->dst;
342         struct dsa_port *dp;
343 
344         list_for_each_entry(dp, &dst->ports, list)
345                 if (dp->ds == ds && dp->index == p)
346                         return dp;
347 
348         return NULL;
349 }
350 
351 static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
352 {
353         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
354 }
355 
356 static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
357 {
358         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
359 }
360 
361 static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
362 {
363         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
364 }
365 
366 static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
367 {
368         return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
369 }
370 
371 static inline u32 dsa_user_ports(struct dsa_switch *ds)
372 {
373         u32 mask = 0;
374         int p;
375 
376         for (p = 0; p < ds->num_ports; p++)
377                 if (dsa_is_user_port(ds, p))
378                         mask |= BIT(p);
379 
380         return mask;
381 }
382 
383 /* Return the local port used to reach an arbitrary switch device */
384 static inline unsigned int dsa_routing_port(struct dsa_switch *ds, int device)
385 {
386         struct dsa_switch_tree *dst = ds->dst;
387         struct dsa_link *dl;
388 
389         list_for_each_entry(dl, &dst->rtable, list)
390                 if (dl->dp->ds == ds && dl->link_dp->ds->index == device)
391                         return dl->dp->index;
392 
393         return ds->num_ports;
394 }
395 
396 /* Return the local port used to reach an arbitrary switch port */
397 static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
398                                             int port)
399 {
400         if (device == ds->index)
401                 return port;
402         else
403                 return dsa_routing_port(ds, device);
404 }
405 
406 /* Return the local port used to reach the dedicated CPU port */
407 static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
408 {
409         const struct dsa_port *dp = dsa_to_port(ds, port);
410         const struct dsa_port *cpu_dp = dp->cpu_dp;
411 
412         if (!cpu_dp)
413                 return port;
414 
415         return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
416 }
417 
418 static inline bool dsa_port_is_vlan_filtering(const struct dsa_port *dp)
419 {
420         const struct dsa_switch *ds = dp->ds;
421 
422         if (ds->vlan_filtering_is_global)
423                 return ds->vlan_filtering;
424         else
425                 return dp->vlan_filtering;
426 }
427 
428 typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
429                               bool is_static, void *data);
430 struct dsa_switch_ops {
431         enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
432                                                   int port,
433                                                   enum dsa_tag_protocol mprot);
434 
435         int     (*setup)(struct dsa_switch *ds);
436         void    (*teardown)(struct dsa_switch *ds);
437         u32     (*get_phy_flags)(struct dsa_switch *ds, int port);
438 
439         /*
440          * Access to the switch's PHY registers.
441          */
442         int     (*phy_read)(struct dsa_switch *ds, int port, int regnum);
443         int     (*phy_write)(struct dsa_switch *ds, int port,
444                              int regnum, u16 val);
445 
446         /*
447          * Link state adjustment (called from libphy)
448          */
449         void    (*adjust_link)(struct dsa_switch *ds, int port,
450                                 struct phy_device *phydev);
451         void    (*fixed_link_update)(struct dsa_switch *ds, int port,
452                                 struct fixed_phy_status *st);
453 
454         /*
455          * PHYLINK integration
456          */
457         void    (*phylink_validate)(struct dsa_switch *ds, int port,
458                                     unsigned long *supported,
459                                     struct phylink_link_state *state);
460         int     (*phylink_mac_link_state)(struct dsa_switch *ds, int port,
461                                           struct phylink_link_state *state);
462         void    (*phylink_mac_config)(struct dsa_switch *ds, int port,
463                                       unsigned int mode,
464                                       const struct phylink_link_state *state);
465         void    (*phylink_mac_an_restart)(struct dsa_switch *ds, int port);
466         void    (*phylink_mac_link_down)(struct dsa_switch *ds, int port,
467                                          unsigned int mode,
468                                          phy_interface_t interface);
469         void    (*phylink_mac_link_up)(struct dsa_switch *ds, int port,
470                                        unsigned int mode,
471                                        phy_interface_t interface,
472                                        struct phy_device *phydev,
473                                        int speed, int duplex,
474                                        bool tx_pause, bool rx_pause);
475         void    (*phylink_fixed_state)(struct dsa_switch *ds, int port,
476                                        struct phylink_link_state *state);
477         /*
478          * ethtool hardware statistics.
479          */
480         void    (*get_strings)(struct dsa_switch *ds, int port,
481                                u32 stringset, uint8_t *data);
482         void    (*get_ethtool_stats)(struct dsa_switch *ds,
483                                      int port, uint64_t *data);
484         int     (*get_sset_count)(struct dsa_switch *ds, int port, int sset);
485         void    (*get_ethtool_phy_stats)(struct dsa_switch *ds,
486                                          int port, uint64_t *data);
487 
488         /*
489          * ethtool Wake-on-LAN
490          */
491         void    (*get_wol)(struct dsa_switch *ds, int port,
492                            struct ethtool_wolinfo *w);
493         int     (*set_wol)(struct dsa_switch *ds, int port,
494                            struct ethtool_wolinfo *w);
495 
496         /*
497          * ethtool timestamp info
498          */
499         int     (*get_ts_info)(struct dsa_switch *ds, int port,
500                                struct ethtool_ts_info *ts);
501 
502         /*
503          * Suspend and resume
504          */
505         int     (*suspend)(struct dsa_switch *ds);
506         int     (*resume)(struct dsa_switch *ds);
507 
508         /*
509          * Port enable/disable
510          */
511         int     (*port_enable)(struct dsa_switch *ds, int port,
512                                struct phy_device *phy);
513         void    (*port_disable)(struct dsa_switch *ds, int port);
514 
515         /*
516          * Port's MAC EEE settings
517          */
518         int     (*set_mac_eee)(struct dsa_switch *ds, int port,
519                                struct ethtool_eee *e);
520         int     (*get_mac_eee)(struct dsa_switch *ds, int port,
521                                struct ethtool_eee *e);
522 
523         /* EEPROM access */
524         int     (*get_eeprom_len)(struct dsa_switch *ds);
525         int     (*get_eeprom)(struct dsa_switch *ds,
526                               struct ethtool_eeprom *eeprom, u8 *data);
527         int     (*set_eeprom)(struct dsa_switch *ds,
528                               struct ethtool_eeprom *eeprom, u8 *data);
529 
530         /*
531          * Register access.
532          */
533         int     (*get_regs_len)(struct dsa_switch *ds, int port);
534         void    (*get_regs)(struct dsa_switch *ds, int port,
535                             struct ethtool_regs *regs, void *p);
536 
537         /*
538          * Bridge integration
539          */
540         int     (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
541         int     (*port_bridge_join)(struct dsa_switch *ds, int port,
542                                     struct net_device *bridge);
543         void    (*port_bridge_leave)(struct dsa_switch *ds, int port,
544                                      struct net_device *bridge);
545         void    (*port_stp_state_set)(struct dsa_switch *ds, int port,
546                                       u8 state);
547         void    (*port_fast_age)(struct dsa_switch *ds, int port);
548         int     (*port_egress_floods)(struct dsa_switch *ds, int port,
549                                       bool unicast, bool multicast);
550 
551         /*
552          * VLAN support
553          */
554         int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
555                                        bool vlan_filtering,
556                                        struct switchdev_trans *trans);
557         int (*port_vlan_prepare)(struct dsa_switch *ds, int port,
558                                  const struct switchdev_obj_port_vlan *vlan);
559         void (*port_vlan_add)(struct dsa_switch *ds, int port,
560                               const struct switchdev_obj_port_vlan *vlan);
561         int     (*port_vlan_del)(struct dsa_switch *ds, int port,
562                                  const struct switchdev_obj_port_vlan *vlan);
563         /*
564          * Forwarding database
565          */
566         int     (*port_fdb_add)(struct dsa_switch *ds, int port,
567                                 const unsigned char *addr, u16 vid);
568         int     (*port_fdb_del)(struct dsa_switch *ds, int port,
569                                 const unsigned char *addr, u16 vid);
570         int     (*port_fdb_dump)(struct dsa_switch *ds, int port,
571                                  dsa_fdb_dump_cb_t *cb, void *data);
572 
573         /*
574          * Multicast database
575          */
576         int (*port_mdb_prepare)(struct dsa_switch *ds, int port,
577                                 const struct switchdev_obj_port_mdb *mdb);
578         void (*port_mdb_add)(struct dsa_switch *ds, int port,
579                              const struct switchdev_obj_port_mdb *mdb);
580         int     (*port_mdb_del)(struct dsa_switch *ds, int port,
581                                 const struct switchdev_obj_port_mdb *mdb);
582         /*
583          * RXNFC
584          */
585         int     (*get_rxnfc)(struct dsa_switch *ds, int port,
586                              struct ethtool_rxnfc *nfc, u32 *rule_locs);
587         int     (*set_rxnfc)(struct dsa_switch *ds, int port,
588                              struct ethtool_rxnfc *nfc);
589 
590         /*
591          * TC integration
592          */
593         int     (*cls_flower_add)(struct dsa_switch *ds, int port,
594                                   struct flow_cls_offload *cls, bool ingress);
595         int     (*cls_flower_del)(struct dsa_switch *ds, int port,
596                                   struct flow_cls_offload *cls, bool ingress);
597         int     (*cls_flower_stats)(struct dsa_switch *ds, int port,
598                                     struct flow_cls_offload *cls, bool ingress);
599         int     (*port_mirror_add)(struct dsa_switch *ds, int port,
600                                    struct dsa_mall_mirror_tc_entry *mirror,
601                                    bool ingress);
602         void    (*port_mirror_del)(struct dsa_switch *ds, int port,
603                                    struct dsa_mall_mirror_tc_entry *mirror);
604         int     (*port_policer_add)(struct dsa_switch *ds, int port,
605                                     struct dsa_mall_policer_tc_entry *policer);
606         void    (*port_policer_del)(struct dsa_switch *ds, int port);
607         int     (*port_setup_tc)(struct dsa_switch *ds, int port,
608                                  enum tc_setup_type type, void *type_data);
609 
610         /*
611          * Cross-chip operations
612          */
613         int     (*crosschip_bridge_join)(struct dsa_switch *ds, int tree_index,
614                                          int sw_index, int port,
615                                          struct net_device *br);
616         void    (*crosschip_bridge_leave)(struct dsa_switch *ds, int tree_index,
617                                           int sw_index, int port,
618                                           struct net_device *br);
619 
620         /*
621          * PTP functionality
622          */
623         int     (*port_hwtstamp_get)(struct dsa_switch *ds, int port,
624                                      struct ifreq *ifr);
625         int     (*port_hwtstamp_set)(struct dsa_switch *ds, int port,
626                                      struct ifreq *ifr);
627         bool    (*port_txtstamp)(struct dsa_switch *ds, int port,
628                                  struct sk_buff *clone, unsigned int type);
629         bool    (*port_rxtstamp)(struct dsa_switch *ds, int port,
630                                  struct sk_buff *skb, unsigned int type);
631 
632         /* Devlink parameters, etc */
633         int     (*devlink_param_get)(struct dsa_switch *ds, u32 id,
634                                      struct devlink_param_gset_ctx *ctx);
635         int     (*devlink_param_set)(struct dsa_switch *ds, u32 id,
636                                      struct devlink_param_gset_ctx *ctx);
637         int     (*devlink_info_get)(struct dsa_switch *ds,
638                                     struct devlink_info_req *req,
639                                     struct netlink_ext_ack *extack);
640 
641         /*
642          * MTU change functionality. Switches can also adjust their MRU through
643          * this method. By MTU, one understands the SDU (L2 payload) length.
644          * If the switch needs to account for the DSA tag on the CPU port, this
645          * method needs to do so privately.
646          */
647         int     (*port_change_mtu)(struct dsa_switch *ds, int port,
648                                    int new_mtu);
649         int     (*port_max_mtu)(struct dsa_switch *ds, int port);
650 };
651 
652 #define DSA_DEVLINK_PARAM_DRIVER(_id, _name, _type, _cmodes)            \
653         DEVLINK_PARAM_DRIVER(_id, _name, _type, _cmodes,                \
654                              dsa_devlink_param_get, dsa_devlink_param_set, NULL)
655 
656 int dsa_devlink_param_get(struct devlink *dl, u32 id,
657                           struct devlink_param_gset_ctx *ctx);
658 int dsa_devlink_param_set(struct devlink *dl, u32 id,
659                           struct devlink_param_gset_ctx *ctx);
660 int dsa_devlink_params_register(struct dsa_switch *ds,
661                                 const struct devlink_param *params,
662                                 size_t params_count);
663 void dsa_devlink_params_unregister(struct dsa_switch *ds,
664                                    const struct devlink_param *params,
665                                    size_t params_count);
666 int dsa_devlink_resource_register(struct dsa_switch *ds,
667                                   const char *resource_name,
668                                   u64 resource_size,
669                                   u64 resource_id,
670                                   u64 parent_resource_id,
671                                   const struct devlink_resource_size_params *size_params);
672 
673 void dsa_devlink_resources_unregister(struct dsa_switch *ds);
674 
675 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
676                                            u64 resource_id,
677                                            devlink_resource_occ_get_t *occ_get,
678                                            void *occ_get_priv);
679 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
680                                              u64 resource_id);
681 struct devlink_region *
682 dsa_devlink_region_create(struct dsa_switch *ds,
683                           const struct devlink_region_ops *ops,
684                           u32 region_max_snapshots, u64 region_size);
685 struct devlink_region *
686 dsa_devlink_port_region_create(struct dsa_switch *ds,
687                                int port,
688                                const struct devlink_port_region_ops *ops,
689                                u32 region_max_snapshots, u64 region_size);
690 void dsa_devlink_region_destroy(struct devlink_region *region);
691 
692 struct dsa_port *dsa_port_from_netdev(struct net_device *netdev);
693 
694 struct dsa_devlink_priv {
695         struct dsa_switch *ds;
696 };
697 
698 static inline struct dsa_switch *dsa_devlink_to_ds(struct devlink *dl)
699 {
700         struct dsa_devlink_priv *dl_priv = devlink_priv(dl);
701 
702         return dl_priv->ds;
703 }
704 
705 static inline
706 struct dsa_switch *dsa_devlink_port_to_ds(struct devlink_port *port)
707 {
708         struct devlink *dl = port->devlink;
709         struct dsa_devlink_priv *dl_priv = devlink_priv(dl);
710 
711         return dl_priv->ds;
712 }
713 
714 static inline int dsa_devlink_port_to_port(struct devlink_port *port)
715 {
716         return port->index;
717 }
718 
719 struct dsa_switch_driver {
720         struct list_head        list;
721         const struct dsa_switch_ops *ops;
722 };
723 
724 struct net_device *dsa_dev_to_net_device(struct device *dev);
725 
726 /* Keep inline for faster access in hot path */
727 static inline bool netdev_uses_dsa(const struct net_device *dev)
728 {
729 #if IS_ENABLED(CONFIG_NET_DSA)
730         return dev->dsa_ptr && dev->dsa_ptr->rcv;
731 #endif
732         return false;
733 }
734 
735 static inline bool dsa_can_decode(const struct sk_buff *skb,
736                                   struct net_device *dev)
737 {
738 #if IS_ENABLED(CONFIG_NET_DSA)
739         return !dev->dsa_ptr->filter || dev->dsa_ptr->filter(skb, dev);
740 #endif
741         return false;
742 }
743 
744 /* All DSA tags that push the EtherType to the right (basically all except tail
745  * tags, which don't break dissection) can be treated the same from the
746  * perspective of the flow dissector.
747  *
748  * We need to return:
749  *  - offset: the (B - A) difference between:
750  *    A. the position of the real EtherType and
751  *    B. the current skb->data (aka ETH_HLEN bytes into the frame, aka 2 bytes
752  *       after the normal EtherType was supposed to be)
753  *    The offset in bytes is exactly equal to the tagger overhead (and half of
754  *    that, in __be16 shorts).
755  *
756  *  - proto: the value of the real EtherType.
757  */
758 static inline void dsa_tag_generic_flow_dissect(const struct sk_buff *skb,
759                                                 __be16 *proto, int *offset)
760 {
761 #if IS_ENABLED(CONFIG_NET_DSA)
762         const struct dsa_device_ops *ops = skb->dev->dsa_ptr->tag_ops;
763         int tag_len = ops->overhead;
764 
765         *offset = tag_len;
766         *proto = ((__be16 *)skb->data)[(tag_len / 2) - 1];
767 #endif
768 }
769 
770 #if IS_ENABLED(CONFIG_NET_DSA)
771 static inline int __dsa_netdevice_ops_check(struct net_device *dev)
772 {
773         int err = -EOPNOTSUPP;
774 
775         if (!dev->dsa_ptr)
776                 return err;
777 
778         if (!dev->dsa_ptr->netdev_ops)
779                 return err;
780 
781         return 0;
782 }
783 
784 static inline int dsa_ndo_do_ioctl(struct net_device *dev, struct ifreq *ifr,
785                                    int cmd)
786 {
787         const struct dsa_netdevice_ops *ops;
788         int err;
789 
790         err = __dsa_netdevice_ops_check(dev);
791         if (err)
792                 return err;
793 
794         ops = dev->dsa_ptr->netdev_ops;
795 
796         return ops->ndo_do_ioctl(dev, ifr, cmd);
797 }
798 #else
799 static inline int dsa_ndo_do_ioctl(struct net_device *dev, struct ifreq *ifr,
800                                    int cmd)
801 {
802         return -EOPNOTSUPP;
803 }
804 #endif
805 
806 void dsa_unregister_switch(struct dsa_switch *ds);
807 int dsa_register_switch(struct dsa_switch *ds);
808 struct dsa_switch *dsa_switch_find(int tree_index, int sw_index);
809 #ifdef CONFIG_PM_SLEEP
810 int dsa_switch_suspend(struct dsa_switch *ds);
811 int dsa_switch_resume(struct dsa_switch *ds);
812 #else
813 static inline int dsa_switch_suspend(struct dsa_switch *ds)
814 {
815         return 0;
816 }
817 static inline int dsa_switch_resume(struct dsa_switch *ds)
818 {
819         return 0;
820 }
821 #endif /* CONFIG_PM_SLEEP */
822 
823 enum dsa_notifier_type {
824         DSA_PORT_REGISTER,
825         DSA_PORT_UNREGISTER,
826 };
827 
828 struct dsa_notifier_info {
829         struct net_device *dev;
830 };
831 
832 struct dsa_notifier_register_info {
833         struct dsa_notifier_info info;  /* must be first */
834         struct net_device *master;
835         unsigned int port_number;
836         unsigned int switch_number;
837 };
838 
839 static inline struct net_device *
840 dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
841 {
842         return info->dev;
843 }
844 
845 #if IS_ENABLED(CONFIG_NET_DSA)
846 int register_dsa_notifier(struct notifier_block *nb);
847 int unregister_dsa_notifier(struct notifier_block *nb);
848 int call_dsa_notifiers(unsigned long val, struct net_device *dev,
849                        struct dsa_notifier_info *info);
850 #else
851 static inline int register_dsa_notifier(struct notifier_block *nb)
852 {
853         return 0;
854 }
855 
856 static inline int unregister_dsa_notifier(struct notifier_block *nb)
857 {
858         return 0;
859 }
860 
861 static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
862                                      struct dsa_notifier_info *info)
863 {
864         return NOTIFY_DONE;
865 }
866 #endif
867 
868 /* Broadcom tag specific helpers to insert and extract queue/port number */
869 #define BRCM_TAG_SET_PORT_QUEUE(p, q)   ((p) << 8 | q)
870 #define BRCM_TAG_GET_PORT(v)            ((v) >> 8)
871 #define BRCM_TAG_GET_QUEUE(v)           ((v) & 0xff)
872 
873 
874 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev);
875 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data);
876 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data);
877 int dsa_port_get_phy_sset_count(struct dsa_port *dp);
878 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up);
879 
880 struct dsa_tag_driver {
881         const struct dsa_device_ops *ops;
882         struct list_head list;
883         struct module *owner;
884 };
885 
886 void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[],
887                               unsigned int count,
888                               struct module *owner);
889 void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[],
890                                 unsigned int count);
891 
892 #define dsa_tag_driver_module_drivers(__dsa_tag_drivers_array, __count) \
893 static int __init dsa_tag_driver_module_init(void)                      \
894 {                                                                       \
895         dsa_tag_drivers_register(__dsa_tag_drivers_array, __count,      \
896                                  THIS_MODULE);                          \
897         return 0;                                                       \
898 }                                                                       \
899 module_init(dsa_tag_driver_module_init);                                \
900                                                                         \
901 static void __exit dsa_tag_driver_module_exit(void)                     \
902 {                                                                       \
903         dsa_tag_drivers_unregister(__dsa_tag_drivers_array, __count);   \
904 }                                                                       \
905 module_exit(dsa_tag_driver_module_exit)
906 
907 /**
908  * module_dsa_tag_drivers() - Helper macro for registering DSA tag
909  * drivers
910  * @__ops_array: Array of tag driver strucutres
911  *
912  * Helper macro for DSA tag drivers which do not do anything special
913  * in module init/exit. Each module may only use this macro once, and
914  * calling it replaces module_init() and module_exit().
915  */
916 #define module_dsa_tag_drivers(__ops_array)                             \
917 dsa_tag_driver_module_drivers(__ops_array, ARRAY_SIZE(__ops_array))
918 
919 #define DSA_TAG_DRIVER_NAME(__ops) dsa_tag_driver ## _ ## __ops
920 
921 /* Create a static structure we can build a linked list of dsa_tag
922  * drivers
923  */
924 #define DSA_TAG_DRIVER(__ops)                                           \
925 static struct dsa_tag_driver DSA_TAG_DRIVER_NAME(__ops) = {             \
926         .ops = &__ops,                                                  \
927 }
928 
929 /**
930  * module_dsa_tag_driver() - Helper macro for registering a single DSA tag
931  * driver
932  * @__ops: Single tag driver structures
933  *
934  * Helper macro for DSA tag drivers which do not do anything special
935  * in module init/exit. Each module may only use this macro once, and
936  * calling it replaces module_init() and module_exit().
937  */
938 #define module_dsa_tag_driver(__ops)                                    \
939 DSA_TAG_DRIVER(__ops);                                                  \
940                                                                         \
941 static struct dsa_tag_driver *dsa_tag_driver_array[] =  {               \
942         &DSA_TAG_DRIVER_NAME(__ops)                                     \
943 };                                                                      \
944 module_dsa_tag_drivers(dsa_tag_driver_array)
945 #endif
946 
947 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp