]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - net/dsa/slave.c
Merge tag 'asoc-v5.7' of https://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[mirror_ubuntu-hirsute-kernel.git] / net / dsa / slave.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
91da11f8
LB
2/*
3 * net/dsa/slave.c - Slave device handling
e84665c9 4 * Copyright (c) 2008-2009 Marvell Semiconductor
91da11f8
LB
5 */
6
7#include <linux/list.h>
df02c6ff 8#include <linux/etherdevice.h>
b73adef6 9#include <linux/netdevice.h>
91da11f8 10#include <linux/phy.h>
a2820543 11#include <linux/phy_fixed.h>
aab9c406 12#include <linux/phylink.h>
0d8bcdd3
FF
13#include <linux/of_net.h>
14#include <linux/of_mdio.h>
7f854420 15#include <linux/mdio.h>
b73adef6 16#include <net/rtnetlink.h>
f50f2127
FF
17#include <net/pkt_cls.h>
18#include <net/tc_act/tc_mirred.h>
b73adef6 19#include <linux/if_bridge.h>
04ff53f9 20#include <linux/netpoll.h>
90af1059 21#include <linux/ptp_classify.h>
ea5dd34b 22
91da11f8
LB
23#include "dsa_priv.h"
24
25/* slave mii_bus handling ***************************************************/
26static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
27{
28 struct dsa_switch *ds = bus->priv;
29
0d8bcdd3 30 if (ds->phys_mii_mask & (1 << addr))
9d490b4e 31 return ds->ops->phy_read(ds, addr, reg);
91da11f8
LB
32
33 return 0xffff;
34}
35
36static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
37{
38 struct dsa_switch *ds = bus->priv;
39
0d8bcdd3 40 if (ds->phys_mii_mask & (1 << addr))
9d490b4e 41 return ds->ops->phy_write(ds, addr, reg, val);
91da11f8
LB
42
43 return 0;
44}
45
46void dsa_slave_mii_bus_init(struct dsa_switch *ds)
47{
48 ds->slave_mii_bus->priv = (void *)ds;
49 ds->slave_mii_bus->name = "dsa slave smi";
50 ds->slave_mii_bus->read = dsa_slave_phy_read;
51 ds->slave_mii_bus->write = dsa_slave_phy_write;
0b7b498d 52 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
49463b7f 53 ds->dst->index, ds->index);
c33063d6 54 ds->slave_mii_bus->parent = ds->dev;
24df8986 55 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
91da11f8
LB
56}
57
58
59/* slave device handling ****************************************************/
abd2be00 60static int dsa_slave_get_iflink(const struct net_device *dev)
c0840801 61{
d0006b00 62 return dsa_slave_to_master(dev)->ifindex;
c0840801
LB
63}
64
91da11f8
LB
65static int dsa_slave_open(struct net_device *dev)
66{
d0006b00 67 struct net_device *master = dsa_slave_to_master(dev);
d945097b 68 struct dsa_port *dp = dsa_slave_to_port(dev);
df02c6ff
LB
69 int err;
70
71 if (!(master->flags & IFF_UP))
72 return -ENETDOWN;
73
8feedbb4 74 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
a748ee24 75 err = dev_uc_add(master, dev->dev_addr);
df02c6ff
LB
76 if (err < 0)
77 goto out;
78 }
79
80 if (dev->flags & IFF_ALLMULTI) {
81 err = dev_set_allmulti(master, 1);
82 if (err < 0)
83 goto del_unicast;
84 }
85 if (dev->flags & IFF_PROMISC) {
86 err = dev_set_promiscuity(master, 1);
87 if (err < 0)
88 goto clear_allmulti;
89 }
90
8640f8dc 91 err = dsa_port_enable_rt(dp, dev->phydev);
fb8a6a2b
VD
92 if (err)
93 goto clear_promisc;
b73adef6 94
91da11f8 95 return 0;
df02c6ff 96
b2f2af21
FF
97clear_promisc:
98 if (dev->flags & IFF_PROMISC)
4fdeddfe 99 dev_set_promiscuity(master, -1);
df02c6ff
LB
100clear_allmulti:
101 if (dev->flags & IFF_ALLMULTI)
102 dev_set_allmulti(master, -1);
103del_unicast:
8feedbb4 104 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
a748ee24 105 dev_uc_del(master, dev->dev_addr);
df02c6ff
LB
106out:
107 return err;
91da11f8
LB
108}
109
110static int dsa_slave_close(struct net_device *dev)
111{
d0006b00 112 struct net_device *master = dsa_slave_to_master(dev);
d945097b 113 struct dsa_port *dp = dsa_slave_to_port(dev);
df02c6ff 114
8640f8dc 115 dsa_port_disable_rt(dp);
6457edfe 116
df02c6ff 117 dev_mc_unsync(master, dev);
a748ee24 118 dev_uc_unsync(master, dev);
df02c6ff
LB
119 if (dev->flags & IFF_ALLMULTI)
120 dev_set_allmulti(master, -1);
121 if (dev->flags & IFF_PROMISC)
122 dev_set_promiscuity(master, -1);
123
8feedbb4 124 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
a748ee24 125 dev_uc_del(master, dev->dev_addr);
df02c6ff 126
91da11f8
LB
127 return 0;
128}
129
130static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
131{
d0006b00 132 struct net_device *master = dsa_slave_to_master(dev);
17ab4f61
RG
133 if (dev->flags & IFF_UP) {
134 if (change & IFF_ALLMULTI)
135 dev_set_allmulti(master,
136 dev->flags & IFF_ALLMULTI ? 1 : -1);
137 if (change & IFF_PROMISC)
138 dev_set_promiscuity(master,
139 dev->flags & IFF_PROMISC ? 1 : -1);
140 }
91da11f8
LB
141}
142
143static void dsa_slave_set_rx_mode(struct net_device *dev)
144{
d0006b00 145 struct net_device *master = dsa_slave_to_master(dev);
91da11f8
LB
146
147 dev_mc_sync(master, dev);
a748ee24 148 dev_uc_sync(master, dev);
91da11f8
LB
149}
150
df02c6ff 151static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
91da11f8 152{
d0006b00 153 struct net_device *master = dsa_slave_to_master(dev);
df02c6ff
LB
154 struct sockaddr *addr = a;
155 int err;
156
157 if (!is_valid_ether_addr(addr->sa_data))
158 return -EADDRNOTAVAIL;
159
160 if (!(dev->flags & IFF_UP))
161 goto out;
162
8feedbb4 163 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
a748ee24 164 err = dev_uc_add(master, addr->sa_data);
df02c6ff
LB
165 if (err < 0)
166 return err;
167 }
168
8feedbb4 169 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
a748ee24 170 dev_uc_del(master, dev->dev_addr);
df02c6ff
LB
171
172out:
d08f161a 173 ether_addr_copy(dev->dev_addr, addr->sa_data);
91da11f8
LB
174
175 return 0;
176}
177
2bedde1a
AS
178struct dsa_slave_dump_ctx {
179 struct net_device *dev;
180 struct sk_buff *skb;
181 struct netlink_callback *cb;
182 int idx;
183};
184
185static int
186dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid,
187 bool is_static, void *data)
188{
189 struct dsa_slave_dump_ctx *dump = data;
190 u32 portid = NETLINK_CB(dump->cb->skb).portid;
191 u32 seq = dump->cb->nlh->nlmsg_seq;
192 struct nlmsghdr *nlh;
193 struct ndmsg *ndm;
194
195 if (dump->idx < dump->cb->args[2])
196 goto skip;
197
198 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
199 sizeof(*ndm), NLM_F_MULTI);
200 if (!nlh)
201 return -EMSGSIZE;
202
203 ndm = nlmsg_data(nlh);
204 ndm->ndm_family = AF_BRIDGE;
205 ndm->ndm_pad1 = 0;
206 ndm->ndm_pad2 = 0;
207 ndm->ndm_flags = NTF_SELF;
208 ndm->ndm_type = 0;
209 ndm->ndm_ifindex = dump->dev->ifindex;
210 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE;
211
212 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))
213 goto nla_put_failure;
214
215 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))
216 goto nla_put_failure;
217
218 nlmsg_end(dump->skb, nlh);
219
220skip:
221 dump->idx++;
222 return 0;
223
224nla_put_failure:
225 nlmsg_cancel(dump->skb, nlh);
226 return -EMSGSIZE;
227}
228
229static int
230dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
231 struct net_device *dev, struct net_device *filter_dev,
232 int *idx)
233{
d945097b 234 struct dsa_port *dp = dsa_slave_to_port(dev);
2bedde1a
AS
235 struct dsa_slave_dump_ctx dump = {
236 .dev = dev,
237 .skb = skb,
238 .cb = cb,
239 .idx = *idx,
240 };
2bedde1a
AS
241 int err;
242
de40fc5d 243 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump);
2bedde1a 244 *idx = dump.idx;
de40fc5d 245
2bedde1a
AS
246 return err;
247}
248
91da11f8
LB
249static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
250{
0336369d
BS
251 struct dsa_slave_priv *p = netdev_priv(dev);
252 struct dsa_switch *ds = p->dp->ds;
253 int port = p->dp->index;
254
255 /* Pass through to switch driver if it supports timestamping */
256 switch (cmd) {
257 case SIOCGHWTSTAMP:
258 if (ds->ops->port_hwtstamp_get)
259 return ds->ops->port_hwtstamp_get(ds, port, ifr);
260 break;
261 case SIOCSHWTSTAMP:
262 if (ds->ops->port_hwtstamp_set)
263 return ds->ops->port_hwtstamp_set(ds, port, ifr);
264 break;
265 }
266
aab9c406 267 return phylink_mii_ioctl(p->dp->pl, ifr, cmd);
91da11f8
LB
268}
269
35636062 270static int dsa_slave_port_attr_set(struct net_device *dev,
f7fadf30 271 const struct switchdev_attr *attr,
7ea6eb3f 272 struct switchdev_trans *trans)
35636062 273{
d945097b 274 struct dsa_port *dp = dsa_slave_to_port(dev);
b8d866ac 275 int ret;
35636062
SF
276
277 switch (attr->id) {
1f868398 278 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
fd364541 279 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
35636062 280 break;
fb2dabad 281 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
c02c4175
VD
282 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
283 trans);
fb2dabad 284 break;
34a79f63 285 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
072bb190 286 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans);
34a79f63 287 break;
ea87005a
FF
288 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
289 ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags,
290 trans);
291 break;
57652796
RK
292 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
293 ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, trans);
294 break;
08cc83cc
VD
295 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
296 ret = dsa_port_mrouter(dp->cpu_dp, attr->u.mrouter, trans);
297 break;
35636062
SF
298 default:
299 ret = -EOPNOTSUPP;
300 break;
301 }
302
303 return ret;
304}
305
bdcff080
VD
306static int dsa_slave_vlan_add(struct net_device *dev,
307 const struct switchdev_obj *obj,
308 struct switchdev_trans *trans)
309{
310 struct dsa_port *dp = dsa_slave_to_port(dev);
311 struct switchdev_obj_port_vlan vlan;
312 int err;
313
314 if (obj->orig_dev != dev)
315 return -EOPNOTSUPP;
316
c5335d73
VD
317 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev))
318 return 0;
319
bdcff080
VD
320 vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj);
321
322 err = dsa_port_vlan_add(dp, &vlan, trans);
323 if (err)
324 return err;
325
b9499904
VD
326 /* We need the dedicated CPU port to be a member of the VLAN as well.
327 * Even though drivers often handle CPU membership in special ways,
328 * it doesn't make sense to program a PVID, so clear this flag.
329 */
330 vlan.flags &= ~BRIDGE_VLAN_INFO_PVID;
331
7e1741b4
VD
332 err = dsa_port_vlan_add(dp->cpu_dp, &vlan, trans);
333 if (err)
334 return err;
335
bdcff080
VD
336 return 0;
337}
338
ba14d9eb 339static int dsa_slave_port_obj_add(struct net_device *dev,
648b4a99 340 const struct switchdev_obj *obj,
79b139f4
VD
341 struct switchdev_trans *trans,
342 struct netlink_ext_ack *extack)
ba14d9eb 343{
d945097b 344 struct dsa_port *dp = dsa_slave_to_port(dev);
ba14d9eb
VD
345 int err;
346
347 /* For the prepare phase, ensure the full set of changes is feasable in
348 * one go in order to signal a failure properly. If an operation is not
349 * supported, return -EOPNOTSUPP.
350 */
351
9e8f4a54 352 switch (obj->id) {
8df30255 353 case SWITCHDEV_OBJ_ID_PORT_MDB:
79b139f4
VD
354 if (obj->orig_dev != dev)
355 return -EOPNOTSUPP;
bcebb976 356 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans);
8df30255 357 break;
5f4dbc50
AL
358 case SWITCHDEV_OBJ_ID_HOST_MDB:
359 /* DSA can directly translate this to a normal MDB add,
360 * but on the CPU port.
361 */
362 err = dsa_port_mdb_add(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj),
363 trans);
364 break;
57d80838 365 case SWITCHDEV_OBJ_ID_PORT_VLAN:
bdcff080 366 err = dsa_slave_vlan_add(dev, obj, trans);
11149536 367 break;
ba14d9eb
VD
368 default:
369 err = -EOPNOTSUPP;
370 break;
371 }
372
373 return err;
374}
375
bdcff080
VD
376static int dsa_slave_vlan_del(struct net_device *dev,
377 const struct switchdev_obj *obj)
378{
379 struct dsa_port *dp = dsa_slave_to_port(dev);
380
381 if (obj->orig_dev != dev)
382 return -EOPNOTSUPP;
383
c5335d73
VD
384 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev))
385 return 0;
386
7e1741b4
VD
387 /* Do not deprogram the CPU port as it may be shared with other user
388 * ports which can be members of this VLAN as well.
389 */
bdcff080
VD
390 return dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));
391}
392
ba14d9eb 393static int dsa_slave_port_obj_del(struct net_device *dev,
648b4a99 394 const struct switchdev_obj *obj)
ba14d9eb 395{
d945097b 396 struct dsa_port *dp = dsa_slave_to_port(dev);
ba14d9eb
VD
397 int err;
398
9e8f4a54 399 switch (obj->id) {
8df30255 400 case SWITCHDEV_OBJ_ID_PORT_MDB:
79b139f4
VD
401 if (obj->orig_dev != dev)
402 return -EOPNOTSUPP;
bcebb976 403 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
8df30255 404 break;
5f4dbc50
AL
405 case SWITCHDEV_OBJ_ID_HOST_MDB:
406 /* DSA can directly translate this to a normal MDB add,
407 * but on the CPU port.
408 */
409 err = dsa_port_mdb_del(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj));
410 break;
57d80838 411 case SWITCHDEV_OBJ_ID_PORT_VLAN:
bdcff080 412 err = dsa_slave_vlan_del(dev, obj);
11149536 413 break;
ba14d9eb
VD
414 default:
415 err = -EOPNOTSUPP;
416 break;
417 }
418
419 return err;
420}
421
929d6c14
FF
422static int dsa_slave_get_port_parent_id(struct net_device *dev,
423 struct netdev_phys_item_id *ppid)
b73adef6 424{
d945097b
VD
425 struct dsa_port *dp = dsa_slave_to_port(dev);
426 struct dsa_switch *ds = dp->ds;
a42c8e33 427 struct dsa_switch_tree *dst = ds->dst;
b73adef6 428
15b04ace
JP
429 /* For non-legacy ports, devlink is used and it takes
430 * care of the name generation. This ndo implementation
431 * should be removed with legacy support.
432 */
433 if (dp->ds->devlink)
434 return -EOPNOTSUPP;
435
929d6c14
FF
436 ppid->id_len = sizeof(dst->index);
437 memcpy(&ppid->id, &dst->index, ppid->id_len);
438
439 return 0;
440}
441
4fa7b718
VD
442static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev,
443 struct sk_buff *skb)
04ff53f9
FF
444{
445#ifdef CONFIG_NET_POLL_CONTROLLER
4fa7b718
VD
446 struct dsa_slave_priv *p = netdev_priv(dev);
447
04ff53f9
FF
448 if (p->netpoll)
449 netpoll_send_skb(p->netpoll, skb);
450#else
451 BUG();
452#endif
453 return NETDEV_TX_OK;
454}
455
90af1059
BS
456static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p,
457 struct sk_buff *skb)
458{
459 struct dsa_switch *ds = p->dp->ds;
460 struct sk_buff *clone;
461 unsigned int type;
462
463 type = ptp_classify_raw(skb);
464 if (type == PTP_CLASS_NONE)
465 return;
466
467 if (!ds->ops->port_txtstamp)
468 return;
469
470 clone = skb_clone_sk(skb);
471 if (!clone)
472 return;
473
146d442c
VO
474 DSA_SKB_CB(skb)->clone = clone;
475
90af1059
BS
476 if (ds->ops->port_txtstamp(ds, p->dp->index, clone, type))
477 return;
478
479 kfree_skb(clone);
480}
481
97a69a0d
VO
482netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev)
483{
484 /* SKB for netpoll still need to be mangled with the protocol-specific
485 * tag to be successfully transmitted
486 */
487 if (unlikely(netpoll_tx_running(dev)))
488 return dsa_slave_netpoll_send_skb(dev, skb);
489
490 /* Queue the SKB for transmission on the parent interface, but
491 * do not modify its EtherType
492 */
493 skb->dev = dsa_slave_to_master(dev);
494 dev_queue_xmit(skb);
495
496 return NETDEV_TX_OK;
497}
498EXPORT_SYMBOL_GPL(dsa_enqueue_skb);
499
3e8a72d1
FF
500static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
501{
502 struct dsa_slave_priv *p = netdev_priv(dev);
5f6b4e14 503 struct pcpu_sw_netstats *s;
4ed70ce9 504 struct sk_buff *nskb;
3e8a72d1 505
5f6b4e14
FF
506 s = this_cpu_ptr(p->stats64);
507 u64_stats_update_begin(&s->syncp);
508 s->tx_packets++;
509 s->tx_bytes += skb->len;
510 u64_stats_update_end(&s->syncp);
3e8a72d1 511
146d442c 512 DSA_SKB_CB(skb)->clone = NULL;
87671375 513
90af1059
BS
514 /* Identify PTP protocol packets, clone them, and pass them to the
515 * switch driver
516 */
517 dsa_skb_tx_timestamp(p, skb);
518
fe47d563
VD
519 /* Transmit function may have to reallocate the original SKB,
520 * in which case it must have freed it. Only free it here on error.
521 */
4ed70ce9 522 nskb = p->xmit(skb, dev);
fe47d563 523 if (!nskb) {
a68578c2 524 kfree_skb(skb);
4ed70ce9 525 return NETDEV_TX_OK;
fe47d563 526 }
5aed85ce 527
97a69a0d
VO
528 return dsa_enqueue_skb(nskb, dev);
529}
04ff53f9 530
91da11f8 531/* ethtool operations *******************************************************/
91da11f8 532
91da11f8
LB
533static void dsa_slave_get_drvinfo(struct net_device *dev,
534 struct ethtool_drvinfo *drvinfo)
535{
7826d43f 536 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
7826d43f
JP
537 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
538 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
91da11f8
LB
539}
540
3d762a0f
GR
541static int dsa_slave_get_regs_len(struct net_device *dev)
542{
d945097b
VD
543 struct dsa_port *dp = dsa_slave_to_port(dev);
544 struct dsa_switch *ds = dp->ds;
3d762a0f 545
9d490b4e 546 if (ds->ops->get_regs_len)
d945097b 547 return ds->ops->get_regs_len(ds, dp->index);
3d762a0f
GR
548
549 return -EOPNOTSUPP;
550}
551
552static void
553dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
554{
d945097b
VD
555 struct dsa_port *dp = dsa_slave_to_port(dev);
556 struct dsa_switch *ds = dp->ds;
3d762a0f 557
9d490b4e 558 if (ds->ops->get_regs)
d945097b 559 ds->ops->get_regs(ds, dp->index, regs, _p);
3d762a0f
GR
560}
561
aab9c406
FF
562static int dsa_slave_nway_reset(struct net_device *dev)
563{
564 struct dsa_port *dp = dsa_slave_to_port(dev);
565
566 return phylink_ethtool_nway_reset(dp->pl);
567}
568
6793abb4
GR
569static int dsa_slave_get_eeprom_len(struct net_device *dev)
570{
d945097b
VD
571 struct dsa_port *dp = dsa_slave_to_port(dev);
572 struct dsa_switch *ds = dp->ds;
6793abb4 573
0e576044 574 if (ds->cd && ds->cd->eeprom_len)
ff04955c 575 return ds->cd->eeprom_len;
6793abb4 576
9d490b4e
VD
577 if (ds->ops->get_eeprom_len)
578 return ds->ops->get_eeprom_len(ds);
6793abb4
GR
579
580 return 0;
581}
582
583static int dsa_slave_get_eeprom(struct net_device *dev,
584 struct ethtool_eeprom *eeprom, u8 *data)
585{
d945097b
VD
586 struct dsa_port *dp = dsa_slave_to_port(dev);
587 struct dsa_switch *ds = dp->ds;
6793abb4 588
9d490b4e
VD
589 if (ds->ops->get_eeprom)
590 return ds->ops->get_eeprom(ds, eeprom, data);
6793abb4
GR
591
592 return -EOPNOTSUPP;
593}
594
595static int dsa_slave_set_eeprom(struct net_device *dev,
596 struct ethtool_eeprom *eeprom, u8 *data)
597{
d945097b
VD
598 struct dsa_port *dp = dsa_slave_to_port(dev);
599 struct dsa_switch *ds = dp->ds;
6793abb4 600
9d490b4e
VD
601 if (ds->ops->set_eeprom)
602 return ds->ops->set_eeprom(ds, eeprom, data);
6793abb4
GR
603
604 return -EOPNOTSUPP;
605}
606
91da11f8
LB
607static void dsa_slave_get_strings(struct net_device *dev,
608 uint32_t stringset, uint8_t *data)
609{
d945097b
VD
610 struct dsa_port *dp = dsa_slave_to_port(dev);
611 struct dsa_switch *ds = dp->ds;
91da11f8
LB
612
613 if (stringset == ETH_SS_STATS) {
614 int len = ETH_GSTRING_LEN;
615
616 strncpy(data, "tx_packets", len);
617 strncpy(data + len, "tx_bytes", len);
618 strncpy(data + 2 * len, "rx_packets", len);
619 strncpy(data + 3 * len, "rx_bytes", len);
9d490b4e 620 if (ds->ops->get_strings)
89f09048
FF
621 ds->ops->get_strings(ds, dp->index, stringset,
622 data + 4 * len);
91da11f8
LB
623 }
624}
625
626static void dsa_slave_get_ethtool_stats(struct net_device *dev,
627 struct ethtool_stats *stats,
628 uint64_t *data)
629{
d945097b 630 struct dsa_port *dp = dsa_slave_to_port(dev);
91da11f8 631 struct dsa_slave_priv *p = netdev_priv(dev);
d945097b 632 struct dsa_switch *ds = dp->ds;
5f6b4e14 633 struct pcpu_sw_netstats *s;
f613ed66 634 unsigned int start;
5f6b4e14
FF
635 int i;
636
637 for_each_possible_cpu(i) {
638 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
639
640 s = per_cpu_ptr(p->stats64, i);
641 do {
642 start = u64_stats_fetch_begin_irq(&s->syncp);
643 tx_packets = s->tx_packets;
644 tx_bytes = s->tx_bytes;
645 rx_packets = s->rx_packets;
646 rx_bytes = s->rx_bytes;
647 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
648 data[0] += tx_packets;
649 data[1] += tx_bytes;
650 data[2] += rx_packets;
651 data[3] += rx_bytes;
652 }
9d490b4e 653 if (ds->ops->get_ethtool_stats)
d945097b 654 ds->ops->get_ethtool_stats(ds, dp->index, data + 4);
91da11f8
LB
655}
656
657static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
658{
d945097b
VD
659 struct dsa_port *dp = dsa_slave_to_port(dev);
660 struct dsa_switch *ds = dp->ds;
91da11f8
LB
661
662 if (sset == ETH_SS_STATS) {
663 int count;
664
665 count = 4;
9d490b4e 666 if (ds->ops->get_sset_count)
89f09048 667 count += ds->ops->get_sset_count(ds, dp->index, sset);
91da11f8
LB
668
669 return count;
670 }
671
672 return -EOPNOTSUPP;
673}
674
19e57c4e
FF
675static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
676{
d945097b
VD
677 struct dsa_port *dp = dsa_slave_to_port(dev);
678 struct dsa_switch *ds = dp->ds;
19e57c4e 679
aab9c406
FF
680 phylink_ethtool_get_wol(dp->pl, w);
681
9d490b4e 682 if (ds->ops->get_wol)
d945097b 683 ds->ops->get_wol(ds, dp->index, w);
19e57c4e
FF
684}
685
686static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
687{
d945097b
VD
688 struct dsa_port *dp = dsa_slave_to_port(dev);
689 struct dsa_switch *ds = dp->ds;
19e57c4e
FF
690 int ret = -EOPNOTSUPP;
691
aab9c406
FF
692 phylink_ethtool_set_wol(dp->pl, w);
693
9d490b4e 694 if (ds->ops->set_wol)
d945097b 695 ret = ds->ops->set_wol(ds, dp->index, w);
19e57c4e
FF
696
697 return ret;
698}
699
7905288f
FF
700static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
701{
d945097b
VD
702 struct dsa_port *dp = dsa_slave_to_port(dev);
703 struct dsa_switch *ds = dp->ds;
7905288f
FF
704 int ret;
705
7b9cc738 706 /* Port's PHY and MAC both need to be EEE capable */
00670cb8 707 if (!dev->phydev || !dp->pl)
7b9cc738
VD
708 return -ENODEV;
709
08f50061 710 if (!ds->ops->set_mac_eee)
7905288f
FF
711 return -EOPNOTSUPP;
712
d945097b 713 ret = ds->ops->set_mac_eee(ds, dp->index, e);
7905288f
FF
714 if (ret)
715 return ret;
716
aab9c406 717 return phylink_ethtool_set_eee(dp->pl, e);
7905288f
FF
718}
719
720static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
721{
d945097b
VD
722 struct dsa_port *dp = dsa_slave_to_port(dev);
723 struct dsa_switch *ds = dp->ds;
7905288f
FF
724 int ret;
725
7b9cc738 726 /* Port's PHY and MAC both need to be EEE capable */
00670cb8 727 if (!dev->phydev || !dp->pl)
7b9cc738
VD
728 return -ENODEV;
729
08f50061 730 if (!ds->ops->get_mac_eee)
7905288f
FF
731 return -EOPNOTSUPP;
732
d945097b 733 ret = ds->ops->get_mac_eee(ds, dp->index, e);
7905288f
FF
734 if (ret)
735 return ret;
736
aab9c406
FF
737 return phylink_ethtool_get_eee(dp->pl, e);
738}
739
740static int dsa_slave_get_link_ksettings(struct net_device *dev,
741 struct ethtool_link_ksettings *cmd)
742{
743 struct dsa_port *dp = dsa_slave_to_port(dev);
744
745 return phylink_ethtool_ksettings_get(dp->pl, cmd);
746}
747
748static int dsa_slave_set_link_ksettings(struct net_device *dev,
749 const struct ethtool_link_ksettings *cmd)
750{
751 struct dsa_port *dp = dsa_slave_to_port(dev);
752
753 return phylink_ethtool_ksettings_set(dp->pl, cmd);
7905288f
FF
754}
755
a2a1a13b
HK
756static void dsa_slave_get_pauseparam(struct net_device *dev,
757 struct ethtool_pauseparam *pause)
758{
759 struct dsa_port *dp = dsa_slave_to_port(dev);
760
761 phylink_ethtool_get_pauseparam(dp->pl, pause);
762}
763
764static int dsa_slave_set_pauseparam(struct net_device *dev,
765 struct ethtool_pauseparam *pause)
766{
767 struct dsa_port *dp = dsa_slave_to_port(dev);
768
769 return phylink_ethtool_set_pauseparam(dp->pl, pause);
770}
771
04ff53f9
FF
772#ifdef CONFIG_NET_POLL_CONTROLLER
773static int dsa_slave_netpoll_setup(struct net_device *dev,
774 struct netpoll_info *ni)
775{
d0006b00 776 struct net_device *master = dsa_slave_to_master(dev);
04ff53f9 777 struct dsa_slave_priv *p = netdev_priv(dev);
04ff53f9
FF
778 struct netpoll *netpoll;
779 int err = 0;
780
781 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
782 if (!netpoll)
783 return -ENOMEM;
784
785 err = __netpoll_setup(netpoll, master);
786 if (err) {
787 kfree(netpoll);
788 goto out;
789 }
790
791 p->netpoll = netpoll;
792out:
793 return err;
794}
795
796static void dsa_slave_netpoll_cleanup(struct net_device *dev)
797{
798 struct dsa_slave_priv *p = netdev_priv(dev);
799 struct netpoll *netpoll = p->netpoll;
800
801 if (!netpoll)
802 return;
803
804 p->netpoll = NULL;
805
c9fbd71f 806 __netpoll_free(netpoll);
04ff53f9
FF
807}
808
809static void dsa_slave_poll_controller(struct net_device *dev)
810{
811}
812#endif
813
44bb765c
FF
814static int dsa_slave_get_phys_port_name(struct net_device *dev,
815 char *name, size_t len)
816{
d945097b 817 struct dsa_port *dp = dsa_slave_to_port(dev);
44bb765c 818
d484210b
JP
819 /* For non-legacy ports, devlink is used and it takes
820 * care of the name generation. This ndo implementation
821 * should be removed with legacy support.
822 */
823 if (dp->ds->devlink)
824 return -EOPNOTSUPP;
825
d945097b 826 if (snprintf(name, len, "p%d", dp->index) >= len)
44bb765c 827 return -EINVAL;
3a543ef4
FF
828
829 return 0;
830}
831
f50f2127 832static struct dsa_mall_tc_entry *
4fa7b718 833dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie)
f50f2127 834{
4fa7b718 835 struct dsa_slave_priv *p = netdev_priv(dev);
f50f2127
FF
836 struct dsa_mall_tc_entry *mall_tc_entry;
837
838 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
839 if (mall_tc_entry->cookie == cookie)
840 return mall_tc_entry;
841
842 return NULL;
843}
844
845static int dsa_slave_add_cls_matchall(struct net_device *dev,
f50f2127
FF
846 struct tc_cls_matchall_offload *cls,
847 bool ingress)
848{
d945097b 849 struct dsa_port *dp = dsa_slave_to_port(dev);
f50f2127
FF
850 struct dsa_slave_priv *p = netdev_priv(dev);
851 struct dsa_mall_tc_entry *mall_tc_entry;
5fd9fc4e 852 __be16 protocol = cls->common.protocol;
d945097b 853 struct dsa_switch *ds = dp->ds;
9681e8b3 854 struct flow_action_entry *act;
d945097b 855 struct dsa_port *to_dp;
f50f2127 856 int err = -EOPNOTSUPP;
f50f2127
FF
857
858 if (!ds->ops->port_mirror_add)
859 return err;
860
9681e8b3 861 if (!flow_offload_has_one_action(&cls->rule->action))
f50f2127
FF
862 return err;
863
9681e8b3 864 act = &cls->rule->action.entries[0];
f50f2127 865
9681e8b3 866 if (act->id == FLOW_ACTION_MIRRED && protocol == htons(ETH_P_ALL)) {
f50f2127
FF
867 struct dsa_mall_mirror_tc_entry *mirror;
868
9681e8b3 869 if (!act->dev)
f50f2127
FF
870 return -EINVAL;
871
9681e8b3 872 if (!dsa_slave_dev_check(act->dev))
f50f2127
FF
873 return -EOPNOTSUPP;
874
875 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
876 if (!mall_tc_entry)
877 return -ENOMEM;
878
879 mall_tc_entry->cookie = cls->cookie;
880 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
881 mirror = &mall_tc_entry->mirror;
882
9681e8b3 883 to_dp = dsa_slave_to_port(act->dev);
f50f2127 884
d945097b 885 mirror->to_local_port = to_dp->index;
f50f2127
FF
886 mirror->ingress = ingress;
887
d945097b 888 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress);
f50f2127
FF
889 if (err) {
890 kfree(mall_tc_entry);
891 return err;
892 }
893
894 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
895 }
896
897 return 0;
898}
899
900static void dsa_slave_del_cls_matchall(struct net_device *dev,
901 struct tc_cls_matchall_offload *cls)
902{
d945097b 903 struct dsa_port *dp = dsa_slave_to_port(dev);
f50f2127 904 struct dsa_mall_tc_entry *mall_tc_entry;
d945097b 905 struct dsa_switch *ds = dp->ds;
f50f2127
FF
906
907 if (!ds->ops->port_mirror_del)
908 return;
909
4fa7b718 910 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie);
f50f2127
FF
911 if (!mall_tc_entry)
912 return;
913
914 list_del(&mall_tc_entry->list);
915
916 switch (mall_tc_entry->type) {
917 case DSA_PORT_MALL_MIRROR:
d945097b 918 ds->ops->port_mirror_del(ds, dp->index, &mall_tc_entry->mirror);
f50f2127
FF
919 break;
920 default:
921 WARN_ON(1);
922 }
923
924 kfree(mall_tc_entry);
925}
926
3fbae382 927static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
6b3eb752
JP
928 struct tc_cls_matchall_offload *cls,
929 bool ingress)
f50f2127 930{
5fd9fc4e 931 if (cls->common.chain_index)
a5fcf8a6 932 return -EOPNOTSUPP;
f50f2127 933
3fbae382
JP
934 switch (cls->command) {
935 case TC_CLSMATCHALL_REPLACE:
5fd9fc4e 936 return dsa_slave_add_cls_matchall(dev, cls, ingress);
3fbae382
JP
937 case TC_CLSMATCHALL_DESTROY:
938 dsa_slave_del_cls_matchall(dev, cls);
939 return 0;
940 default:
941 return -EOPNOTSUPP;
942 }
943}
944
6b3eb752
JP
945static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
946 void *cb_priv, bool ingress)
947{
948 struct net_device *dev = cb_priv;
949
44ae12a7
JP
950 if (!tc_can_offload(dev))
951 return -EOPNOTSUPP;
952
6b3eb752
JP
953 switch (type) {
954 case TC_SETUP_CLSMATCHALL:
955 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress);
956 default:
957 return -EOPNOTSUPP;
958 }
959}
960
961static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type,
962 void *type_data, void *cb_priv)
963{
964 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true);
965}
966
967static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
968 void *type_data, void *cb_priv)
969{
970 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
971}
972
955bcb6e
PNA
973static LIST_HEAD(dsa_slave_block_cb_list);
974
6b3eb752 975static int dsa_slave_setup_tc_block(struct net_device *dev,
955bcb6e 976 struct flow_block_offload *f)
6b3eb752 977{
955bcb6e 978 struct flow_block_cb *block_cb;
a7323311 979 flow_setup_cb_t *cb;
6b3eb752 980
32f8c409 981 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
6b3eb752 982 cb = dsa_slave_setup_tc_block_cb_ig;
32f8c409 983 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
6b3eb752
JP
984 cb = dsa_slave_setup_tc_block_cb_eg;
985 else
986 return -EOPNOTSUPP;
987
955bcb6e
PNA
988 f->driver_block_list = &dsa_slave_block_cb_list;
989
6b3eb752 990 switch (f->command) {
9c0e189e 991 case FLOW_BLOCK_BIND:
0d4fd02e
PNA
992 if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list))
993 return -EBUSY;
994
0c7294dd 995 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL);
955bcb6e
PNA
996 if (IS_ERR(block_cb))
997 return PTR_ERR(block_cb);
998
999 flow_block_cb_add(block_cb, f);
1000 list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list);
1001 return 0;
9c0e189e 1002 case FLOW_BLOCK_UNBIND:
14bfb13f 1003 block_cb = flow_block_cb_lookup(f->block, cb, dev);
955bcb6e
PNA
1004 if (!block_cb)
1005 return -ENOENT;
1006
1007 flow_block_cb_remove(block_cb, f);
1008 list_del(&block_cb->driver_list);
6b3eb752
JP
1009 return 0;
1010 default:
1011 return -EOPNOTSUPP;
1012 }
1013}
1014
3fbae382 1015static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
de4784ca 1016 void *type_data)
3fbae382 1017{
47d23af2
VO
1018 struct dsa_port *dp = dsa_slave_to_port(dev);
1019 struct dsa_switch *ds = dp->ds;
1020
1021 if (type == TC_SETUP_BLOCK)
6b3eb752 1022 return dsa_slave_setup_tc_block(dev, type_data);
47d23af2
VO
1023
1024 if (!ds->ops->port_setup_tc)
a5fcf8a6 1025 return -EOPNOTSUPP;
47d23af2
VO
1026
1027 return ds->ops->port_setup_tc(ds, dp->index, type, type_data);
f50f2127
FF
1028}
1029
f613ed66
FF
1030static void dsa_slave_get_stats64(struct net_device *dev,
1031 struct rtnl_link_stats64 *stats)
1032{
1033 struct dsa_slave_priv *p = netdev_priv(dev);
5f6b4e14 1034 struct pcpu_sw_netstats *s;
f613ed66 1035 unsigned int start;
5f6b4e14 1036 int i;
f613ed66
FF
1037
1038 netdev_stats_to_stats64(stats, &dev->stats);
5f6b4e14
FF
1039 for_each_possible_cpu(i) {
1040 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
1041
1042 s = per_cpu_ptr(p->stats64, i);
1043 do {
1044 start = u64_stats_fetch_begin_irq(&s->syncp);
1045 tx_packets = s->tx_packets;
1046 tx_bytes = s->tx_bytes;
1047 rx_packets = s->rx_packets;
1048 rx_bytes = s->rx_bytes;
1049 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
1050
1051 stats->tx_packets += tx_packets;
1052 stats->tx_bytes += tx_bytes;
1053 stats->rx_packets += rx_packets;
1054 stats->rx_bytes += rx_bytes;
1055 }
f613ed66
FF
1056}
1057
bf9f2648
FF
1058static int dsa_slave_get_rxnfc(struct net_device *dev,
1059 struct ethtool_rxnfc *nfc, u32 *rule_locs)
1060{
d945097b
VD
1061 struct dsa_port *dp = dsa_slave_to_port(dev);
1062 struct dsa_switch *ds = dp->ds;
bf9f2648
FF
1063
1064 if (!ds->ops->get_rxnfc)
1065 return -EOPNOTSUPP;
1066
d945097b 1067 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);
bf9f2648
FF
1068}
1069
1070static int dsa_slave_set_rxnfc(struct net_device *dev,
1071 struct ethtool_rxnfc *nfc)
1072{
d945097b
VD
1073 struct dsa_port *dp = dsa_slave_to_port(dev);
1074 struct dsa_switch *ds = dp->ds;
bf9f2648
FF
1075
1076 if (!ds->ops->set_rxnfc)
1077 return -EOPNOTSUPP;
1078
d945097b 1079 return ds->ops->set_rxnfc(ds, dp->index, nfc);
bf9f2648
FF
1080}
1081
0336369d
BS
1082static int dsa_slave_get_ts_info(struct net_device *dev,
1083 struct ethtool_ts_info *ts)
1084{
1085 struct dsa_slave_priv *p = netdev_priv(dev);
1086 struct dsa_switch *ds = p->dp->ds;
1087
1088 if (!ds->ops->get_ts_info)
1089 return -EOPNOTSUPP;
1090
1091 return ds->ops->get_ts_info(ds, p->dp->index, ts);
1092}
1093
061f6a50
FF
1094static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
1095 u16 vid)
1096{
1097 struct dsa_port *dp = dsa_slave_to_port(dev);
061f6a50
FF
1098 struct bridge_vlan_info info;
1099 int ret;
1100
1101 /* Check for a possible bridge VLAN entry now since there is no
1102 * need to emulate the switchdev prepare + commit phase.
1103 */
1104 if (dp->bridge_dev) {
c5335d73
VD
1105 if (!br_vlan_enabled(dp->bridge_dev))
1106 return 0;
1107
061f6a50
FF
1108 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
1109 * device, respectively the VID is not found, returning
1110 * 0 means success, which is a failure for us here.
1111 */
1112 ret = br_vlan_get_info(dp->bridge_dev, vid, &info);
1113 if (ret == 0)
1114 return -EBUSY;
1115 }
1116
cf360866 1117 ret = dsa_port_vid_add(dp, vid, 0);
9b236d2a 1118 if (ret)
cf360866
VD
1119 return ret;
1120
7e1741b4 1121 ret = dsa_port_vid_add(dp->cpu_dp, vid, 0);
9b236d2a 1122 if (ret)
7e1741b4
VD
1123 return ret;
1124
cf360866 1125 return 0;
061f6a50
FF
1126}
1127
1128static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
1129 u16 vid)
1130{
1131 struct dsa_port *dp = dsa_slave_to_port(dev);
061f6a50
FF
1132 struct bridge_vlan_info info;
1133 int ret;
1134
1135 /* Check for a possible bridge VLAN entry now since there is no
1136 * need to emulate the switchdev prepare + commit phase.
1137 */
1138 if (dp->bridge_dev) {
c5335d73
VD
1139 if (!br_vlan_enabled(dp->bridge_dev))
1140 return 0;
1141
061f6a50
FF
1142 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
1143 * device, respectively the VID is not found, returning
1144 * 0 means success, which is a failure for us here.
1145 */
1146 ret = br_vlan_get_info(dp->bridge_dev, vid, &info);
1147 if (ret == 0)
1148 return -EBUSY;
1149 }
1150
7e1741b4
VD
1151 /* Do not deprogram the CPU port as it may be shared with other user
1152 * ports which can be members of this VLAN as well.
1153 */
9b236d2a 1154 return dsa_port_vid_del(dp, vid);
061f6a50
FF
1155}
1156
91da11f8 1157static const struct ethtool_ops dsa_slave_ethtool_ops = {
91da11f8 1158 .get_drvinfo = dsa_slave_get_drvinfo,
3d762a0f
GR
1159 .get_regs_len = dsa_slave_get_regs_len,
1160 .get_regs = dsa_slave_get_regs,
aab9c406 1161 .nway_reset = dsa_slave_nway_reset,
c4aef9fc 1162 .get_link = ethtool_op_get_link,
6793abb4
GR
1163 .get_eeprom_len = dsa_slave_get_eeprom_len,
1164 .get_eeprom = dsa_slave_get_eeprom,
1165 .set_eeprom = dsa_slave_set_eeprom,
91da11f8
LB
1166 .get_strings = dsa_slave_get_strings,
1167 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
1168 .get_sset_count = dsa_slave_get_sset_count,
19e57c4e
FF
1169 .set_wol = dsa_slave_set_wol,
1170 .get_wol = dsa_slave_get_wol,
7905288f
FF
1171 .set_eee = dsa_slave_set_eee,
1172 .get_eee = dsa_slave_get_eee,
aab9c406
FF
1173 .get_link_ksettings = dsa_slave_get_link_ksettings,
1174 .set_link_ksettings = dsa_slave_set_link_ksettings,
a2a1a13b
HK
1175 .get_pauseparam = dsa_slave_get_pauseparam,
1176 .set_pauseparam = dsa_slave_set_pauseparam,
bf9f2648
FF
1177 .get_rxnfc = dsa_slave_get_rxnfc,
1178 .set_rxnfc = dsa_slave_set_rxnfc,
0336369d 1179 .get_ts_info = dsa_slave_get_ts_info,
91da11f8
LB
1180};
1181
2a93c1a3
FF
1182/* legacy way, bypassing the bridge *****************************************/
1183int dsa_legacy_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1184 struct net_device *dev,
1185 const unsigned char *addr, u16 vid,
87b0984e
PM
1186 u16 flags,
1187 struct netlink_ext_ack *extack)
2a93c1a3
FF
1188{
1189 struct dsa_port *dp = dsa_slave_to_port(dev);
1190
1191 return dsa_port_fdb_add(dp, addr, vid);
1192}
1193
1194int dsa_legacy_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
1195 struct net_device *dev,
1196 const unsigned char *addr, u16 vid)
1197{
1198 struct dsa_port *dp = dsa_slave_to_port(dev);
1199
1200 return dsa_port_fdb_del(dp, addr, vid);
1201}
1202
716efee2
JP
1203static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev)
1204{
1205 struct dsa_port *dp = dsa_slave_to_port(dev);
1206
1207 return dp->ds->devlink ? &dp->devlink_port : NULL;
1208}
1209
3e8a72d1 1210static const struct net_device_ops dsa_slave_netdev_ops = {
d442ad4a
SH
1211 .ndo_open = dsa_slave_open,
1212 .ndo_stop = dsa_slave_close,
3e8a72d1 1213 .ndo_start_xmit = dsa_slave_xmit,
d442ad4a
SH
1214 .ndo_change_rx_flags = dsa_slave_change_rx_flags,
1215 .ndo_set_rx_mode = dsa_slave_set_rx_mode,
d442ad4a 1216 .ndo_set_mac_address = dsa_slave_set_mac_address,
37b8da1a
AS
1217 .ndo_fdb_add = dsa_legacy_fdb_add,
1218 .ndo_fdb_del = dsa_legacy_fdb_del,
2bedde1a 1219 .ndo_fdb_dump = dsa_slave_fdb_dump,
d442ad4a 1220 .ndo_do_ioctl = dsa_slave_ioctl,
abd2be00 1221 .ndo_get_iflink = dsa_slave_get_iflink,
04ff53f9
FF
1222#ifdef CONFIG_NET_POLL_CONTROLLER
1223 .ndo_netpoll_setup = dsa_slave_netpoll_setup,
1224 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup,
1225 .ndo_poll_controller = dsa_slave_poll_controller,
1226#endif
44bb765c 1227 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
f50f2127 1228 .ndo_setup_tc = dsa_slave_setup_tc,
f613ed66 1229 .ndo_get_stats64 = dsa_slave_get_stats64,
929d6c14 1230 .ndo_get_port_parent_id = dsa_slave_get_port_parent_id,
061f6a50
FF
1231 .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid,
1232 .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid,
716efee2 1233 .ndo_get_devlink_port = dsa_slave_get_devlink_port,
98237d43
SF
1234};
1235
f37db85d
FF
1236static struct device_type dsa_type = {
1237 .name = "dsa",
1238};
1239
aab9c406
FF
1240void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)
1241{
1242 const struct dsa_port *dp = dsa_to_port(ds, port);
1243
1244 phylink_mac_change(dp->pl, up);
1245}
1246EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
1247
1248static void dsa_slave_phylink_fixed_state(struct net_device *dev,
1249 struct phylink_link_state *state)
1250{
1251 struct dsa_port *dp = dsa_slave_to_port(dev);
1252 struct dsa_switch *ds = dp->ds;
1253
1254 /* No need to check that this operation is valid, the callback would
1255 * not be called if it was not.
1256 */
1257 ds->ops->phylink_fixed_state(ds, dp->index, state);
ce31b31c
FF
1258}
1259
91da11f8 1260/* slave device setup *******************************************************/
4fa7b718 1261static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)
c305c165 1262{
d945097b 1263 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
d945097b 1264 struct dsa_switch *ds = dp->ds;
c305c165 1265
0115dcd1
VD
1266 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
1267 if (!slave_dev->phydev) {
d25b8e74 1268 netdev_err(slave_dev, "no phy at %d\n", addr);
c305c165 1269 return -ENODEV;
d25b8e74 1270 }
c305c165 1271
aab9c406 1272 return phylink_connect_phy(dp->pl, slave_dev->phydev);
11d8f3dd 1273}
11d8f3dd 1274
4fa7b718 1275static int dsa_slave_phy_setup(struct net_device *slave_dev)
0d8bcdd3 1276{
d945097b 1277 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
d945097b
VD
1278 struct device_node *port_dn = dp->dn;
1279 struct dsa_switch *ds = dp->ds;
0c65b2b9 1280 phy_interface_t mode;
6819563e 1281 u32 phy_flags = 0;
0c65b2b9 1282 int ret;
0d8bcdd3 1283
0c65b2b9
AL
1284 ret = of_get_phy_mode(port_dn, &mode);
1285 if (ret)
19334920 1286 mode = PHY_INTERFACE_MODE_NA;
0d8bcdd3 1287
44cc27e4
IC
1288 dp->pl_config.dev = &slave_dev->dev;
1289 dp->pl_config.type = PHYLINK_NETDEV;
1290
1291 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), mode,
77373d49 1292 &dsa_port_phylink_mac_ops);
aab9c406
FF
1293 if (IS_ERR(dp->pl)) {
1294 netdev_err(slave_dev,
1295 "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1296 return PTR_ERR(dp->pl);
0d8bcdd3
FF
1297 }
1298
aab9c406
FF
1299 /* Register only if the switch provides such a callback, since this
1300 * callback takes precedence over polling the link GPIO in PHYLINK
1301 * (see phylink_get_fixed_state).
1302 */
1303 if (ds->ops->phylink_fixed_state)
1304 phylink_fixed_state_cb(dp->pl, dsa_slave_phylink_fixed_state);
1305
9d490b4e 1306 if (ds->ops->get_phy_flags)
d945097b 1307 phy_flags = ds->ops->get_phy_flags(ds, dp->index);
6819563e 1308
aab9c406 1309 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);
6146dd45
VO
1310 if (ret == -ENODEV && ds->slave_mii_bus) {
1311 /* We could not connect to a designated PHY or SFP, so try to
1312 * use the switch internal MDIO bus instead
aab9c406 1313 */
d945097b 1314 ret = dsa_slave_phy_connect(slave_dev, dp->index);
d25b8e74 1315 if (ret) {
aab9c406
FF
1316 netdev_err(slave_dev,
1317 "failed to connect to port %d: %d\n",
d945097b 1318 dp->index, ret);
aab9c406 1319 phylink_destroy(dp->pl);
c305c165 1320 return ret;
d25b8e74 1321 }
b31f65fb 1322 }
9697f1cd 1323
6146dd45 1324 return ret;
0d8bcdd3
FF
1325}
1326
24462549
FF
1327int dsa_slave_suspend(struct net_device *slave_dev)
1328{
aab9c406 1329 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
24462549 1330
a94c689e
FF
1331 if (!netif_running(slave_dev))
1332 return 0;
1333
f154be24
FF
1334 netif_device_detach(slave_dev);
1335
aab9c406
FF
1336 rtnl_lock();
1337 phylink_stop(dp->pl);
1338 rtnl_unlock();
24462549
FF
1339
1340 return 0;
1341}
1342
1343int dsa_slave_resume(struct net_device *slave_dev)
1344{
aab9c406
FF
1345 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1346
a94c689e
FF
1347 if (!netif_running(slave_dev))
1348 return 0;
1349
24462549
FF
1350 netif_device_attach(slave_dev);
1351
aab9c406
FF
1352 rtnl_lock();
1353 phylink_start(dp->pl);
1354 rtnl_unlock();
24462549
FF
1355
1356 return 0;
1357}
1358
6158eaa7
VD
1359static void dsa_slave_notify(struct net_device *dev, unsigned long val)
1360{
d0006b00 1361 struct net_device *master = dsa_slave_to_master(dev);
d945097b 1362 struct dsa_port *dp = dsa_slave_to_port(dev);
6158eaa7
VD
1363 struct dsa_notifier_register_info rinfo = {
1364 .switch_number = dp->ds->index,
1365 .port_number = dp->index,
1366 .master = master,
1367 .info.dev = dev,
1368 };
1369
1370 call_dsa_notifiers(val, dev, &rinfo.info);
1371}
1372
951259aa 1373int dsa_slave_create(struct dsa_port *port)
91da11f8 1374{
24a9332a 1375 const struct dsa_port *cpu_dp = port->cpu_dp;
f8b8b1cd 1376 struct net_device *master = cpu_dp->master;
4cfbf09c 1377 struct dsa_switch *ds = port->ds;
951259aa 1378 const char *name = port->name;
91da11f8
LB
1379 struct net_device *slave_dev;
1380 struct dsa_slave_priv *p;
1381 int ret;
1382
55199df6
FF
1383 if (!ds->num_tx_queues)
1384 ds->num_tx_queues = 1;
1385
1386 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1387 NET_NAME_UNKNOWN, ether_setup,
1388 ds->num_tx_queues, 1);
91da11f8 1389 if (slave_dev == NULL)
d87d6f44 1390 return -ENOMEM;
91da11f8 1391
9b236d2a
VO
1392 slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
1393 if (ds->ops->port_vlan_add && ds->ops->port_vlan_del)
1394 slave_dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
f50f2127 1395 slave_dev->hw_features |= NETIF_F_HW_TC;
7ad24ea4 1396 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
4974f9b7 1397 if (!IS_ERR_OR_NULL(port->mac))
a2c7023f
XS
1398 ether_addr_copy(slave_dev->dev_addr, port->mac);
1399 else
1400 eth_hw_addr_inherit(slave_dev, master);
0a5f107b 1401 slave_dev->priv_flags |= IFF_NO_QUEUE;
3e8a72d1 1402 slave_dev->netdev_ops = &dsa_slave_netdev_ops;
8b1efc0f
JW
1403 slave_dev->min_mtu = 0;
1404 slave_dev->max_mtu = ETH_MAX_MTU;
f37db85d 1405 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
d442ad4a 1406
4cfbf09c
VD
1407 SET_NETDEV_DEV(slave_dev, port->ds->dev);
1408 slave_dev->dev.of_node = port->dn;
5075314e
AD
1409 slave_dev->vlan_features = master->vlan_features;
1410
1411 p = netdev_priv(slave_dev);
5f6b4e14
FF
1412 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1413 if (!p->stats64) {
1414 free_netdev(slave_dev);
1415 return -ENOMEM;
1416 }
4cfbf09c 1417 p->dp = port;
f50f2127 1418 INIT_LIST_HEAD(&p->mall_tc_list);
15240248 1419 p->xmit = cpu_dp->tag_ops->xmit;
f8b8b1cd 1420 port->slave = slave_dev;
91da11f8
LB
1421
1422 netif_carrier_off(slave_dev);
1423
4fa7b718 1424 ret = dsa_slave_phy_setup(slave_dev);
0071f56e
AL
1425 if (ret) {
1426 netdev_err(master, "error %d setting up slave phy\n", ret);
e804441c
FF
1427 goto out_free;
1428 }
1429
6158eaa7 1430 dsa_slave_notify(slave_dev, DSA_PORT_REGISTER);
60724d4b 1431
e804441c
FF
1432 ret = register_netdev(slave_dev);
1433 if (ret) {
1434 netdev_err(master, "error %d registering interface %s\n",
1435 ret, slave_dev->name);
1436 goto out_phy;
0071f56e
AL
1437 }
1438
d87d6f44 1439 return 0;
e804441c
FF
1440
1441out_phy:
aab9c406
FF
1442 rtnl_lock();
1443 phylink_disconnect_phy(p->dp->pl);
1444 rtnl_unlock();
1445 phylink_destroy(p->dp->pl);
e804441c
FF
1446out_free:
1447 free_percpu(p->stats64);
1448 free_netdev(slave_dev);
f8b8b1cd 1449 port->slave = NULL;
e804441c 1450 return ret;
91da11f8 1451}
b73adef6 1452
cda5c15b
NA
1453void dsa_slave_destroy(struct net_device *slave_dev)
1454{
d945097b 1455 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
cda5c15b
NA
1456 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1457
1458 netif_carrier_off(slave_dev);
aab9c406
FF
1459 rtnl_lock();
1460 phylink_disconnect_phy(dp->pl);
1461 rtnl_unlock();
881eadab 1462
6158eaa7 1463 dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
cda5c15b 1464 unregister_netdev(slave_dev);
aab9c406 1465 phylink_destroy(dp->pl);
5f6b4e14 1466 free_percpu(p->stats64);
cda5c15b
NA
1467 free_netdev(slave_dev);
1468}
1469
4d776482 1470bool dsa_slave_dev_check(const struct net_device *dev)
b73adef6
FF
1471{
1472 return dev->netdev_ops == &dsa_slave_netdev_ops;
1473}
1474
8e92ab3a
VD
1475static int dsa_slave_changeupper(struct net_device *dev,
1476 struct netdev_notifier_changeupper_info *info)
b73adef6 1477{
d945097b 1478 struct dsa_port *dp = dsa_slave_to_port(dev);
8e92ab3a 1479 int err = NOTIFY_DONE;
b73adef6 1480
8e92ab3a
VD
1481 if (netif_is_bridge_master(info->upper_dev)) {
1482 if (info->linking) {
17d7802b 1483 err = dsa_port_bridge_join(dp, info->upper_dev);
8e92ab3a
VD
1484 err = notifier_from_errno(err);
1485 } else {
17d7802b 1486 dsa_port_bridge_leave(dp, info->upper_dev);
8e92ab3a 1487 err = NOTIFY_OK;
6debb68a 1488 }
6debb68a 1489 }
b73adef6 1490
8e92ab3a 1491 return err;
6debb68a 1492}
b73adef6 1493
cc1d5bda
FF
1494static int dsa_slave_upper_vlan_check(struct net_device *dev,
1495 struct netdev_notifier_changeupper_info *
1496 info)
1497{
1498 struct netlink_ext_ack *ext_ack;
1499 struct net_device *slave;
1500 struct dsa_port *dp;
1501
1502 ext_ack = netdev_notifier_info_to_extack(&info->info);
1503
1504 if (!is_vlan_dev(dev))
1505 return NOTIFY_DONE;
1506
1507 slave = vlan_dev_real_dev(dev);
1508 if (!dsa_slave_dev_check(slave))
1509 return NOTIFY_DONE;
1510
1511 dp = dsa_slave_to_port(slave);
1512 if (!dp->bridge_dev)
1513 return NOTIFY_DONE;
1514
1515 /* Deny enslaving a VLAN device into a VLAN-aware bridge */
1516 if (br_vlan_enabled(dp->bridge_dev) &&
1517 netif_is_bridge_master(info->upper_dev) && info->linking) {
1518 NL_SET_ERR_MSG_MOD(ext_ack,
1519 "Cannot enslave VLAN device into VLAN aware bridge");
1520 return notifier_from_errno(-EINVAL);
1521 }
1522
1523 return NOTIFY_DONE;
1524}
1525
88e4f0ca
VD
1526static int dsa_slave_netdevice_event(struct notifier_block *nb,
1527 unsigned long event, void *ptr)
6debb68a
VD
1528{
1529 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1530
cc1d5bda
FF
1531 if (event == NETDEV_CHANGEUPPER) {
1532 if (!dsa_slave_dev_check(dev))
1533 return dsa_slave_upper_vlan_check(dev, ptr);
8e92ab3a 1534
8e92ab3a 1535 return dsa_slave_changeupper(dev, ptr);
cc1d5bda 1536 }
b73adef6 1537
b73adef6
FF
1538 return NOTIFY_DONE;
1539}
88e4f0ca 1540
c9eb3e0f
AS
1541struct dsa_switchdev_event_work {
1542 struct work_struct work;
1543 struct switchdev_notifier_fdb_info fdb_info;
1544 struct net_device *dev;
1545 unsigned long event;
1546};
1547
1548static void dsa_slave_switchdev_event_work(struct work_struct *work)
1549{
1550 struct dsa_switchdev_event_work *switchdev_work =
1551 container_of(work, struct dsa_switchdev_event_work, work);
1552 struct net_device *dev = switchdev_work->dev;
1553 struct switchdev_notifier_fdb_info *fdb_info;
d945097b 1554 struct dsa_port *dp = dsa_slave_to_port(dev);
c9eb3e0f
AS
1555 int err;
1556
1557 rtnl_lock();
1558 switch (switchdev_work->event) {
1559 case SWITCHDEV_FDB_ADD_TO_DEVICE:
1560 fdb_info = &switchdev_work->fdb_info;
a37fb855
VD
1561 if (!fdb_info->added_by_user)
1562 break;
1563
d945097b 1564 err = dsa_port_fdb_add(dp, fdb_info->addr, fdb_info->vid);
c9eb3e0f
AS
1565 if (err) {
1566 netdev_dbg(dev, "fdb add failed err=%d\n", err);
1567 break;
1568 }
e9ba0fbc 1569 fdb_info->offloaded = true;
c9eb3e0f 1570 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
6685987c 1571 &fdb_info->info, NULL);
c9eb3e0f
AS
1572 break;
1573
1574 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1575 fdb_info = &switchdev_work->fdb_info;
a37fb855
VD
1576 if (!fdb_info->added_by_user)
1577 break;
1578
d945097b 1579 err = dsa_port_fdb_del(dp, fdb_info->addr, fdb_info->vid);
c9eb3e0f
AS
1580 if (err) {
1581 netdev_dbg(dev, "fdb del failed err=%d\n", err);
1582 dev_close(dev);
1583 }
1584 break;
1585 }
1586 rtnl_unlock();
1587
1588 kfree(switchdev_work->fdb_info.addr);
1589 kfree(switchdev_work);
1590 dev_put(dev);
1591}
1592
1593static int
1594dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work *
1595 switchdev_work,
1596 const struct switchdev_notifier_fdb_info *
1597 fdb_info)
1598{
1599 memcpy(&switchdev_work->fdb_info, fdb_info,
1600 sizeof(switchdev_work->fdb_info));
1601 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
1602 if (!switchdev_work->fdb_info.addr)
1603 return -ENOMEM;
1604 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
1605 fdb_info->addr);
1606 return 0;
1607}
1608
1609/* Called under rcu_read_lock() */
1610static int dsa_slave_switchdev_event(struct notifier_block *unused,
1611 unsigned long event, void *ptr)
1612{
1613 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1614 struct dsa_switchdev_event_work *switchdev_work;
79b139f4
VD
1615 int err;
1616
1617 if (event == SWITCHDEV_PORT_ATTR_SET) {
1618 err = switchdev_handle_port_attr_set(dev, ptr,
1619 dsa_slave_dev_check,
1620 dsa_slave_port_attr_set);
1621 return notifier_from_errno(err);
1622 }
c9eb3e0f
AS
1623
1624 if (!dsa_slave_dev_check(dev))
1625 return NOTIFY_DONE;
1626
1627 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
1628 if (!switchdev_work)
1629 return NOTIFY_BAD;
1630
1631 INIT_WORK(&switchdev_work->work,
1632 dsa_slave_switchdev_event_work);
1633 switchdev_work->dev = dev;
1634 switchdev_work->event = event;
1635
1636 switch (event) {
1637 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
1638 case SWITCHDEV_FDB_DEL_TO_DEVICE:
a37fb855 1639 if (dsa_slave_switchdev_fdb_work_init(switchdev_work, ptr))
c9eb3e0f
AS
1640 goto err_fdb_work_init;
1641 dev_hold(dev);
1642 break;
1643 default:
1644 kfree(switchdev_work);
1645 return NOTIFY_DONE;
1646 }
1647
1648 dsa_schedule_work(&switchdev_work->work);
1649 return NOTIFY_OK;
1650
1651err_fdb_work_init:
1652 kfree(switchdev_work);
1653 return NOTIFY_BAD;
1654}
1655
2b239f67
PM
1656static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused,
1657 unsigned long event, void *ptr)
1658{
1659 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
79b139f4 1660 int err;
2b239f67
PM
1661
1662 switch (event) {
79b139f4
VD
1663 case SWITCHDEV_PORT_OBJ_ADD:
1664 err = switchdev_handle_port_obj_add(dev, ptr,
1665 dsa_slave_dev_check,
1666 dsa_slave_port_obj_add);
1667 return notifier_from_errno(err);
2b239f67 1668 case SWITCHDEV_PORT_OBJ_DEL:
79b139f4
VD
1669 err = switchdev_handle_port_obj_del(dev, ptr,
1670 dsa_slave_dev_check,
1671 dsa_slave_port_obj_del);
1672 return notifier_from_errno(err);
9ed1eced 1673 case SWITCHDEV_PORT_ATTR_SET:
79b139f4
VD
1674 err = switchdev_handle_port_attr_set(dev, ptr,
1675 dsa_slave_dev_check,
1676 dsa_slave_port_attr_set);
1677 return notifier_from_errno(err);
2b239f67
PM
1678 }
1679
1680 return NOTIFY_DONE;
1681}
1682
88e4f0ca 1683static struct notifier_block dsa_slave_nb __read_mostly = {
c9eb3e0f
AS
1684 .notifier_call = dsa_slave_netdevice_event,
1685};
1686
1687static struct notifier_block dsa_slave_switchdev_notifier = {
1688 .notifier_call = dsa_slave_switchdev_event,
88e4f0ca
VD
1689};
1690
2b239f67
PM
1691static struct notifier_block dsa_slave_switchdev_blocking_notifier = {
1692 .notifier_call = dsa_slave_switchdev_blocking_event,
1693};
1694
88e4f0ca
VD
1695int dsa_slave_register_notifier(void)
1696{
2b239f67 1697 struct notifier_block *nb;
c9eb3e0f
AS
1698 int err;
1699
1700 err = register_netdevice_notifier(&dsa_slave_nb);
1701 if (err)
1702 return err;
1703
1704 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier);
1705 if (err)
1706 goto err_switchdev_nb;
1707
2b239f67
PM
1708 nb = &dsa_slave_switchdev_blocking_notifier;
1709 err = register_switchdev_blocking_notifier(nb);
1710 if (err)
1711 goto err_switchdev_blocking_nb;
1712
c9eb3e0f
AS
1713 return 0;
1714
2b239f67
PM
1715err_switchdev_blocking_nb:
1716 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
c9eb3e0f
AS
1717err_switchdev_nb:
1718 unregister_netdevice_notifier(&dsa_slave_nb);
1719 return err;
88e4f0ca
VD
1720}
1721
1722void dsa_slave_unregister_notifier(void)
1723{
2b239f67 1724 struct notifier_block *nb;
88e4f0ca
VD
1725 int err;
1726
2b239f67
PM
1727 nb = &dsa_slave_switchdev_blocking_notifier;
1728 err = unregister_switchdev_blocking_notifier(nb);
1729 if (err)
1730 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err);
1731
c9eb3e0f
AS
1732 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
1733 if (err)
1734 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err);
1735
88e4f0ca
VD
1736 err = unregister_netdevice_notifier(&dsa_slave_nb);
1737 if (err)
1738 pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
1739}