]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
f2f23566 VD |
2 | /* |
3 | * Handling of a master device, switching frames via its switch fabric CPU port | |
4 | * | |
5 | * Copyright (c) 2017 Savoir-faire Linux Inc. | |
6 | * Vivien Didelot <vivien.didelot@savoirfairelinux.com> | |
f2f23566 VD |
7 | */ |
8 | ||
9 | #include "dsa_priv.h" | |
10 | ||
48e23311 VD |
11 | static int dsa_master_get_regs_len(struct net_device *dev) |
12 | { | |
13 | struct dsa_port *cpu_dp = dev->dsa_ptr; | |
14 | const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; | |
15 | struct dsa_switch *ds = cpu_dp->ds; | |
16 | int port = cpu_dp->index; | |
17 | int ret = 0; | |
18 | int len; | |
19 | ||
20 | if (ops->get_regs_len) { | |
21 | len = ops->get_regs_len(dev); | |
22 | if (len < 0) | |
23 | return len; | |
24 | ret += len; | |
25 | } | |
26 | ||
27 | ret += sizeof(struct ethtool_drvinfo); | |
28 | ret += sizeof(struct ethtool_regs); | |
29 | ||
30 | if (ds->ops->get_regs_len) { | |
31 | len = ds->ops->get_regs_len(ds, port); | |
32 | if (len < 0) | |
33 | return len; | |
34 | ret += len; | |
35 | } | |
36 | ||
37 | return ret; | |
38 | } | |
39 | ||
40 | static void dsa_master_get_regs(struct net_device *dev, | |
41 | struct ethtool_regs *regs, void *data) | |
42 | { | |
43 | struct dsa_port *cpu_dp = dev->dsa_ptr; | |
44 | const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; | |
45 | struct dsa_switch *ds = cpu_dp->ds; | |
46 | struct ethtool_drvinfo *cpu_info; | |
47 | struct ethtool_regs *cpu_regs; | |
48 | int port = cpu_dp->index; | |
49 | int len; | |
50 | ||
51 | if (ops->get_regs_len && ops->get_regs) { | |
52 | len = ops->get_regs_len(dev); | |
53 | if (len < 0) | |
54 | return; | |
55 | regs->len = len; | |
56 | ops->get_regs(dev, regs, data); | |
57 | data += regs->len; | |
58 | } | |
59 | ||
60 | cpu_info = (struct ethtool_drvinfo *)data; | |
61 | strlcpy(cpu_info->driver, "dsa", sizeof(cpu_info->driver)); | |
62 | data += sizeof(*cpu_info); | |
63 | cpu_regs = (struct ethtool_regs *)data; | |
64 | data += sizeof(*cpu_regs); | |
65 | ||
66 | if (ds->ops->get_regs_len && ds->ops->get_regs) { | |
67 | len = ds->ops->get_regs_len(ds, port); | |
68 | if (len < 0) | |
69 | return; | |
70 | cpu_regs->len = len; | |
71 | ds->ops->get_regs(ds, port, cpu_regs, data); | |
72 | } | |
73 | } | |
74 | ||
f2f23566 VD |
75 | static void dsa_master_get_ethtool_stats(struct net_device *dev, |
76 | struct ethtool_stats *stats, | |
77 | uint64_t *data) | |
78 | { | |
2f657a60 | 79 | struct dsa_port *cpu_dp = dev->dsa_ptr; |
7ec764ee VD |
80 | const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; |
81 | struct dsa_switch *ds = cpu_dp->ds; | |
82 | int port = cpu_dp->index; | |
f2f23566 VD |
83 | int count = 0; |
84 | ||
1d1e79f1 | 85 | if (ops->get_sset_count && ops->get_ethtool_stats) { |
f2f23566 VD |
86 | count = ops->get_sset_count(dev, ETH_SS_STATS); |
87 | ops->get_ethtool_stats(dev, stats, data); | |
88 | } | |
89 | ||
90 | if (ds->ops->get_ethtool_stats) | |
7ec764ee | 91 | ds->ops->get_ethtool_stats(ds, port, data + count); |
f2f23566 VD |
92 | } |
93 | ||
cf963573 FF |
94 | static void dsa_master_get_ethtool_phy_stats(struct net_device *dev, |
95 | struct ethtool_stats *stats, | |
96 | uint64_t *data) | |
97 | { | |
98 | struct dsa_port *cpu_dp = dev->dsa_ptr; | |
99 | const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; | |
100 | struct dsa_switch *ds = cpu_dp->ds; | |
101 | int port = cpu_dp->index; | |
102 | int count = 0; | |
103 | ||
104 | if (dev->phydev && !ops->get_ethtool_phy_stats) { | |
105 | count = phy_ethtool_get_sset_count(dev->phydev); | |
106 | if (count >= 0) | |
107 | phy_ethtool_get_stats(dev->phydev, stats, data); | |
108 | } else if (ops->get_sset_count && ops->get_ethtool_phy_stats) { | |
109 | count = ops->get_sset_count(dev, ETH_SS_PHY_STATS); | |
110 | ops->get_ethtool_phy_stats(dev, stats, data); | |
111 | } | |
112 | ||
113 | if (count < 0) | |
114 | count = 0; | |
115 | ||
116 | if (ds->ops->get_ethtool_phy_stats) | |
117 | ds->ops->get_ethtool_phy_stats(ds, port, data + count); | |
118 | } | |
119 | ||
f2f23566 VD |
120 | static int dsa_master_get_sset_count(struct net_device *dev, int sset) |
121 | { | |
2f657a60 | 122 | struct dsa_port *cpu_dp = dev->dsa_ptr; |
7ec764ee VD |
123 | const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; |
124 | struct dsa_switch *ds = cpu_dp->ds; | |
f2f23566 VD |
125 | int count = 0; |
126 | ||
cf963573 FF |
127 | if (sset == ETH_SS_PHY_STATS && dev->phydev && |
128 | !ops->get_ethtool_phy_stats) | |
129 | count = phy_ethtool_get_sset_count(dev->phydev); | |
130 | else if (ops->get_sset_count) | |
89f09048 | 131 | count = ops->get_sset_count(dev, sset); |
cf963573 FF |
132 | |
133 | if (count < 0) | |
134 | count = 0; | |
f2f23566 | 135 | |
89f09048 FF |
136 | if (ds->ops->get_sset_count) |
137 | count += ds->ops->get_sset_count(ds, cpu_dp->index, sset); | |
f2f23566 VD |
138 | |
139 | return count; | |
140 | } | |
141 | ||
142 | static void dsa_master_get_strings(struct net_device *dev, uint32_t stringset, | |
143 | uint8_t *data) | |
144 | { | |
2f657a60 | 145 | struct dsa_port *cpu_dp = dev->dsa_ptr; |
7ec764ee VD |
146 | const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; |
147 | struct dsa_switch *ds = cpu_dp->ds; | |
148 | int port = cpu_dp->index; | |
f2f23566 | 149 | int len = ETH_GSTRING_LEN; |
a269333f | 150 | int mcount = 0, count, i; |
f2f23566 VD |
151 | uint8_t pfx[4]; |
152 | uint8_t *ndata; | |
153 | ||
7ec764ee | 154 | snprintf(pfx, sizeof(pfx), "p%.2d", port); |
f2f23566 VD |
155 | /* We do not want to be NULL-terminated, since this is a prefix */ |
156 | pfx[sizeof(pfx) - 1] = '_'; | |
157 | ||
cf963573 FF |
158 | if (stringset == ETH_SS_PHY_STATS && dev->phydev && |
159 | !ops->get_ethtool_phy_stats) { | |
160 | mcount = phy_ethtool_get_sset_count(dev->phydev); | |
161 | if (mcount < 0) | |
162 | mcount = 0; | |
163 | else | |
164 | phy_ethtool_get_strings(dev->phydev, data); | |
165 | } else if (ops->get_sset_count && ops->get_strings) { | |
89f09048 FF |
166 | mcount = ops->get_sset_count(dev, stringset); |
167 | if (mcount < 0) | |
168 | mcount = 0; | |
f2f23566 VD |
169 | ops->get_strings(dev, stringset, data); |
170 | } | |
171 | ||
89f09048 | 172 | if (ds->ops->get_strings) { |
f2f23566 VD |
173 | ndata = data + mcount * len; |
174 | /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle | |
175 | * the output after to prepend our CPU port prefix we | |
176 | * constructed earlier | |
177 | */ | |
89f09048 FF |
178 | ds->ops->get_strings(ds, port, stringset, ndata); |
179 | count = ds->ops->get_sset_count(ds, port, stringset); | |
a269333f DC |
180 | if (count < 0) |
181 | return; | |
f2f23566 VD |
182 | for (i = 0; i < count; i++) { |
183 | memmove(ndata + (i * len + sizeof(pfx)), | |
184 | ndata + i * len, len - sizeof(pfx)); | |
185 | memcpy(ndata + i * len, pfx, sizeof(pfx)); | |
186 | } | |
187 | } | |
188 | } | |
189 | ||
f685e609 VO |
190 | static int dsa_master_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) |
191 | { | |
192 | struct dsa_port *cpu_dp = dev->dsa_ptr; | |
193 | struct dsa_switch *ds = cpu_dp->ds; | |
194 | struct dsa_switch_tree *dst; | |
195 | int err = -EOPNOTSUPP; | |
196 | struct dsa_port *dp; | |
197 | ||
198 | dst = ds->dst; | |
199 | ||
200 | switch (cmd) { | |
201 | case SIOCGHWTSTAMP: | |
202 | case SIOCSHWTSTAMP: | |
203 | /* Deny PTP operations on master if there is at least one | |
204 | * switch in the tree that is PTP capable. | |
205 | */ | |
206 | list_for_each_entry(dp, &dst->ports, list) | |
207 | if (dp->ds->ops->port_hwtstamp_get || | |
208 | dp->ds->ops->port_hwtstamp_set) | |
209 | return -EBUSY; | |
210 | break; | |
211 | } | |
212 | ||
a7605370 AB |
213 | if (dev->netdev_ops->ndo_eth_ioctl) |
214 | err = dev->netdev_ops->ndo_eth_ioctl(dev, ifr, cmd); | |
f685e609 VO |
215 | |
216 | return err; | |
217 | } | |
218 | ||
9c0c7014 | 219 | static const struct dsa_netdevice_ops dsa_netdev_ops = { |
a7605370 | 220 | .ndo_eth_ioctl = dsa_master_ioctl, |
9c0c7014 FF |
221 | }; |
222 | ||
17a22fcf | 223 | static int dsa_master_ethtool_setup(struct net_device *dev) |
f2f23566 | 224 | { |
2f657a60 | 225 | struct dsa_port *cpu_dp = dev->dsa_ptr; |
7ec764ee | 226 | struct dsa_switch *ds = cpu_dp->ds; |
f2f23566 VD |
227 | struct ethtool_ops *ops; |
228 | ||
229 | ops = devm_kzalloc(ds->dev, sizeof(*ops), GFP_KERNEL); | |
230 | if (!ops) | |
231 | return -ENOMEM; | |
232 | ||
7ec764ee VD |
233 | cpu_dp->orig_ethtool_ops = dev->ethtool_ops; |
234 | if (cpu_dp->orig_ethtool_ops) | |
235 | memcpy(ops, cpu_dp->orig_ethtool_ops, sizeof(*ops)); | |
f2f23566 | 236 | |
48e23311 VD |
237 | ops->get_regs_len = dsa_master_get_regs_len; |
238 | ops->get_regs = dsa_master_get_regs; | |
f2f23566 VD |
239 | ops->get_sset_count = dsa_master_get_sset_count; |
240 | ops->get_ethtool_stats = dsa_master_get_ethtool_stats; | |
241 | ops->get_strings = dsa_master_get_strings; | |
cf963573 | 242 | ops->get_ethtool_phy_stats = dsa_master_get_ethtool_phy_stats; |
f2f23566 VD |
243 | |
244 | dev->ethtool_ops = ops; | |
245 | ||
246 | return 0; | |
247 | } | |
248 | ||
17a22fcf | 249 | static void dsa_master_ethtool_teardown(struct net_device *dev) |
f2f23566 | 250 | { |
2f657a60 | 251 | struct dsa_port *cpu_dp = dev->dsa_ptr; |
f2f23566 | 252 | |
7ec764ee VD |
253 | dev->ethtool_ops = cpu_dp->orig_ethtool_ops; |
254 | cpu_dp->orig_ethtool_ops = NULL; | |
f2f23566 | 255 | } |
17a22fcf | 256 | |
9c0c7014 FF |
257 | static void dsa_netdev_ops_set(struct net_device *dev, |
258 | const struct dsa_netdevice_ops *ops) | |
da7b9e9b | 259 | { |
9c0c7014 | 260 | dev->dsa_ptr->netdev_ops = ops; |
da7b9e9b FF |
261 | } |
262 | ||
c3975400 VO |
263 | static void dsa_master_set_promiscuity(struct net_device *dev, int inc) |
264 | { | |
265 | const struct dsa_device_ops *ops = dev->dsa_ptr->tag_ops; | |
266 | ||
267 | if (!ops->promisc_on_master) | |
268 | return; | |
269 | ||
270 | rtnl_lock(); | |
271 | dev_set_promiscuity(dev, inc); | |
272 | rtnl_unlock(); | |
273 | } | |
274 | ||
a3d7e01d FF |
275 | static ssize_t tagging_show(struct device *d, struct device_attribute *attr, |
276 | char *buf) | |
277 | { | |
278 | struct net_device *dev = to_net_dev(d); | |
279 | struct dsa_port *cpu_dp = dev->dsa_ptr; | |
280 | ||
281 | return sprintf(buf, "%s\n", | |
282 | dsa_tag_protocol_to_str(cpu_dp->tag_ops)); | |
283 | } | |
53da0eba VO |
284 | |
285 | static ssize_t tagging_store(struct device *d, struct device_attribute *attr, | |
286 | const char *buf, size_t count) | |
287 | { | |
288 | const struct dsa_device_ops *new_tag_ops, *old_tag_ops; | |
289 | struct net_device *dev = to_net_dev(d); | |
290 | struct dsa_port *cpu_dp = dev->dsa_ptr; | |
291 | int err; | |
292 | ||
293 | old_tag_ops = cpu_dp->tag_ops; | |
294 | new_tag_ops = dsa_find_tagger_by_name(buf); | |
295 | /* Bad tagger name, or module is not loaded? */ | |
296 | if (IS_ERR(new_tag_ops)) | |
297 | return PTR_ERR(new_tag_ops); | |
298 | ||
299 | if (new_tag_ops == old_tag_ops) | |
300 | /* Drop the temporarily held duplicate reference, since | |
301 | * the DSA switch tree uses this tagger. | |
302 | */ | |
303 | goto out; | |
304 | ||
305 | err = dsa_tree_change_tag_proto(cpu_dp->ds->dst, dev, new_tag_ops, | |
306 | old_tag_ops); | |
307 | if (err) { | |
308 | /* On failure the old tagger is restored, so we don't need the | |
309 | * driver for the new one. | |
310 | */ | |
311 | dsa_tag_driver_put(new_tag_ops); | |
312 | return err; | |
313 | } | |
314 | ||
315 | /* On success we no longer need the module for the old tagging protocol | |
316 | */ | |
317 | out: | |
318 | dsa_tag_driver_put(old_tag_ops); | |
319 | return count; | |
320 | } | |
321 | static DEVICE_ATTR_RW(tagging); | |
a3d7e01d FF |
322 | |
323 | static struct attribute *dsa_slave_attrs[] = { | |
324 | &dev_attr_tagging.attr, | |
325 | NULL | |
326 | }; | |
327 | ||
328 | static const struct attribute_group dsa_group = { | |
329 | .name = "dsa", | |
330 | .attrs = dsa_slave_attrs, | |
331 | }; | |
332 | ||
91ba4795 AL |
333 | static void dsa_master_reset_mtu(struct net_device *dev) |
334 | { | |
335 | int err; | |
336 | ||
337 | rtnl_lock(); | |
338 | err = dev_set_mtu(dev, ETH_DATA_LEN); | |
339 | if (err) | |
340 | netdev_dbg(dev, | |
341 | "Unable to reset MTU to exclude DSA overheads\n"); | |
342 | rtnl_unlock(); | |
343 | } | |
344 | ||
845e0ebb CW |
345 | static struct lock_class_key dsa_master_addr_list_lock_key; |
346 | ||
17a22fcf VD |
347 | int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp) |
348 | { | |
4e500251 | 349 | const struct dsa_device_ops *tag_ops = cpu_dp->tag_ops; |
07b90056 VO |
350 | struct dsa_switch *ds = cpu_dp->ds; |
351 | struct device_link *consumer_link; | |
4e500251 VO |
352 | int mtu, ret; |
353 | ||
354 | mtu = ETH_DATA_LEN + dsa_tag_protocol_overhead(tag_ops); | |
a3d7e01d | 355 | |
07b90056 VO |
356 | /* The DSA master must use SET_NETDEV_DEV for this to work. */ |
357 | consumer_link = device_link_add(ds->dev, dev->dev.parent, | |
358 | DL_FLAG_AUTOREMOVE_CONSUMER); | |
359 | if (!consumer_link) | |
360 | netdev_err(dev, | |
361 | "Failed to create a device link to DSA switch %s\n", | |
362 | dev_name(ds->dev)); | |
363 | ||
bfcb8132 | 364 | rtnl_lock(); |
bdc40a3f | 365 | ret = dev_set_mtu(dev, mtu); |
bfcb8132 VO |
366 | rtnl_unlock(); |
367 | if (ret) | |
bdc40a3f RV |
368 | netdev_warn(dev, "error %d setting MTU to %d to include DSA overhead\n", |
369 | ret, mtu); | |
dc0fe7d4 | 370 | |
17a22fcf VD |
371 | /* If we use a tagging format that doesn't have an ethertype |
372 | * field, make sure that all packets from this point on get | |
373 | * sent to the tag format's receive function. | |
374 | */ | |
375 | wmb(); | |
376 | ||
377 | dev->dsa_ptr = cpu_dp; | |
845e0ebb CW |
378 | lockdep_set_class(&dev->addr_list_lock, |
379 | &dsa_master_addr_list_lock_key); | |
c3975400 VO |
380 | |
381 | dsa_master_set_promiscuity(dev, 1); | |
382 | ||
a3d7e01d FF |
383 | ret = dsa_master_ethtool_setup(dev); |
384 | if (ret) | |
c3975400 | 385 | goto out_err_reset_promisc; |
a3d7e01d | 386 | |
9c0c7014 | 387 | dsa_netdev_ops_set(dev, &dsa_netdev_ops); |
da7b9e9b | 388 | |
a3d7e01d FF |
389 | ret = sysfs_create_group(&dev->dev.kobj, &dsa_group); |
390 | if (ret) | |
da7b9e9b FF |
391 | goto out_err_ndo_teardown; |
392 | ||
393 | return ret; | |
a3d7e01d | 394 | |
da7b9e9b | 395 | out_err_ndo_teardown: |
9c0c7014 | 396 | dsa_netdev_ops_set(dev, NULL); |
da7b9e9b | 397 | dsa_master_ethtool_teardown(dev); |
c3975400 VO |
398 | out_err_reset_promisc: |
399 | dsa_master_set_promiscuity(dev, -1); | |
a3d7e01d | 400 | return ret; |
17a22fcf VD |
401 | } |
402 | ||
403 | void dsa_master_teardown(struct net_device *dev) | |
404 | { | |
a3d7e01d | 405 | sysfs_remove_group(&dev->dev.kobj, &dsa_group); |
9c0c7014 | 406 | dsa_netdev_ops_set(dev, NULL); |
17a22fcf | 407 | dsa_master_ethtool_teardown(dev); |
91ba4795 | 408 | dsa_master_reset_mtu(dev); |
c3975400 | 409 | dsa_master_set_promiscuity(dev, -1); |
17a22fcf VD |
410 | |
411 | dev->dsa_ptr = NULL; | |
412 | ||
413 | /* If we used a tagging format that doesn't have an ethertype | |
414 | * field, make sure that all packets from this point get sent | |
415 | * without the tag and go through the regular receive path. | |
416 | */ | |
417 | wmb(); | |
418 | } |