Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 1 | /* |
| 2 | * include/net/dsa.h - Driver for Distributed Switch Architecture switch chips |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 3 | * Copyright (c) 2008-2009 Marvell Semiconductor |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 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 | |
Russell King | 4d56a29 | 2017-02-07 15:03:05 -0800 | [diff] [blame] | 14 | #include <linux/if.h> |
Axel Lin | ea1f51b | 2011-11-30 22:07:18 +0000 | [diff] [blame] | 15 | #include <linux/if_ether.h> |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 16 | #include <linux/list.h> |
Vivien Didelot | f515f19 | 2017-02-03 13:20:20 -0500 | [diff] [blame] | 17 | #include <linux/notifier.h> |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 18 | #include <linux/timer.h> |
| 19 | #include <linux/workqueue.h> |
Florian Fainelli | fa981d9 | 2014-08-27 17:04:49 -0700 | [diff] [blame] | 20 | #include <linux/of.h> |
Florian Fainelli | a282054 | 2014-10-17 16:02:13 -0700 | [diff] [blame] | 21 | #include <linux/ethtool.h> |
Brandon Streiff | 0336369 | 2018-02-14 01:07:48 +0100 | [diff] [blame] | 22 | #include <linux/net_tstamp.h> |
Florian Fainelli | 11d8f3d | 2018-05-10 13:17:32 -0700 | [diff] [blame] | 23 | #include <linux/phy.h> |
Florian Fainelli | ecfc937 | 2019-01-15 15:06:11 -0800 | [diff] [blame] | 24 | #include <linux/platform_data/dsa.h> |
Andrew Lunn | 96567d5 | 2017-03-28 23:45:07 +0200 | [diff] [blame] | 25 | #include <net/devlink.h> |
Vivien Didelot | f0c24ccf | 2017-05-17 15:46:04 -0400 | [diff] [blame] | 26 | #include <net/switchdev.h> |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 27 | |
Florian Fainelli | f50f212 | 2017-01-30 12:41:40 -0800 | [diff] [blame] | 28 | struct tc_action; |
Russell King | 4d56a29 | 2017-02-07 15:03:05 -0800 | [diff] [blame] | 29 | struct phy_device; |
| 30 | struct fixed_phy_status; |
Florian Fainelli | 11d8f3d | 2018-05-10 13:17:32 -0700 | [diff] [blame] | 31 | struct phylink_link_state; |
Florian Fainelli | f50f212 | 2017-01-30 12:41:40 -0800 | [diff] [blame] | 32 | |
Florian Fainelli | ac7a04c | 2014-09-11 21:18:09 -0700 | [diff] [blame] | 33 | enum dsa_tag_protocol { |
| 34 | DSA_TAG_PROTO_NONE = 0, |
Florian Fainelli | ac7a04c | 2014-09-11 21:18:09 -0700 | [diff] [blame] | 35 | DSA_TAG_PROTO_BRCM, |
Florian Fainelli | b74b70c | 2017-11-10 15:22:54 -0800 | [diff] [blame] | 36 | DSA_TAG_PROTO_BRCM_PREPEND, |
Andrew Lunn | eb7b721 | 2017-05-16 22:40:07 +0200 | [diff] [blame] | 37 | DSA_TAG_PROTO_DSA, |
| 38 | DSA_TAG_PROTO_EDSA, |
Hauke Mehrtens | 7969119 | 2018-09-09 22:16:43 +0200 | [diff] [blame] | 39 | DSA_TAG_PROTO_GSWIP, |
Tristram Ha | 39d6b96 | 2018-12-15 01:58:04 +0100 | [diff] [blame] | 40 | DSA_TAG_PROTO_KSZ9477, |
Tristram Ha | 88b573a | 2019-02-28 19:57:23 -0800 | [diff] [blame] | 41 | DSA_TAG_PROTO_KSZ9893, |
Juergen Beisert | e8fe177 | 2017-04-18 10:48:24 +0200 | [diff] [blame] | 42 | DSA_TAG_PROTO_LAN9303, |
Andrew Lunn | eb7b721 | 2017-05-16 22:40:07 +0200 | [diff] [blame] | 43 | DSA_TAG_PROTO_MTK, |
| 44 | DSA_TAG_PROTO_QCA, |
| 45 | DSA_TAG_PROTO_TRAILER, |
Andrew Lunn | 39a7f2a | 2016-06-04 21:17:03 +0200 | [diff] [blame] | 46 | DSA_TAG_LAST, /* MUST BE LAST */ |
Florian Fainelli | ac7a04c | 2014-09-11 21:18:09 -0700 | [diff] [blame] | 47 | }; |
Florian Fainelli | 5037d53 | 2014-08-27 17:04:55 -0700 | [diff] [blame] | 48 | |
Alexander Duyck | 5075314 | 2014-09-15 13:00:19 -0400 | [diff] [blame] | 49 | struct packet_type; |
Brandon Streiff | 90af105 | 2018-02-14 01:07:49 +0100 | [diff] [blame] | 50 | struct dsa_switch; |
Florian Fainelli | 3e8a72d | 2014-08-27 17:04:46 -0700 | [diff] [blame] | 51 | |
John Crispin | 68277a2 | 2017-08-09 14:41:16 +0200 | [diff] [blame] | 52 | struct dsa_device_ops { |
| 53 | struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev); |
| 54 | struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev, |
Florian Westphal | 89e4950 | 2017-08-17 16:47:00 +0200 | [diff] [blame] | 55 | struct packet_type *pt); |
John Crispin | 598a968 | 2017-08-09 14:41:17 +0200 | [diff] [blame] | 56 | int (*flow_dissect)(const struct sk_buff *skb, __be16 *proto, |
| 57 | int *offset); |
Andrew Lunn | a5dd308 | 2018-12-06 11:36:04 +0100 | [diff] [blame] | 58 | unsigned int overhead; |
John Crispin | 68277a2 | 2017-08-09 14:41:16 +0200 | [diff] [blame] | 59 | }; |
| 60 | |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 61 | struct dsa_switch_tree { |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 62 | struct list_head list; |
| 63 | |
Vivien Didelot | f515f19 | 2017-02-03 13:20:20 -0500 | [diff] [blame] | 64 | /* Notifier chain for switch-wide events */ |
| 65 | struct raw_notifier_head nh; |
| 66 | |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 67 | /* Tree identifier */ |
Vivien Didelot | 49463b7 | 2017-11-03 19:05:21 -0400 | [diff] [blame] | 68 | unsigned int index; |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 69 | |
| 70 | /* Number of switches attached to this tree */ |
| 71 | struct kref refcount; |
| 72 | |
| 73 | /* Has this tree been applied to the hardware? */ |
Vivien Didelot | ec15dd4 | 2017-11-06 16:11:46 -0500 | [diff] [blame] | 74 | bool setup; |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 75 | |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 76 | /* |
| 77 | * Configuration data for the platform device that owns |
| 78 | * this dsa switch tree instance. |
| 79 | */ |
| 80 | struct dsa_platform_data *pd; |
Lennert Buytenhek | cf85d08 | 2008-10-07 13:45:02 +0000 | [diff] [blame] | 81 | |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 82 | /* |
Vivien Didelot | 8b0d3ea | 2017-05-16 14:10:33 -0400 | [diff] [blame] | 83 | * The switch port to which the CPU is attached. |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 84 | */ |
Vivien Didelot | 8b0d3ea | 2017-05-16 14:10:33 -0400 | [diff] [blame] | 85 | struct dsa_port *cpu_dp; |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 86 | |
| 87 | /* |
Ben Hutchings | cf50dcc | 2011-11-25 14:32:52 +0000 | [diff] [blame] | 88 | * Data for the individual switch chips. |
| 89 | */ |
| 90 | struct dsa_switch *ds[DSA_MAX_SWITCHES]; |
| 91 | }; |
| 92 | |
Florian Fainelli | f50f212 | 2017-01-30 12:41:40 -0800 | [diff] [blame] | 93 | /* TC matchall action types, only mirroring for now */ |
| 94 | enum dsa_port_mall_action_type { |
| 95 | DSA_PORT_MALL_MIRROR, |
| 96 | }; |
| 97 | |
| 98 | /* TC mirroring entry */ |
| 99 | struct dsa_mall_mirror_tc_entry { |
| 100 | u8 to_local_port; |
| 101 | bool ingress; |
| 102 | }; |
| 103 | |
| 104 | /* TC matchall entry */ |
| 105 | struct dsa_mall_tc_entry { |
| 106 | struct list_head list; |
| 107 | unsigned long cookie; |
| 108 | enum dsa_port_mall_action_type type; |
| 109 | union { |
| 110 | struct dsa_mall_mirror_tc_entry mirror; |
| 111 | }; |
| 112 | }; |
| 113 | |
| 114 | |
Andrew Lunn | c8b0980 | 2016-06-04 21:16:57 +0200 | [diff] [blame] | 115 | struct dsa_port { |
Vivien Didelot | f8b8b1c | 2017-10-16 11:12:18 -0400 | [diff] [blame] | 116 | /* A CPU port is physically connected to a master device. |
| 117 | * A user port exposed to userspace has a slave device. |
| 118 | */ |
| 119 | union { |
| 120 | struct net_device *master; |
| 121 | struct net_device *slave; |
| 122 | }; |
| 123 | |
Vivien Didelot | 1524024 | 2017-09-29 17:19:18 -0400 | [diff] [blame] | 124 | /* CPU port tagging operations used by master or slave devices */ |
| 125 | const struct dsa_device_ops *tag_ops; |
| 126 | |
Vivien Didelot | 3e41f93 | 2017-09-29 17:19:19 -0400 | [diff] [blame] | 127 | /* Copies for faster access in master receive hot path */ |
| 128 | struct dsa_switch_tree *dst; |
| 129 | struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev, |
| 130 | struct packet_type *pt); |
| 131 | |
Vivien Didelot | 057cad2 | 2017-10-26 11:22:57 -0400 | [diff] [blame] | 132 | enum { |
| 133 | DSA_PORT_TYPE_UNUSED = 0, |
| 134 | DSA_PORT_TYPE_CPU, |
| 135 | DSA_PORT_TYPE_DSA, |
| 136 | DSA_PORT_TYPE_USER, |
| 137 | } type; |
| 138 | |
Vivien Didelot | 818be84 | 2017-01-27 15:29:38 -0500 | [diff] [blame] | 139 | struct dsa_switch *ds; |
| 140 | unsigned int index; |
Florian Fainelli | 71e0bbd | 2017-02-04 13:02:43 -0800 | [diff] [blame] | 141 | const char *name; |
Vivien Didelot | 24a9332 | 2017-11-06 16:11:43 -0500 | [diff] [blame] | 142 | const struct dsa_port *cpu_dp; |
Andrew Lunn | 189b0d9 | 2016-06-04 21:16:58 +0200 | [diff] [blame] | 143 | struct device_node *dn; |
Vivien Didelot | 34a79f6 | 2016-07-18 20:45:38 -0400 | [diff] [blame] | 144 | unsigned int ageing_time; |
Vivien Didelot | 732f794 | 2016-09-22 16:49:22 -0400 | [diff] [blame] | 145 | u8 stp_state; |
Vivien Didelot | a5e9a02 | 2017-01-27 15:29:40 -0500 | [diff] [blame] | 146 | struct net_device *bridge_dev; |
Andrew Lunn | 96567d5 | 2017-03-28 23:45:07 +0200 | [diff] [blame] | 147 | struct devlink_port devlink_port; |
Florian Fainelli | aab9c40 | 2018-05-10 13:17:36 -0700 | [diff] [blame] | 148 | struct phylink *pl; |
Florian Fainelli | 67dbb9d4 | 2017-06-13 13:27:20 -0700 | [diff] [blame] | 149 | /* |
| 150 | * Original copy of the master netdev ethtool_ops |
| 151 | */ |
Florian Fainelli | 67dbb9d4 | 2017-06-13 13:27:20 -0700 | [diff] [blame] | 152 | const struct ethtool_ops *orig_ethtool_ops; |
Florian Fainelli | da7b9e9 | 2019-01-15 14:43:04 -0800 | [diff] [blame] | 153 | |
| 154 | /* |
| 155 | * Original copy of the master netdev net_device_ops |
| 156 | */ |
| 157 | const struct net_device_ops *orig_ndo_ops; |
Andrew Lunn | c8b0980 | 2016-06-04 21:16:57 +0200 | [diff] [blame] | 158 | }; |
| 159 | |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 160 | struct dsa_switch { |
Andrew Lunn | c33063d | 2016-05-10 23:27:23 +0200 | [diff] [blame] | 161 | struct device *dev; |
| 162 | |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 163 | /* |
| 164 | * Parent switch tree, and switch index. |
| 165 | */ |
| 166 | struct dsa_switch_tree *dst; |
Vivien Didelot | 99feaaf | 2017-11-03 19:05:20 -0400 | [diff] [blame] | 167 | unsigned int index; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 168 | |
Vivien Didelot | f515f19 | 2017-02-03 13:20:20 -0500 | [diff] [blame] | 169 | /* Listener for switch fabric events */ |
| 170 | struct notifier_block nb; |
| 171 | |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 172 | /* |
Andrew Lunn | 7543a6d | 2016-04-13 02:40:40 +0200 | [diff] [blame] | 173 | * Give the switch driver somewhere to hang its private data |
| 174 | * structure. |
| 175 | */ |
| 176 | void *priv; |
| 177 | |
| 178 | /* |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 179 | * Configuration data for this switch. |
| 180 | */ |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 181 | struct dsa_chip_data *cd; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 182 | |
| 183 | /* |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 184 | * The switch operations. |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 185 | */ |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 186 | const struct dsa_switch_ops *ops; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 187 | |
Andrew Lunn | 66472fc | 2016-06-04 21:17:00 +0200 | [diff] [blame] | 188 | /* |
| 189 | * An array of which element [a] indicates which port on this |
| 190 | * switch should be used to send packets to that are destined |
| 191 | * for switch a. Can be NULL if there is only one switch chip. |
| 192 | */ |
| 193 | s8 rtable[DSA_MAX_SWITCHES]; |
| 194 | |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 195 | /* |
| 196 | * Slave mii_bus and devices for the individual ports. |
| 197 | */ |
Florian Fainelli | 0d8bcdd | 2014-08-27 17:04:51 -0700 | [diff] [blame] | 198 | u32 phys_mii_mask; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 199 | struct mii_bus *slave_mii_bus; |
Vivien Didelot | a0c02161 | 2017-01-27 15:29:36 -0500 | [diff] [blame] | 200 | |
Vivien Didelot | 0f3da6a | 2017-03-15 15:53:49 -0400 | [diff] [blame] | 201 | /* Ageing Time limits in msecs */ |
| 202 | unsigned int ageing_time_min; |
| 203 | unsigned int ageing_time_max; |
| 204 | |
Andrew Lunn | 96567d5 | 2017-03-28 23:45:07 +0200 | [diff] [blame] | 205 | /* devlink used to represent this switch device */ |
| 206 | struct devlink *devlink; |
| 207 | |
Florian Fainelli | 55199df | 2017-09-03 20:27:00 -0700 | [diff] [blame] | 208 | /* Number of switch port queues */ |
| 209 | unsigned int num_tx_queues; |
| 210 | |
Salvatore Mesoraca | 0015b80 | 2018-07-16 21:10:34 -0700 | [diff] [blame] | 211 | unsigned long *bitmap; |
| 212 | unsigned long _bitmap; |
| 213 | |
Vivien Didelot | a0c02161 | 2017-01-27 15:29:36 -0500 | [diff] [blame] | 214 | /* Dynamically allocated ports, keep last */ |
| 215 | size_t num_ports; |
| 216 | struct dsa_port ports[]; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 217 | }; |
| 218 | |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 219 | static inline const struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p) |
| 220 | { |
| 221 | return &ds->ports[p]; |
| 222 | } |
| 223 | |
Vivien Didelot | bff7b68 | 2017-10-26 11:22:51 -0400 | [diff] [blame] | 224 | static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p) |
| 225 | { |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 226 | return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED; |
Vivien Didelot | bff7b68 | 2017-10-26 11:22:51 -0400 | [diff] [blame] | 227 | } |
| 228 | |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 229 | static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p) |
| 230 | { |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 231 | return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Andrew Lunn | 60045cb | 2015-08-17 23:52:51 +0200 | [diff] [blame] | 234 | static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p) |
| 235 | { |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 236 | return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA; |
Andrew Lunn | 60045cb | 2015-08-17 23:52:51 +0200 | [diff] [blame] | 237 | } |
| 238 | |
Vivien Didelot | 2b3e989 | 2017-10-26 11:22:54 -0400 | [diff] [blame] | 239 | static inline bool dsa_is_user_port(struct dsa_switch *ds, int p) |
Vivien Didelot | 6cd456f | 2017-03-11 16:12:58 -0500 | [diff] [blame] | 240 | { |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 241 | return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER; |
Vivien Didelot | 6cd456f | 2017-03-11 16:12:58 -0500 | [diff] [blame] | 242 | } |
| 243 | |
Vivien Didelot | 02bc6e5 | 2017-10-26 11:22:56 -0400 | [diff] [blame] | 244 | static inline u32 dsa_user_ports(struct dsa_switch *ds) |
| 245 | { |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 246 | u32 mask = 0; |
| 247 | int p; |
Vivien Didelot | 02bc6e5 | 2017-10-26 11:22:56 -0400 | [diff] [blame] | 248 | |
Vivien Didelot | c38c5a6 | 2017-10-26 11:22:58 -0400 | [diff] [blame] | 249 | for (p = 0; p < ds->num_ports; p++) |
| 250 | if (dsa_is_user_port(ds, p)) |
| 251 | mask |= BIT(p); |
| 252 | |
| 253 | return mask; |
Vivien Didelot | c8652c8 | 2017-10-16 11:12:19 -0400 | [diff] [blame] | 254 | } |
| 255 | |
Vivien Didelot | 3b8fac5 | 2017-11-30 12:56:42 -0500 | [diff] [blame] | 256 | /* Return the local port used to reach an arbitrary switch port */ |
| 257 | static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device, |
| 258 | int port) |
| 259 | { |
| 260 | if (device == ds->index) |
| 261 | return port; |
| 262 | else |
| 263 | return ds->rtable[device]; |
| 264 | } |
| 265 | |
| 266 | /* Return the local port used to reach the dedicated CPU port */ |
Vivien Didelot | 07073c7 | 2017-12-05 15:34:13 -0500 | [diff] [blame] | 267 | static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port) |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 268 | { |
Vivien Didelot | 07073c7 | 2017-12-05 15:34:13 -0500 | [diff] [blame] | 269 | const struct dsa_port *dp = dsa_to_port(ds, port); |
| 270 | const struct dsa_port *cpu_dp = dp->cpu_dp; |
| 271 | |
| 272 | if (!cpu_dp) |
| 273 | return port; |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 274 | |
Vivien Didelot | 3b8fac5 | 2017-11-30 12:56:42 -0500 | [diff] [blame] | 275 | return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index); |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 276 | } |
| 277 | |
Arkadi Sharshevsky | 2bedde1 | 2017-08-06 16:15:49 +0300 | [diff] [blame] | 278 | typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid, |
| 279 | bool is_static, void *data); |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 280 | struct dsa_switch_ops { |
Florian Fainelli | 2a93c1a | 2017-12-06 15:03:33 -0800 | [diff] [blame] | 281 | #if IS_ENABLED(CONFIG_NET_DSA_LEGACY) |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 282 | /* |
Vivien Didelot | a6a71f1 | 2017-04-12 12:45:03 -0400 | [diff] [blame] | 283 | * Legacy probing. |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 284 | */ |
Vivien Didelot | 0209d14 | 2016-04-17 13:23:55 -0400 | [diff] [blame] | 285 | const char *(*probe)(struct device *dsa_dev, |
| 286 | struct device *host_dev, int sw_addr, |
| 287 | void **priv); |
Florian Fainelli | 2a93c1a | 2017-12-06 15:03:33 -0800 | [diff] [blame] | 288 | #endif |
Andrew Lunn | 7b31436 | 2016-08-22 16:01:01 +0200 | [diff] [blame] | 289 | |
Florian Fainelli | 5ed4e3e | 2017-11-10 15:22:52 -0800 | [diff] [blame] | 290 | enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds, |
| 291 | int port); |
Andrew Lunn | 7b31436 | 2016-08-22 16:01:01 +0200 | [diff] [blame] | 292 | |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 293 | int (*setup)(struct dsa_switch *ds); |
Florian Fainelli | 6819563 | 2014-09-19 13:07:54 -0700 | [diff] [blame] | 294 | u32 (*get_phy_flags)(struct dsa_switch *ds, int port); |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 295 | |
| 296 | /* |
| 297 | * Access to the switch's PHY registers. |
| 298 | */ |
| 299 | int (*phy_read)(struct dsa_switch *ds, int port, int regnum); |
| 300 | int (*phy_write)(struct dsa_switch *ds, int port, |
| 301 | int regnum, u16 val); |
| 302 | |
| 303 | /* |
Florian Fainelli | ec9436b | 2014-08-27 17:04:53 -0700 | [diff] [blame] | 304 | * Link state adjustment (called from libphy) |
| 305 | */ |
| 306 | void (*adjust_link)(struct dsa_switch *ds, int port, |
| 307 | struct phy_device *phydev); |
Florian Fainelli | ce31b31 | 2014-08-27 17:04:54 -0700 | [diff] [blame] | 308 | void (*fixed_link_update)(struct dsa_switch *ds, int port, |
| 309 | struct fixed_phy_status *st); |
Florian Fainelli | ec9436b | 2014-08-27 17:04:53 -0700 | [diff] [blame] | 310 | |
| 311 | /* |
Florian Fainelli | 11d8f3d | 2018-05-10 13:17:32 -0700 | [diff] [blame] | 312 | * PHYLINK integration |
| 313 | */ |
| 314 | void (*phylink_validate)(struct dsa_switch *ds, int port, |
| 315 | unsigned long *supported, |
| 316 | struct phylink_link_state *state); |
| 317 | int (*phylink_mac_link_state)(struct dsa_switch *ds, int port, |
| 318 | struct phylink_link_state *state); |
| 319 | void (*phylink_mac_config)(struct dsa_switch *ds, int port, |
| 320 | unsigned int mode, |
| 321 | const struct phylink_link_state *state); |
| 322 | void (*phylink_mac_an_restart)(struct dsa_switch *ds, int port); |
| 323 | void (*phylink_mac_link_down)(struct dsa_switch *ds, int port, |
| 324 | unsigned int mode, |
| 325 | phy_interface_t interface); |
| 326 | void (*phylink_mac_link_up)(struct dsa_switch *ds, int port, |
| 327 | unsigned int mode, |
| 328 | phy_interface_t interface, |
| 329 | struct phy_device *phydev); |
| 330 | void (*phylink_fixed_state)(struct dsa_switch *ds, int port, |
| 331 | struct phylink_link_state *state); |
| 332 | /* |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 333 | * ethtool hardware statistics. |
| 334 | */ |
Florian Fainelli | 89f0904 | 2018-04-25 12:12:50 -0700 | [diff] [blame] | 335 | void (*get_strings)(struct dsa_switch *ds, int port, |
| 336 | u32 stringset, uint8_t *data); |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 337 | void (*get_ethtool_stats)(struct dsa_switch *ds, |
| 338 | int port, uint64_t *data); |
Florian Fainelli | 89f0904 | 2018-04-25 12:12:50 -0700 | [diff] [blame] | 339 | int (*get_sset_count)(struct dsa_switch *ds, int port, int sset); |
Florian Fainelli | cf96357 | 2018-04-25 12:12:52 -0700 | [diff] [blame] | 340 | void (*get_ethtool_phy_stats)(struct dsa_switch *ds, |
| 341 | int port, uint64_t *data); |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 342 | |
| 343 | /* |
Florian Fainelli | 19e57c4 | 2014-09-18 17:31:24 -0700 | [diff] [blame] | 344 | * ethtool Wake-on-LAN |
| 345 | */ |
| 346 | void (*get_wol)(struct dsa_switch *ds, int port, |
| 347 | struct ethtool_wolinfo *w); |
| 348 | int (*set_wol)(struct dsa_switch *ds, int port, |
| 349 | struct ethtool_wolinfo *w); |
| 350 | |
| 351 | /* |
Brandon Streiff | 0336369 | 2018-02-14 01:07:48 +0100 | [diff] [blame] | 352 | * ethtool timestamp info |
| 353 | */ |
| 354 | int (*get_ts_info)(struct dsa_switch *ds, int port, |
| 355 | struct ethtool_ts_info *ts); |
| 356 | |
| 357 | /* |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 358 | * Suspend and resume |
| 359 | */ |
| 360 | int (*suspend)(struct dsa_switch *ds); |
| 361 | int (*resume)(struct dsa_switch *ds); |
Florian Fainelli | b2f2af2 | 2014-09-24 17:05:18 -0700 | [diff] [blame] | 362 | |
| 363 | /* |
| 364 | * Port enable/disable |
| 365 | */ |
| 366 | int (*port_enable)(struct dsa_switch *ds, int port, |
| 367 | struct phy_device *phy); |
Andrew Lunn | 75104db | 2019-02-24 20:44:43 +0100 | [diff] [blame] | 368 | void (*port_disable)(struct dsa_switch *ds, int port); |
Florian Fainelli | 7905288 | 2014-09-24 17:05:21 -0700 | [diff] [blame] | 369 | |
| 370 | /* |
Vivien Didelot | 08f5006 | 2017-08-01 16:32:41 -0400 | [diff] [blame] | 371 | * Port's MAC EEE settings |
Florian Fainelli | 7905288 | 2014-09-24 17:05:21 -0700 | [diff] [blame] | 372 | */ |
Vivien Didelot | 08f5006 | 2017-08-01 16:32:41 -0400 | [diff] [blame] | 373 | int (*set_mac_eee)(struct dsa_switch *ds, int port, |
| 374 | struct ethtool_eee *e); |
| 375 | int (*get_mac_eee)(struct dsa_switch *ds, int port, |
| 376 | struct ethtool_eee *e); |
Guenter Roeck | 51579c3 | 2014-10-29 10:44:58 -0700 | [diff] [blame] | 377 | |
Guenter Roeck | 6793abb | 2014-10-29 10:45:01 -0700 | [diff] [blame] | 378 | /* EEPROM access */ |
| 379 | int (*get_eeprom_len)(struct dsa_switch *ds); |
| 380 | int (*get_eeprom)(struct dsa_switch *ds, |
| 381 | struct ethtool_eeprom *eeprom, u8 *data); |
| 382 | int (*set_eeprom)(struct dsa_switch *ds, |
| 383 | struct ethtool_eeprom *eeprom, u8 *data); |
Guenter Roeck | 3d762a0 | 2014-10-29 10:45:04 -0700 | [diff] [blame] | 384 | |
| 385 | /* |
| 386 | * Register access. |
| 387 | */ |
| 388 | int (*get_regs_len)(struct dsa_switch *ds, int port); |
| 389 | void (*get_regs)(struct dsa_switch *ds, int port, |
| 390 | struct ethtool_regs *regs, void *p); |
Florian Fainelli | b73adef | 2015-02-24 13:15:33 -0800 | [diff] [blame] | 391 | |
| 392 | /* |
| 393 | * Bridge integration |
| 394 | */ |
Vivien Didelot | 34a79f6 | 2016-07-18 20:45:38 -0400 | [diff] [blame] | 395 | int (*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs); |
Vivien Didelot | 71327a4 | 2016-03-13 16:21:32 -0400 | [diff] [blame] | 396 | int (*port_bridge_join)(struct dsa_switch *ds, int port, |
Vivien Didelot | a669275 | 2016-02-12 12:09:39 -0500 | [diff] [blame] | 397 | struct net_device *bridge); |
Vivien Didelot | f123f2f | 2017-01-27 15:29:41 -0500 | [diff] [blame] | 398 | void (*port_bridge_leave)(struct dsa_switch *ds, int port, |
| 399 | struct net_device *bridge); |
Vivien Didelot | 43c44a9 | 2016-04-06 11:55:03 -0400 | [diff] [blame] | 400 | void (*port_stp_state_set)(struct dsa_switch *ds, int port, |
| 401 | u8 state); |
Vivien Didelot | 732f794 | 2016-09-22 16:49:22 -0400 | [diff] [blame] | 402 | void (*port_fast_age)(struct dsa_switch *ds, int port); |
Russell King | 5765279 | 2019-02-20 15:35:04 -0800 | [diff] [blame] | 403 | int (*port_egress_floods)(struct dsa_switch *ds, int port, |
| 404 | bool unicast, bool multicast); |
Vivien Didelot | 2a778e1 | 2015-08-10 09:09:49 -0400 | [diff] [blame] | 405 | |
| 406 | /* |
Vivien Didelot | 1114953 | 2015-08-13 12:52:17 -0400 | [diff] [blame] | 407 | * VLAN support |
| 408 | */ |
Vivien Didelot | fb2daba | 2016-02-26 13:16:00 -0500 | [diff] [blame] | 409 | int (*port_vlan_filtering)(struct dsa_switch *ds, int port, |
| 410 | bool vlan_filtering); |
Vivien Didelot | 80e0236 | 2017-11-30 11:23:57 -0500 | [diff] [blame] | 411 | int (*port_vlan_prepare)(struct dsa_switch *ds, int port, |
| 412 | const struct switchdev_obj_port_vlan *vlan); |
| 413 | void (*port_vlan_add)(struct dsa_switch *ds, int port, |
| 414 | const struct switchdev_obj_port_vlan *vlan); |
Vivien Didelot | 76e398a | 2015-11-01 12:33:55 -0500 | [diff] [blame] | 415 | int (*port_vlan_del)(struct dsa_switch *ds, int port, |
| 416 | const struct switchdev_obj_port_vlan *vlan); |
Vivien Didelot | 1114953 | 2015-08-13 12:52:17 -0400 | [diff] [blame] | 417 | /* |
Vivien Didelot | 2a778e1 | 2015-08-10 09:09:49 -0400 | [diff] [blame] | 418 | * Forwarding database |
| 419 | */ |
Arkadi Sharshevsky | 1b6dd55 | 2017-08-06 16:15:40 +0300 | [diff] [blame] | 420 | int (*port_fdb_add)(struct dsa_switch *ds, int port, |
Arkadi Sharshevsky | 6c2c1dc | 2017-08-06 16:15:39 +0300 | [diff] [blame] | 421 | const unsigned char *addr, u16 vid); |
Vivien Didelot | 2a778e1 | 2015-08-10 09:09:49 -0400 | [diff] [blame] | 422 | int (*port_fdb_del)(struct dsa_switch *ds, int port, |
Arkadi Sharshevsky | 6c2c1dc | 2017-08-06 16:15:39 +0300 | [diff] [blame] | 423 | const unsigned char *addr, u16 vid); |
Vivien Didelot | ea70ba9 | 2015-10-22 09:34:38 -0400 | [diff] [blame] | 424 | int (*port_fdb_dump)(struct dsa_switch *ds, int port, |
Arkadi Sharshevsky | 2bedde1 | 2017-08-06 16:15:49 +0300 | [diff] [blame] | 425 | dsa_fdb_dump_cb_t *cb, void *data); |
Vivien Didelot | 8df3025 | 2016-08-31 11:50:03 -0400 | [diff] [blame] | 426 | |
| 427 | /* |
| 428 | * Multicast database |
| 429 | */ |
Vivien Didelot | 3709aad | 2017-11-30 11:23:58 -0500 | [diff] [blame] | 430 | int (*port_mdb_prepare)(struct dsa_switch *ds, int port, |
| 431 | const struct switchdev_obj_port_mdb *mdb); |
| 432 | void (*port_mdb_add)(struct dsa_switch *ds, int port, |
| 433 | const struct switchdev_obj_port_mdb *mdb); |
Vivien Didelot | 8df3025 | 2016-08-31 11:50:03 -0400 | [diff] [blame] | 434 | int (*port_mdb_del)(struct dsa_switch *ds, int port, |
| 435 | const struct switchdev_obj_port_mdb *mdb); |
Florian Fainelli | bf9f264 | 2017-01-30 09:48:40 -0800 | [diff] [blame] | 436 | /* |
| 437 | * RXNFC |
| 438 | */ |
| 439 | int (*get_rxnfc)(struct dsa_switch *ds, int port, |
| 440 | struct ethtool_rxnfc *nfc, u32 *rule_locs); |
| 441 | int (*set_rxnfc)(struct dsa_switch *ds, int port, |
| 442 | struct ethtool_rxnfc *nfc); |
Florian Fainelli | f50f212 | 2017-01-30 12:41:40 -0800 | [diff] [blame] | 443 | |
| 444 | /* |
| 445 | * TC integration |
| 446 | */ |
| 447 | int (*port_mirror_add)(struct dsa_switch *ds, int port, |
| 448 | struct dsa_mall_mirror_tc_entry *mirror, |
| 449 | bool ingress); |
| 450 | void (*port_mirror_del)(struct dsa_switch *ds, int port, |
| 451 | struct dsa_mall_mirror_tc_entry *mirror); |
Vivien Didelot | 40ef2c9 | 2017-03-30 17:37:14 -0400 | [diff] [blame] | 452 | |
| 453 | /* |
| 454 | * Cross-chip operations |
| 455 | */ |
| 456 | int (*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index, |
| 457 | int port, struct net_device *br); |
| 458 | void (*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index, |
| 459 | int port, struct net_device *br); |
Brandon Streiff | 0336369 | 2018-02-14 01:07:48 +0100 | [diff] [blame] | 460 | |
| 461 | /* |
| 462 | * PTP functionality |
| 463 | */ |
| 464 | int (*port_hwtstamp_get)(struct dsa_switch *ds, int port, |
| 465 | struct ifreq *ifr); |
| 466 | int (*port_hwtstamp_set)(struct dsa_switch *ds, int port, |
| 467 | struct ifreq *ifr); |
Brandon Streiff | 90af105 | 2018-02-14 01:07:49 +0100 | [diff] [blame] | 468 | bool (*port_txtstamp)(struct dsa_switch *ds, int port, |
| 469 | struct sk_buff *clone, unsigned int type); |
| 470 | bool (*port_rxtstamp)(struct dsa_switch *ds, int port, |
| 471 | struct sk_buff *skb, unsigned int type); |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 472 | }; |
| 473 | |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 474 | struct dsa_switch_driver { |
| 475 | struct list_head list; |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 476 | const struct dsa_switch_ops *ops; |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 477 | }; |
| 478 | |
Florian Fainelli | 2a93c1a | 2017-12-06 15:03:33 -0800 | [diff] [blame] | 479 | #if IS_ENABLED(CONFIG_NET_DSA_LEGACY) |
Vivien Didelot | a6a71f1 | 2017-04-12 12:45:03 -0400 | [diff] [blame] | 480 | /* Legacy driver registration */ |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 481 | void register_switch_driver(struct dsa_switch_driver *type); |
| 482 | void unregister_switch_driver(struct dsa_switch_driver *type); |
Alexander Duyck | b4d2394 | 2014-09-15 13:00:27 -0400 | [diff] [blame] | 483 | struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev); |
Vivien Didelot | a6a71f1 | 2017-04-12 12:45:03 -0400 | [diff] [blame] | 484 | |
Florian Fainelli | 2a93c1a | 2017-12-06 15:03:33 -0800 | [diff] [blame] | 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 |
Florian Fainelli | 14b89f3 | 2017-02-04 13:02:42 -0800 | [diff] [blame] | 493 | struct net_device *dsa_dev_to_net_device(struct device *dev); |
Ben Hutchings | c8f0b86 | 2011-11-27 17:06:08 +0000 | [diff] [blame] | 494 | |
Vivien Didelot | 73a7ece | 2017-06-01 16:07:11 -0400 | [diff] [blame] | 495 | /* Keep inline for faster access in hot path */ |
Andrew Lunn | c6e970a | 2017-03-28 23:45:06 +0200 | [diff] [blame] | 496 | static inline bool netdev_uses_dsa(struct net_device *dev) |
| 497 | { |
| 498 | #if IS_ENABLED(CONFIG_NET_DSA) |
Vivien Didelot | 717ffbf | 2017-06-01 16:07:13 -0400 | [diff] [blame] | 499 | return dev->dsa_ptr && dev->dsa_ptr->rcv; |
Andrew Lunn | c6e970a | 2017-03-28 23:45:06 +0200 | [diff] [blame] | 500 | #endif |
| 501 | return false; |
| 502 | } |
| 503 | |
Vivien Didelot | a0c02161 | 2017-01-27 15:29:36 -0500 | [diff] [blame] | 504 | struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n); |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 505 | void dsa_unregister_switch(struct dsa_switch *ds); |
Vivien Didelot | 23c9ee4 | 2017-05-26 18:12:51 -0400 | [diff] [blame] | 506 | int dsa_register_switch(struct dsa_switch *ds); |
Florian Fainelli | ea825e7 | 2016-08-18 15:30:12 -0700 | [diff] [blame] | 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 | |
Florian Fainelli | 60724d4 | 2017-10-11 10:57:48 -0700 | [diff] [blame] | 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 | |
Florian Fainelli | 0a5f14c | 2017-10-11 10:57:49 -0700 | [diff] [blame] | 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 | |
Florian Fainelli | cf96357 | 2018-04-25 12:12:52 -0700 | [diff] [blame] | 571 | |
| 572 | int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data); |
| 573 | int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data); |
| 574 | int dsa_port_get_phy_sset_count(struct dsa_port *dp); |
Florian Fainelli | 11d8f3d | 2018-05-10 13:17:32 -0700 | [diff] [blame] | 575 | void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up); |
Florian Fainelli | cf96357 | 2018-04-25 12:12:52 -0700 | [diff] [blame] | 576 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 577 | #endif |