]> git.ipfire.org Git - thirdparty/linux.git/blob - net/dsa/slave.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
io_uring: reset -EBUSY error when io sq thread is waken up
[thirdparty/linux.git] / net / dsa / slave.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * net/dsa/slave.c - Slave device handling
4 * Copyright (c) 2008-2009 Marvell Semiconductor
5 */
6
7 #include <linux/list.h>
8 #include <linux/etherdevice.h>
9 #include <linux/netdevice.h>
10 #include <linux/phy.h>
11 #include <linux/phy_fixed.h>
12 #include <linux/phylink.h>
13 #include <linux/of_net.h>
14 #include <linux/of_mdio.h>
15 #include <linux/mdio.h>
16 #include <net/rtnetlink.h>
17 #include <net/pkt_cls.h>
18 #include <net/tc_act/tc_mirred.h>
19 #include <linux/if_bridge.h>
20 #include <linux/netpoll.h>
21 #include <linux/ptp_classify.h>
22
23 #include "dsa_priv.h"
24
25 /* slave mii_bus handling ***************************************************/
26 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
27 {
28 struct dsa_switch *ds = bus->priv;
29
30 if (ds->phys_mii_mask & (1 << addr))
31 return ds->ops->phy_read(ds, addr, reg);
32
33 return 0xffff;
34 }
35
36 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
37 {
38 struct dsa_switch *ds = bus->priv;
39
40 if (ds->phys_mii_mask & (1 << addr))
41 return ds->ops->phy_write(ds, addr, reg, val);
42
43 return 0;
44 }
45
46 void 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;
52 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
53 ds->dst->index, ds->index);
54 ds->slave_mii_bus->parent = ds->dev;
55 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
56 }
57
58
59 /* slave device handling ****************************************************/
60 static int dsa_slave_get_iflink(const struct net_device *dev)
61 {
62 return dsa_slave_to_master(dev)->ifindex;
63 }
64
65 static int dsa_slave_open(struct net_device *dev)
66 {
67 struct net_device *master = dsa_slave_to_master(dev);
68 struct dsa_port *dp = dsa_slave_to_port(dev);
69 int err;
70
71 if (!(master->flags & IFF_UP))
72 return -ENETDOWN;
73
74 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
75 err = dev_uc_add(master, dev->dev_addr);
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
91 err = dsa_port_enable_rt(dp, dev->phydev);
92 if (err)
93 goto clear_promisc;
94
95 return 0;
96
97 clear_promisc:
98 if (dev->flags & IFF_PROMISC)
99 dev_set_promiscuity(master, -1);
100 clear_allmulti:
101 if (dev->flags & IFF_ALLMULTI)
102 dev_set_allmulti(master, -1);
103 del_unicast:
104 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
105 dev_uc_del(master, dev->dev_addr);
106 out:
107 return err;
108 }
109
110 static int dsa_slave_close(struct net_device *dev)
111 {
112 struct net_device *master = dsa_slave_to_master(dev);
113 struct dsa_port *dp = dsa_slave_to_port(dev);
114
115 dsa_port_disable_rt(dp);
116
117 dev_mc_unsync(master, dev);
118 dev_uc_unsync(master, dev);
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
124 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
125 dev_uc_del(master, dev->dev_addr);
126
127 return 0;
128 }
129
130 static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
131 {
132 struct net_device *master = dsa_slave_to_master(dev);
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 }
141 }
142
143 static void dsa_slave_set_rx_mode(struct net_device *dev)
144 {
145 struct net_device *master = dsa_slave_to_master(dev);
146
147 dev_mc_sync(master, dev);
148 dev_uc_sync(master, dev);
149 }
150
151 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
152 {
153 struct net_device *master = dsa_slave_to_master(dev);
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
163 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
164 err = dev_uc_add(master, addr->sa_data);
165 if (err < 0)
166 return err;
167 }
168
169 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
170 dev_uc_del(master, dev->dev_addr);
171
172 out:
173 ether_addr_copy(dev->dev_addr, addr->sa_data);
174
175 return 0;
176 }
177
178 struct dsa_slave_dump_ctx {
179 struct net_device *dev;
180 struct sk_buff *skb;
181 struct netlink_callback *cb;
182 int idx;
183 };
184
185 static int
186 dsa_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
220 skip:
221 dump->idx++;
222 return 0;
223
224 nla_put_failure:
225 nlmsg_cancel(dump->skb, nlh);
226 return -EMSGSIZE;
227 }
228
229 static int
230 dsa_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 {
234 struct dsa_port *dp = dsa_slave_to_port(dev);
235 struct dsa_slave_dump_ctx dump = {
236 .dev = dev,
237 .skb = skb,
238 .cb = cb,
239 .idx = *idx,
240 };
241 int err;
242
243 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump);
244 *idx = dump.idx;
245
246 return err;
247 }
248
249 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
250 {
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
267 return phylink_mii_ioctl(p->dp->pl, ifr, cmd);
268 }
269
270 static int dsa_slave_port_attr_set(struct net_device *dev,
271 const struct switchdev_attr *attr,
272 struct switchdev_trans *trans)
273 {
274 struct dsa_port *dp = dsa_slave_to_port(dev);
275 int ret;
276
277 switch (attr->id) {
278 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
279 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
280 break;
281 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
282 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
283 trans);
284 break;
285 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
286 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans);
287 break;
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;
292 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
293 ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, trans);
294 break;
295 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
296 ret = dsa_port_mrouter(dp->cpu_dp, attr->u.mrouter, trans);
297 break;
298 default:
299 ret = -EOPNOTSUPP;
300 break;
301 }
302
303 return ret;
304 }
305
306 static 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
317 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev))
318 return 0;
319
320 vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj);
321
322 err = dsa_port_vlan_add(dp, &vlan, trans);
323 if (err)
324 return err;
325
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
332 err = dsa_port_vlan_add(dp->cpu_dp, &vlan, trans);
333 if (err)
334 return err;
335
336 return 0;
337 }
338
339 static int dsa_slave_port_obj_add(struct net_device *dev,
340 const struct switchdev_obj *obj,
341 struct switchdev_trans *trans,
342 struct netlink_ext_ack *extack)
343 {
344 struct dsa_port *dp = dsa_slave_to_port(dev);
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
352 switch (obj->id) {
353 case SWITCHDEV_OBJ_ID_PORT_MDB:
354 if (obj->orig_dev != dev)
355 return -EOPNOTSUPP;
356 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans);
357 break;
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;
365 case SWITCHDEV_OBJ_ID_PORT_VLAN:
366 err = dsa_slave_vlan_add(dev, obj, trans);
367 break;
368 default:
369 err = -EOPNOTSUPP;
370 break;
371 }
372
373 return err;
374 }
375
376 static 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
384 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev))
385 return 0;
386
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 */
390 return dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));
391 }
392
393 static int dsa_slave_port_obj_del(struct net_device *dev,
394 const struct switchdev_obj *obj)
395 {
396 struct dsa_port *dp = dsa_slave_to_port(dev);
397 int err;
398
399 switch (obj->id) {
400 case SWITCHDEV_OBJ_ID_PORT_MDB:
401 if (obj->orig_dev != dev)
402 return -EOPNOTSUPP;
403 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
404 break;
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;
411 case SWITCHDEV_OBJ_ID_PORT_VLAN:
412 err = dsa_slave_vlan_del(dev, obj);
413 break;
414 default:
415 err = -EOPNOTSUPP;
416 break;
417 }
418
419 return err;
420 }
421
422 static int dsa_slave_get_port_parent_id(struct net_device *dev,
423 struct netdev_phys_item_id *ppid)
424 {
425 struct dsa_port *dp = dsa_slave_to_port(dev);
426 struct dsa_switch *ds = dp->ds;
427 struct dsa_switch_tree *dst = ds->dst;
428
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
436 ppid->id_len = sizeof(dst->index);
437 memcpy(&ppid->id, &dst->index, ppid->id_len);
438
439 return 0;
440 }
441
442 static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev,
443 struct sk_buff *skb)
444 {
445 #ifdef CONFIG_NET_POLL_CONTROLLER
446 struct dsa_slave_priv *p = netdev_priv(dev);
447
448 if (p->netpoll)
449 netpoll_send_skb(p->netpoll, skb);
450 #else
451 BUG();
452 #endif
453 return NETDEV_TX_OK;
454 }
455
456 static 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
474 DSA_SKB_CB(skb)->clone = clone;
475
476 if (ds->ops->port_txtstamp(ds, p->dp->index, clone, type))
477 return;
478
479 kfree_skb(clone);
480 }
481
482 netdev_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 }
498 EXPORT_SYMBOL_GPL(dsa_enqueue_skb);
499
500 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
501 {
502 struct dsa_slave_priv *p = netdev_priv(dev);
503 struct pcpu_sw_netstats *s;
504 struct sk_buff *nskb;
505
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);
511
512 DSA_SKB_CB(skb)->clone = NULL;
513
514 /* Identify PTP protocol packets, clone them, and pass them to the
515 * switch driver
516 */
517 dsa_skb_tx_timestamp(p, skb);
518
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 */
522 nskb = p->xmit(skb, dev);
523 if (!nskb) {
524 kfree_skb(skb);
525 return NETDEV_TX_OK;
526 }
527
528 return dsa_enqueue_skb(nskb, dev);
529 }
530
531 /* ethtool operations *******************************************************/
532
533 static void dsa_slave_get_drvinfo(struct net_device *dev,
534 struct ethtool_drvinfo *drvinfo)
535 {
536 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
537 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
538 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
539 }
540
541 static int dsa_slave_get_regs_len(struct net_device *dev)
542 {
543 struct dsa_port *dp = dsa_slave_to_port(dev);
544 struct dsa_switch *ds = dp->ds;
545
546 if (ds->ops->get_regs_len)
547 return ds->ops->get_regs_len(ds, dp->index);
548
549 return -EOPNOTSUPP;
550 }
551
552 static void
553 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
554 {
555 struct dsa_port *dp = dsa_slave_to_port(dev);
556 struct dsa_switch *ds = dp->ds;
557
558 if (ds->ops->get_regs)
559 ds->ops->get_regs(ds, dp->index, regs, _p);
560 }
561
562 static 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
569 static int dsa_slave_get_eeprom_len(struct net_device *dev)
570 {
571 struct dsa_port *dp = dsa_slave_to_port(dev);
572 struct dsa_switch *ds = dp->ds;
573
574 if (ds->cd && ds->cd->eeprom_len)
575 return ds->cd->eeprom_len;
576
577 if (ds->ops->get_eeprom_len)
578 return ds->ops->get_eeprom_len(ds);
579
580 return 0;
581 }
582
583 static int dsa_slave_get_eeprom(struct net_device *dev,
584 struct ethtool_eeprom *eeprom, u8 *data)
585 {
586 struct dsa_port *dp = dsa_slave_to_port(dev);
587 struct dsa_switch *ds = dp->ds;
588
589 if (ds->ops->get_eeprom)
590 return ds->ops->get_eeprom(ds, eeprom, data);
591
592 return -EOPNOTSUPP;
593 }
594
595 static int dsa_slave_set_eeprom(struct net_device *dev,
596 struct ethtool_eeprom *eeprom, u8 *data)
597 {
598 struct dsa_port *dp = dsa_slave_to_port(dev);
599 struct dsa_switch *ds = dp->ds;
600
601 if (ds->ops->set_eeprom)
602 return ds->ops->set_eeprom(ds, eeprom, data);
603
604 return -EOPNOTSUPP;
605 }
606
607 static void dsa_slave_get_strings(struct net_device *dev,
608 uint32_t stringset, uint8_t *data)
609 {
610 struct dsa_port *dp = dsa_slave_to_port(dev);
611 struct dsa_switch *ds = dp->ds;
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);
620 if (ds->ops->get_strings)
621 ds->ops->get_strings(ds, dp->index, stringset,
622 data + 4 * len);
623 }
624 }
625
626 static void dsa_slave_get_ethtool_stats(struct net_device *dev,
627 struct ethtool_stats *stats,
628 uint64_t *data)
629 {
630 struct dsa_port *dp = dsa_slave_to_port(dev);
631 struct dsa_slave_priv *p = netdev_priv(dev);
632 struct dsa_switch *ds = dp->ds;
633 struct pcpu_sw_netstats *s;
634 unsigned int start;
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 }
653 if (ds->ops->get_ethtool_stats)
654 ds->ops->get_ethtool_stats(ds, dp->index, data + 4);
655 }
656
657 static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
658 {
659 struct dsa_port *dp = dsa_slave_to_port(dev);
660 struct dsa_switch *ds = dp->ds;
661
662 if (sset == ETH_SS_STATS) {
663 int count;
664
665 count = 4;
666 if (ds->ops->get_sset_count)
667 count += ds->ops->get_sset_count(ds, dp->index, sset);
668
669 return count;
670 }
671
672 return -EOPNOTSUPP;
673 }
674
675 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
676 {
677 struct dsa_port *dp = dsa_slave_to_port(dev);
678 struct dsa_switch *ds = dp->ds;
679
680 phylink_ethtool_get_wol(dp->pl, w);
681
682 if (ds->ops->get_wol)
683 ds->ops->get_wol(ds, dp->index, w);
684 }
685
686 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
687 {
688 struct dsa_port *dp = dsa_slave_to_port(dev);
689 struct dsa_switch *ds = dp->ds;
690 int ret = -EOPNOTSUPP;
691
692 phylink_ethtool_set_wol(dp->pl, w);
693
694 if (ds->ops->set_wol)
695 ret = ds->ops->set_wol(ds, dp->index, w);
696
697 return ret;
698 }
699
700 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
701 {
702 struct dsa_port *dp = dsa_slave_to_port(dev);
703 struct dsa_switch *ds = dp->ds;
704 int ret;
705
706 /* Port's PHY and MAC both need to be EEE capable */
707 if (!dev->phydev || !dp->pl)
708 return -ENODEV;
709
710 if (!ds->ops->set_mac_eee)
711 return -EOPNOTSUPP;
712
713 ret = ds->ops->set_mac_eee(ds, dp->index, e);
714 if (ret)
715 return ret;
716
717 return phylink_ethtool_set_eee(dp->pl, e);
718 }
719
720 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
721 {
722 struct dsa_port *dp = dsa_slave_to_port(dev);
723 struct dsa_switch *ds = dp->ds;
724 int ret;
725
726 /* Port's PHY and MAC both need to be EEE capable */
727 if (!dev->phydev || !dp->pl)
728 return -ENODEV;
729
730 if (!ds->ops->get_mac_eee)
731 return -EOPNOTSUPP;
732
733 ret = ds->ops->get_mac_eee(ds, dp->index, e);
734 if (ret)
735 return ret;
736
737 return phylink_ethtool_get_eee(dp->pl, e);
738 }
739
740 static 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
748 static 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);
754 }
755
756 static 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
764 static 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
772 #ifdef CONFIG_NET_POLL_CONTROLLER
773 static int dsa_slave_netpoll_setup(struct net_device *dev,
774 struct netpoll_info *ni)
775 {
776 struct net_device *master = dsa_slave_to_master(dev);
777 struct dsa_slave_priv *p = netdev_priv(dev);
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;
792 out:
793 return err;
794 }
795
796 static 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
806 __netpoll_free(netpoll);
807 }
808
809 static void dsa_slave_poll_controller(struct net_device *dev)
810 {
811 }
812 #endif
813
814 static int dsa_slave_get_phys_port_name(struct net_device *dev,
815 char *name, size_t len)
816 {
817 struct dsa_port *dp = dsa_slave_to_port(dev);
818
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
826 if (snprintf(name, len, "p%d", dp->index) >= len)
827 return -EINVAL;
828
829 return 0;
830 }
831
832 static struct dsa_mall_tc_entry *
833 dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie)
834 {
835 struct dsa_slave_priv *p = netdev_priv(dev);
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
845 static int
846 dsa_slave_add_cls_matchall_mirred(struct net_device *dev,
847 struct tc_cls_matchall_offload *cls,
848 bool ingress)
849 {
850 struct dsa_port *dp = dsa_slave_to_port(dev);
851 struct dsa_slave_priv *p = netdev_priv(dev);
852 struct dsa_mall_mirror_tc_entry *mirror;
853 struct dsa_mall_tc_entry *mall_tc_entry;
854 struct dsa_switch *ds = dp->ds;
855 struct flow_action_entry *act;
856 struct dsa_port *to_dp;
857 int err;
858
859 act = &cls->rule->action.entries[0];
860
861 if (!ds->ops->port_mirror_add)
862 return -EOPNOTSUPP;
863
864 if (!act->dev)
865 return -EINVAL;
866
867 if (!flow_action_basic_hw_stats_check(&cls->rule->action,
868 cls->common.extack))
869 return -EOPNOTSUPP;
870
871 act = &cls->rule->action.entries[0];
872
873 if (!dsa_slave_dev_check(act->dev))
874 return -EOPNOTSUPP;
875
876 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
877 if (!mall_tc_entry)
878 return -ENOMEM;
879
880 mall_tc_entry->cookie = cls->cookie;
881 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
882 mirror = &mall_tc_entry->mirror;
883
884 to_dp = dsa_slave_to_port(act->dev);
885
886 mirror->to_local_port = to_dp->index;
887 mirror->ingress = ingress;
888
889 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress);
890 if (err) {
891 kfree(mall_tc_entry);
892 return err;
893 }
894
895 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
896
897 return err;
898 }
899
900 static int
901 dsa_slave_add_cls_matchall_police(struct net_device *dev,
902 struct tc_cls_matchall_offload *cls,
903 bool ingress)
904 {
905 struct netlink_ext_ack *extack = cls->common.extack;
906 struct dsa_port *dp = dsa_slave_to_port(dev);
907 struct dsa_slave_priv *p = netdev_priv(dev);
908 struct dsa_mall_policer_tc_entry *policer;
909 struct dsa_mall_tc_entry *mall_tc_entry;
910 struct dsa_switch *ds = dp->ds;
911 struct flow_action_entry *act;
912 int err;
913
914 if (!ds->ops->port_policer_add) {
915 NL_SET_ERR_MSG_MOD(extack,
916 "Policing offload not implemented\n");
917 return -EOPNOTSUPP;
918 }
919
920 if (!ingress) {
921 NL_SET_ERR_MSG_MOD(extack,
922 "Only supported on ingress qdisc\n");
923 return -EOPNOTSUPP;
924 }
925
926 if (!flow_action_basic_hw_stats_check(&cls->rule->action,
927 cls->common.extack))
928 return -EOPNOTSUPP;
929
930 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) {
931 if (mall_tc_entry->type == DSA_PORT_MALL_POLICER) {
932 NL_SET_ERR_MSG_MOD(extack,
933 "Only one port policer allowed\n");
934 return -EEXIST;
935 }
936 }
937
938 act = &cls->rule->action.entries[0];
939
940 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
941 if (!mall_tc_entry)
942 return -ENOMEM;
943
944 mall_tc_entry->cookie = cls->cookie;
945 mall_tc_entry->type = DSA_PORT_MALL_POLICER;
946 policer = &mall_tc_entry->policer;
947 policer->rate_bytes_per_sec = act->police.rate_bytes_ps;
948 policer->burst = act->police.burst;
949
950 err = ds->ops->port_policer_add(ds, dp->index, policer);
951 if (err) {
952 kfree(mall_tc_entry);
953 return err;
954 }
955
956 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
957
958 return err;
959 }
960
961 static int dsa_slave_add_cls_matchall(struct net_device *dev,
962 struct tc_cls_matchall_offload *cls,
963 bool ingress)
964 {
965 int err = -EOPNOTSUPP;
966
967 if (cls->common.protocol == htons(ETH_P_ALL) &&
968 flow_offload_has_one_action(&cls->rule->action) &&
969 cls->rule->action.entries[0].id == FLOW_ACTION_MIRRED)
970 err = dsa_slave_add_cls_matchall_mirred(dev, cls, ingress);
971 else if (flow_offload_has_one_action(&cls->rule->action) &&
972 cls->rule->action.entries[0].id == FLOW_ACTION_POLICE)
973 err = dsa_slave_add_cls_matchall_police(dev, cls, ingress);
974
975 return err;
976 }
977
978 static void dsa_slave_del_cls_matchall(struct net_device *dev,
979 struct tc_cls_matchall_offload *cls)
980 {
981 struct dsa_port *dp = dsa_slave_to_port(dev);
982 struct dsa_mall_tc_entry *mall_tc_entry;
983 struct dsa_switch *ds = dp->ds;
984
985 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie);
986 if (!mall_tc_entry)
987 return;
988
989 list_del(&mall_tc_entry->list);
990
991 switch (mall_tc_entry->type) {
992 case DSA_PORT_MALL_MIRROR:
993 if (ds->ops->port_mirror_del)
994 ds->ops->port_mirror_del(ds, dp->index,
995 &mall_tc_entry->mirror);
996 break;
997 case DSA_PORT_MALL_POLICER:
998 if (ds->ops->port_policer_del)
999 ds->ops->port_policer_del(ds, dp->index);
1000 break;
1001 default:
1002 WARN_ON(1);
1003 }
1004
1005 kfree(mall_tc_entry);
1006 }
1007
1008 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
1009 struct tc_cls_matchall_offload *cls,
1010 bool ingress)
1011 {
1012 if (cls->common.chain_index)
1013 return -EOPNOTSUPP;
1014
1015 switch (cls->command) {
1016 case TC_CLSMATCHALL_REPLACE:
1017 return dsa_slave_add_cls_matchall(dev, cls, ingress);
1018 case TC_CLSMATCHALL_DESTROY:
1019 dsa_slave_del_cls_matchall(dev, cls);
1020 return 0;
1021 default:
1022 return -EOPNOTSUPP;
1023 }
1024 }
1025
1026 static int dsa_slave_add_cls_flower(struct net_device *dev,
1027 struct flow_cls_offload *cls,
1028 bool ingress)
1029 {
1030 struct dsa_port *dp = dsa_slave_to_port(dev);
1031 struct dsa_switch *ds = dp->ds;
1032 int port = dp->index;
1033
1034 if (!ds->ops->cls_flower_add)
1035 return -EOPNOTSUPP;
1036
1037 return ds->ops->cls_flower_add(ds, port, cls, ingress);
1038 }
1039
1040 static int dsa_slave_del_cls_flower(struct net_device *dev,
1041 struct flow_cls_offload *cls,
1042 bool ingress)
1043 {
1044 struct dsa_port *dp = dsa_slave_to_port(dev);
1045 struct dsa_switch *ds = dp->ds;
1046 int port = dp->index;
1047
1048 if (!ds->ops->cls_flower_del)
1049 return -EOPNOTSUPP;
1050
1051 return ds->ops->cls_flower_del(ds, port, cls, ingress);
1052 }
1053
1054 static int dsa_slave_stats_cls_flower(struct net_device *dev,
1055 struct flow_cls_offload *cls,
1056 bool ingress)
1057 {
1058 struct dsa_port *dp = dsa_slave_to_port(dev);
1059 struct dsa_switch *ds = dp->ds;
1060 int port = dp->index;
1061
1062 if (!ds->ops->cls_flower_stats)
1063 return -EOPNOTSUPP;
1064
1065 return ds->ops->cls_flower_stats(ds, port, cls, ingress);
1066 }
1067
1068 static int dsa_slave_setup_tc_cls_flower(struct net_device *dev,
1069 struct flow_cls_offload *cls,
1070 bool ingress)
1071 {
1072 switch (cls->command) {
1073 case FLOW_CLS_REPLACE:
1074 return dsa_slave_add_cls_flower(dev, cls, ingress);
1075 case FLOW_CLS_DESTROY:
1076 return dsa_slave_del_cls_flower(dev, cls, ingress);
1077 case FLOW_CLS_STATS:
1078 return dsa_slave_stats_cls_flower(dev, cls, ingress);
1079 default:
1080 return -EOPNOTSUPP;
1081 }
1082 }
1083
1084 static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
1085 void *cb_priv, bool ingress)
1086 {
1087 struct net_device *dev = cb_priv;
1088
1089 if (!tc_can_offload(dev))
1090 return -EOPNOTSUPP;
1091
1092 switch (type) {
1093 case TC_SETUP_CLSMATCHALL:
1094 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress);
1095 case TC_SETUP_CLSFLOWER:
1096 return dsa_slave_setup_tc_cls_flower(dev, type_data, ingress);
1097 default:
1098 return -EOPNOTSUPP;
1099 }
1100 }
1101
1102 static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type,
1103 void *type_data, void *cb_priv)
1104 {
1105 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true);
1106 }
1107
1108 static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
1109 void *type_data, void *cb_priv)
1110 {
1111 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
1112 }
1113
1114 static LIST_HEAD(dsa_slave_block_cb_list);
1115
1116 static int dsa_slave_setup_tc_block(struct net_device *dev,
1117 struct flow_block_offload *f)
1118 {
1119 struct flow_block_cb *block_cb;
1120 flow_setup_cb_t *cb;
1121
1122 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
1123 cb = dsa_slave_setup_tc_block_cb_ig;
1124 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
1125 cb = dsa_slave_setup_tc_block_cb_eg;
1126 else
1127 return -EOPNOTSUPP;
1128
1129 f->driver_block_list = &dsa_slave_block_cb_list;
1130
1131 switch (f->command) {
1132 case FLOW_BLOCK_BIND:
1133 if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list))
1134 return -EBUSY;
1135
1136 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL);
1137 if (IS_ERR(block_cb))
1138 return PTR_ERR(block_cb);
1139
1140 flow_block_cb_add(block_cb, f);
1141 list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list);
1142 return 0;
1143 case FLOW_BLOCK_UNBIND:
1144 block_cb = flow_block_cb_lookup(f->block, cb, dev);
1145 if (!block_cb)
1146 return -ENOENT;
1147
1148 flow_block_cb_remove(block_cb, f);
1149 list_del(&block_cb->driver_list);
1150 return 0;
1151 default:
1152 return -EOPNOTSUPP;
1153 }
1154 }
1155
1156 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
1157 void *type_data)
1158 {
1159 struct dsa_port *dp = dsa_slave_to_port(dev);
1160 struct dsa_switch *ds = dp->ds;
1161
1162 if (type == TC_SETUP_BLOCK)
1163 return dsa_slave_setup_tc_block(dev, type_data);
1164
1165 if (!ds->ops->port_setup_tc)
1166 return -EOPNOTSUPP;
1167
1168 return ds->ops->port_setup_tc(ds, dp->index, type, type_data);
1169 }
1170
1171 static void dsa_slave_get_stats64(struct net_device *dev,
1172 struct rtnl_link_stats64 *stats)
1173 {
1174 struct dsa_slave_priv *p = netdev_priv(dev);
1175 struct pcpu_sw_netstats *s;
1176 unsigned int start;
1177 int i;
1178
1179 netdev_stats_to_stats64(stats, &dev->stats);
1180 for_each_possible_cpu(i) {
1181 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
1182
1183 s = per_cpu_ptr(p->stats64, i);
1184 do {
1185 start = u64_stats_fetch_begin_irq(&s->syncp);
1186 tx_packets = s->tx_packets;
1187 tx_bytes = s->tx_bytes;
1188 rx_packets = s->rx_packets;
1189 rx_bytes = s->rx_bytes;
1190 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
1191
1192 stats->tx_packets += tx_packets;
1193 stats->tx_bytes += tx_bytes;
1194 stats->rx_packets += rx_packets;
1195 stats->rx_bytes += rx_bytes;
1196 }
1197 }
1198
1199 static int dsa_slave_get_rxnfc(struct net_device *dev,
1200 struct ethtool_rxnfc *nfc, u32 *rule_locs)
1201 {
1202 struct dsa_port *dp = dsa_slave_to_port(dev);
1203 struct dsa_switch *ds = dp->ds;
1204
1205 if (!ds->ops->get_rxnfc)
1206 return -EOPNOTSUPP;
1207
1208 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);
1209 }
1210
1211 static int dsa_slave_set_rxnfc(struct net_device *dev,
1212 struct ethtool_rxnfc *nfc)
1213 {
1214 struct dsa_port *dp = dsa_slave_to_port(dev);
1215 struct dsa_switch *ds = dp->ds;
1216
1217 if (!ds->ops->set_rxnfc)
1218 return -EOPNOTSUPP;
1219
1220 return ds->ops->set_rxnfc(ds, dp->index, nfc);
1221 }
1222
1223 static int dsa_slave_get_ts_info(struct net_device *dev,
1224 struct ethtool_ts_info *ts)
1225 {
1226 struct dsa_slave_priv *p = netdev_priv(dev);
1227 struct dsa_switch *ds = p->dp->ds;
1228
1229 if (!ds->ops->get_ts_info)
1230 return -EOPNOTSUPP;
1231
1232 return ds->ops->get_ts_info(ds, p->dp->index, ts);
1233 }
1234
1235 static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
1236 u16 vid)
1237 {
1238 struct dsa_port *dp = dsa_slave_to_port(dev);
1239 struct bridge_vlan_info info;
1240 int ret;
1241
1242 /* Check for a possible bridge VLAN entry now since there is no
1243 * need to emulate the switchdev prepare + commit phase.
1244 */
1245 if (dp->bridge_dev) {
1246 if (!br_vlan_enabled(dp->bridge_dev))
1247 return 0;
1248
1249 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
1250 * device, respectively the VID is not found, returning
1251 * 0 means success, which is a failure for us here.
1252 */
1253 ret = br_vlan_get_info(dp->bridge_dev, vid, &info);
1254 if (ret == 0)
1255 return -EBUSY;
1256 }
1257
1258 ret = dsa_port_vid_add(dp, vid, 0);
1259 if (ret)
1260 return ret;
1261
1262 ret = dsa_port_vid_add(dp->cpu_dp, vid, 0);
1263 if (ret)
1264 return ret;
1265
1266 return 0;
1267 }
1268
1269 static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
1270 u16 vid)
1271 {
1272 struct dsa_port *dp = dsa_slave_to_port(dev);
1273 struct bridge_vlan_info info;
1274 int ret;
1275
1276 /* Check for a possible bridge VLAN entry now since there is no
1277 * need to emulate the switchdev prepare + commit phase.
1278 */
1279 if (dp->bridge_dev) {
1280 if (!br_vlan_enabled(dp->bridge_dev))
1281 return 0;
1282
1283 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
1284 * device, respectively the VID is not found, returning
1285 * 0 means success, which is a failure for us here.
1286 */
1287 ret = br_vlan_get_info(dp->bridge_dev, vid, &info);
1288 if (ret == 0)
1289 return -EBUSY;
1290 }
1291
1292 /* Do not deprogram the CPU port as it may be shared with other user
1293 * ports which can be members of this VLAN as well.
1294 */
1295 return dsa_port_vid_del(dp, vid);
1296 }
1297
1298 struct dsa_hw_port {
1299 struct list_head list;
1300 struct net_device *dev;
1301 int old_mtu;
1302 };
1303
1304 static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu)
1305 {
1306 const struct dsa_hw_port *p;
1307 int err;
1308
1309 list_for_each_entry(p, hw_port_list, list) {
1310 if (p->dev->mtu == mtu)
1311 continue;
1312
1313 err = dev_set_mtu(p->dev, mtu);
1314 if (err)
1315 goto rollback;
1316 }
1317
1318 return 0;
1319
1320 rollback:
1321 list_for_each_entry_continue_reverse(p, hw_port_list, list) {
1322 if (p->dev->mtu == p->old_mtu)
1323 continue;
1324
1325 if (dev_set_mtu(p->dev, p->old_mtu))
1326 netdev_err(p->dev, "Failed to restore MTU\n");
1327 }
1328
1329 return err;
1330 }
1331
1332 static void dsa_hw_port_list_free(struct list_head *hw_port_list)
1333 {
1334 struct dsa_hw_port *p, *n;
1335
1336 list_for_each_entry_safe(p, n, hw_port_list, list)
1337 kfree(p);
1338 }
1339
1340 /* Make the hardware datapath to/from @dev limited to a common MTU */
1341 static void dsa_bridge_mtu_normalization(struct dsa_port *dp)
1342 {
1343 struct list_head hw_port_list;
1344 struct dsa_switch_tree *dst;
1345 int min_mtu = ETH_MAX_MTU;
1346 struct dsa_port *other_dp;
1347 int err;
1348
1349 if (!dp->ds->mtu_enforcement_ingress)
1350 return;
1351
1352 if (!dp->bridge_dev)
1353 return;
1354
1355 INIT_LIST_HEAD(&hw_port_list);
1356
1357 /* Populate the list of ports that are part of the same bridge
1358 * as the newly added/modified port
1359 */
1360 list_for_each_entry(dst, &dsa_tree_list, list) {
1361 list_for_each_entry(other_dp, &dst->ports, list) {
1362 struct dsa_hw_port *hw_port;
1363 struct net_device *slave;
1364
1365 if (other_dp->type != DSA_PORT_TYPE_USER)
1366 continue;
1367
1368 if (other_dp->bridge_dev != dp->bridge_dev)
1369 continue;
1370
1371 if (!other_dp->ds->mtu_enforcement_ingress)
1372 continue;
1373
1374 slave = other_dp->slave;
1375
1376 if (min_mtu > slave->mtu)
1377 min_mtu = slave->mtu;
1378
1379 hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL);
1380 if (!hw_port)
1381 goto out;
1382
1383 hw_port->dev = slave;
1384 hw_port->old_mtu = slave->mtu;
1385
1386 list_add(&hw_port->list, &hw_port_list);
1387 }
1388 }
1389
1390 /* Attempt to configure the entire hardware bridge to the newly added
1391 * interface's MTU first, regardless of whether the intention of the
1392 * user was to raise or lower it.
1393 */
1394 err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->slave->mtu);
1395 if (!err)
1396 goto out;
1397
1398 /* Clearly that didn't work out so well, so just set the minimum MTU on
1399 * all hardware bridge ports now. If this fails too, then all ports will
1400 * still have their old MTU rolled back anyway.
1401 */
1402 dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu);
1403
1404 out:
1405 dsa_hw_port_list_free(&hw_port_list);
1406 }
1407
1408 static int dsa_slave_change_mtu(struct net_device *dev, int new_mtu)
1409 {
1410 struct net_device *master = dsa_slave_to_master(dev);
1411 struct dsa_port *dp = dsa_slave_to_port(dev);
1412 struct dsa_slave_priv *p = netdev_priv(dev);
1413 struct dsa_switch *ds = p->dp->ds;
1414 struct dsa_port *cpu_dp;
1415 int port = p->dp->index;
1416 int largest_mtu = 0;
1417 int new_master_mtu;
1418 int old_master_mtu;
1419 int mtu_limit;
1420 int cpu_mtu;
1421 int err, i;
1422
1423 if (!ds->ops->port_change_mtu)
1424 return -EOPNOTSUPP;
1425
1426 for (i = 0; i < ds->num_ports; i++) {
1427 int slave_mtu;
1428
1429 if (!dsa_is_user_port(ds, i))
1430 continue;
1431
1432 /* During probe, this function will be called for each slave
1433 * device, while not all of them have been allocated. That's
1434 * ok, it doesn't change what the maximum is, so ignore it.
1435 */
1436 if (!dsa_to_port(ds, i)->slave)
1437 continue;
1438
1439 /* Pretend that we already applied the setting, which we
1440 * actually haven't (still haven't done all integrity checks)
1441 */
1442 if (i == port)
1443 slave_mtu = new_mtu;
1444 else
1445 slave_mtu = dsa_to_port(ds, i)->slave->mtu;
1446
1447 if (largest_mtu < slave_mtu)
1448 largest_mtu = slave_mtu;
1449 }
1450
1451 cpu_dp = dsa_to_port(ds, port)->cpu_dp;
1452
1453 mtu_limit = min_t(int, master->max_mtu, dev->max_mtu);
1454 old_master_mtu = master->mtu;
1455 new_master_mtu = largest_mtu + cpu_dp->tag_ops->overhead;
1456 if (new_master_mtu > mtu_limit)
1457 return -ERANGE;
1458
1459 /* If the master MTU isn't over limit, there's no need to check the CPU
1460 * MTU, since that surely isn't either.
1461 */
1462 cpu_mtu = largest_mtu;
1463
1464 /* Start applying stuff */
1465 if (new_master_mtu != old_master_mtu) {
1466 err = dev_set_mtu(master, new_master_mtu);
1467 if (err < 0)
1468 goto out_master_failed;
1469
1470 /* We only need to propagate the MTU of the CPU port to
1471 * upstream switches.
1472 */
1473 err = dsa_port_mtu_change(cpu_dp, cpu_mtu, true);
1474 if (err)
1475 goto out_cpu_failed;
1476 }
1477
1478 err = dsa_port_mtu_change(dp, new_mtu, false);
1479 if (err)
1480 goto out_port_failed;
1481
1482 dev->mtu = new_mtu;
1483
1484 dsa_bridge_mtu_normalization(dp);
1485
1486 return 0;
1487
1488 out_port_failed:
1489 if (new_master_mtu != old_master_mtu)
1490 dsa_port_mtu_change(cpu_dp, old_master_mtu -
1491 cpu_dp->tag_ops->overhead,
1492 true);
1493 out_cpu_failed:
1494 if (new_master_mtu != old_master_mtu)
1495 dev_set_mtu(master, old_master_mtu);
1496 out_master_failed:
1497 return err;
1498 }
1499
1500 static const struct ethtool_ops dsa_slave_ethtool_ops = {
1501 .get_drvinfo = dsa_slave_get_drvinfo,
1502 .get_regs_len = dsa_slave_get_regs_len,
1503 .get_regs = dsa_slave_get_regs,
1504 .nway_reset = dsa_slave_nway_reset,
1505 .get_link = ethtool_op_get_link,
1506 .get_eeprom_len = dsa_slave_get_eeprom_len,
1507 .get_eeprom = dsa_slave_get_eeprom,
1508 .set_eeprom = dsa_slave_set_eeprom,
1509 .get_strings = dsa_slave_get_strings,
1510 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
1511 .get_sset_count = dsa_slave_get_sset_count,
1512 .set_wol = dsa_slave_set_wol,
1513 .get_wol = dsa_slave_get_wol,
1514 .set_eee = dsa_slave_set_eee,
1515 .get_eee = dsa_slave_get_eee,
1516 .get_link_ksettings = dsa_slave_get_link_ksettings,
1517 .set_link_ksettings = dsa_slave_set_link_ksettings,
1518 .get_pauseparam = dsa_slave_get_pauseparam,
1519 .set_pauseparam = dsa_slave_set_pauseparam,
1520 .get_rxnfc = dsa_slave_get_rxnfc,
1521 .set_rxnfc = dsa_slave_set_rxnfc,
1522 .get_ts_info = dsa_slave_get_ts_info,
1523 };
1524
1525 /* legacy way, bypassing the bridge *****************************************/
1526 int dsa_legacy_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1527 struct net_device *dev,
1528 const unsigned char *addr, u16 vid,
1529 u16 flags,
1530 struct netlink_ext_ack *extack)
1531 {
1532 struct dsa_port *dp = dsa_slave_to_port(dev);
1533
1534 return dsa_port_fdb_add(dp, addr, vid);
1535 }
1536
1537 int dsa_legacy_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
1538 struct net_device *dev,
1539 const unsigned char *addr, u16 vid)
1540 {
1541 struct dsa_port *dp = dsa_slave_to_port(dev);
1542
1543 return dsa_port_fdb_del(dp, addr, vid);
1544 }
1545
1546 static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev)
1547 {
1548 struct dsa_port *dp = dsa_slave_to_port(dev);
1549
1550 return dp->ds->devlink ? &dp->devlink_port : NULL;
1551 }
1552
1553 static const struct net_device_ops dsa_slave_netdev_ops = {
1554 .ndo_open = dsa_slave_open,
1555 .ndo_stop = dsa_slave_close,
1556 .ndo_start_xmit = dsa_slave_xmit,
1557 .ndo_change_rx_flags = dsa_slave_change_rx_flags,
1558 .ndo_set_rx_mode = dsa_slave_set_rx_mode,
1559 .ndo_set_mac_address = dsa_slave_set_mac_address,
1560 .ndo_fdb_add = dsa_legacy_fdb_add,
1561 .ndo_fdb_del = dsa_legacy_fdb_del,
1562 .ndo_fdb_dump = dsa_slave_fdb_dump,
1563 .ndo_do_ioctl = dsa_slave_ioctl,
1564 .ndo_get_iflink = dsa_slave_get_iflink,
1565 #ifdef CONFIG_NET_POLL_CONTROLLER
1566 .ndo_netpoll_setup = dsa_slave_netpoll_setup,
1567 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup,
1568 .ndo_poll_controller = dsa_slave_poll_controller,
1569 #endif
1570 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
1571 .ndo_setup_tc = dsa_slave_setup_tc,
1572 .ndo_get_stats64 = dsa_slave_get_stats64,
1573 .ndo_get_port_parent_id = dsa_slave_get_port_parent_id,
1574 .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid,
1575 .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid,
1576 .ndo_get_devlink_port = dsa_slave_get_devlink_port,
1577 .ndo_change_mtu = dsa_slave_change_mtu,
1578 };
1579
1580 static struct device_type dsa_type = {
1581 .name = "dsa",
1582 };
1583
1584 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)
1585 {
1586 const struct dsa_port *dp = dsa_to_port(ds, port);
1587
1588 if (dp->pl)
1589 phylink_mac_change(dp->pl, up);
1590 }
1591 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
1592
1593 static void dsa_slave_phylink_fixed_state(struct net_device *dev,
1594 struct phylink_link_state *state)
1595 {
1596 struct dsa_port *dp = dsa_slave_to_port(dev);
1597 struct dsa_switch *ds = dp->ds;
1598
1599 /* No need to check that this operation is valid, the callback would
1600 * not be called if it was not.
1601 */
1602 ds->ops->phylink_fixed_state(ds, dp->index, state);
1603 }
1604
1605 /* slave device setup *******************************************************/
1606 static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)
1607 {
1608 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1609 struct dsa_switch *ds = dp->ds;
1610
1611 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
1612 if (!slave_dev->phydev) {
1613 netdev_err(slave_dev, "no phy at %d\n", addr);
1614 return -ENODEV;
1615 }
1616
1617 return phylink_connect_phy(dp->pl, slave_dev->phydev);
1618 }
1619
1620 static int dsa_slave_phy_setup(struct net_device *slave_dev)
1621 {
1622 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1623 struct device_node *port_dn = dp->dn;
1624 struct dsa_switch *ds = dp->ds;
1625 phy_interface_t mode;
1626 u32 phy_flags = 0;
1627 int ret;
1628
1629 ret = of_get_phy_mode(port_dn, &mode);
1630 if (ret)
1631 mode = PHY_INTERFACE_MODE_NA;
1632
1633 dp->pl_config.dev = &slave_dev->dev;
1634 dp->pl_config.type = PHYLINK_NETDEV;
1635
1636 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), mode,
1637 &dsa_port_phylink_mac_ops);
1638 if (IS_ERR(dp->pl)) {
1639 netdev_err(slave_dev,
1640 "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1641 return PTR_ERR(dp->pl);
1642 }
1643
1644 /* Register only if the switch provides such a callback, since this
1645 * callback takes precedence over polling the link GPIO in PHYLINK
1646 * (see phylink_get_fixed_state).
1647 */
1648 if (ds->ops->phylink_fixed_state)
1649 phylink_fixed_state_cb(dp->pl, dsa_slave_phylink_fixed_state);
1650
1651 if (ds->ops->get_phy_flags)
1652 phy_flags = ds->ops->get_phy_flags(ds, dp->index);
1653
1654 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);
1655 if (ret == -ENODEV && ds->slave_mii_bus) {
1656 /* We could not connect to a designated PHY or SFP, so try to
1657 * use the switch internal MDIO bus instead
1658 */
1659 ret = dsa_slave_phy_connect(slave_dev, dp->index);
1660 if (ret) {
1661 netdev_err(slave_dev,
1662 "failed to connect to port %d: %d\n",
1663 dp->index, ret);
1664 phylink_destroy(dp->pl);
1665 return ret;
1666 }
1667 }
1668
1669 return ret;
1670 }
1671
1672 int dsa_slave_suspend(struct net_device *slave_dev)
1673 {
1674 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1675
1676 if (!netif_running(slave_dev))
1677 return 0;
1678
1679 netif_device_detach(slave_dev);
1680
1681 rtnl_lock();
1682 phylink_stop(dp->pl);
1683 rtnl_unlock();
1684
1685 return 0;
1686 }
1687
1688 int dsa_slave_resume(struct net_device *slave_dev)
1689 {
1690 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1691
1692 if (!netif_running(slave_dev))
1693 return 0;
1694
1695 netif_device_attach(slave_dev);
1696
1697 rtnl_lock();
1698 phylink_start(dp->pl);
1699 rtnl_unlock();
1700
1701 return 0;
1702 }
1703
1704 static void dsa_slave_notify(struct net_device *dev, unsigned long val)
1705 {
1706 struct net_device *master = dsa_slave_to_master(dev);
1707 struct dsa_port *dp = dsa_slave_to_port(dev);
1708 struct dsa_notifier_register_info rinfo = {
1709 .switch_number = dp->ds->index,
1710 .port_number = dp->index,
1711 .master = master,
1712 .info.dev = dev,
1713 };
1714
1715 call_dsa_notifiers(val, dev, &rinfo.info);
1716 }
1717
1718 int dsa_slave_create(struct dsa_port *port)
1719 {
1720 const struct dsa_port *cpu_dp = port->cpu_dp;
1721 struct net_device *master = cpu_dp->master;
1722 struct dsa_switch *ds = port->ds;
1723 const char *name = port->name;
1724 struct net_device *slave_dev;
1725 struct dsa_slave_priv *p;
1726 int ret;
1727
1728 if (!ds->num_tx_queues)
1729 ds->num_tx_queues = 1;
1730
1731 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1732 NET_NAME_UNKNOWN, ether_setup,
1733 ds->num_tx_queues, 1);
1734 if (slave_dev == NULL)
1735 return -ENOMEM;
1736
1737 slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
1738 if (ds->ops->port_vlan_add && ds->ops->port_vlan_del)
1739 slave_dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1740 slave_dev->hw_features |= NETIF_F_HW_TC;
1741 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1742 if (!IS_ERR_OR_NULL(port->mac))
1743 ether_addr_copy(slave_dev->dev_addr, port->mac);
1744 else
1745 eth_hw_addr_inherit(slave_dev, master);
1746 slave_dev->priv_flags |= IFF_NO_QUEUE;
1747 slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1748 slave_dev->min_mtu = 0;
1749 if (ds->ops->port_max_mtu)
1750 slave_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index);
1751 else
1752 slave_dev->max_mtu = ETH_MAX_MTU;
1753 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1754
1755 SET_NETDEV_DEV(slave_dev, port->ds->dev);
1756 slave_dev->dev.of_node = port->dn;
1757 slave_dev->vlan_features = master->vlan_features;
1758
1759 p = netdev_priv(slave_dev);
1760 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1761 if (!p->stats64) {
1762 free_netdev(slave_dev);
1763 return -ENOMEM;
1764 }
1765 p->dp = port;
1766 INIT_LIST_HEAD(&p->mall_tc_list);
1767 p->xmit = cpu_dp->tag_ops->xmit;
1768 port->slave = slave_dev;
1769
1770 rtnl_lock();
1771 ret = dsa_slave_change_mtu(slave_dev, ETH_DATA_LEN);
1772 rtnl_unlock();
1773 if (ret)
1774 dev_warn(ds->dev, "nonfatal error %d setting MTU on port %d\n",
1775 ret, port->index);
1776
1777 netif_carrier_off(slave_dev);
1778
1779 ret = dsa_slave_phy_setup(slave_dev);
1780 if (ret) {
1781 netdev_err(master, "error %d setting up slave phy\n", ret);
1782 goto out_free;
1783 }
1784
1785 dsa_slave_notify(slave_dev, DSA_PORT_REGISTER);
1786
1787 ret = register_netdev(slave_dev);
1788 if (ret) {
1789 netdev_err(master, "error %d registering interface %s\n",
1790 ret, slave_dev->name);
1791 goto out_phy;
1792 }
1793
1794 return 0;
1795
1796 out_phy:
1797 rtnl_lock();
1798 phylink_disconnect_phy(p->dp->pl);
1799 rtnl_unlock();
1800 phylink_destroy(p->dp->pl);
1801 out_free:
1802 free_percpu(p->stats64);
1803 free_netdev(slave_dev);
1804 port->slave = NULL;
1805 return ret;
1806 }
1807
1808 void dsa_slave_destroy(struct net_device *slave_dev)
1809 {
1810 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1811 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1812
1813 netif_carrier_off(slave_dev);
1814 rtnl_lock();
1815 phylink_disconnect_phy(dp->pl);
1816 rtnl_unlock();
1817
1818 dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
1819 unregister_netdev(slave_dev);
1820 phylink_destroy(dp->pl);
1821 free_percpu(p->stats64);
1822 free_netdev(slave_dev);
1823 }
1824
1825 bool dsa_slave_dev_check(const struct net_device *dev)
1826 {
1827 return dev->netdev_ops == &dsa_slave_netdev_ops;
1828 }
1829
1830 static int dsa_slave_changeupper(struct net_device *dev,
1831 struct netdev_notifier_changeupper_info *info)
1832 {
1833 struct dsa_port *dp = dsa_slave_to_port(dev);
1834 int err = NOTIFY_DONE;
1835
1836 if (netif_is_bridge_master(info->upper_dev)) {
1837 if (info->linking) {
1838 err = dsa_port_bridge_join(dp, info->upper_dev);
1839 if (!err)
1840 dsa_bridge_mtu_normalization(dp);
1841 err = notifier_from_errno(err);
1842 } else {
1843 dsa_port_bridge_leave(dp, info->upper_dev);
1844 err = NOTIFY_OK;
1845 }
1846 }
1847
1848 return err;
1849 }
1850
1851 static int dsa_slave_upper_vlan_check(struct net_device *dev,
1852 struct netdev_notifier_changeupper_info *
1853 info)
1854 {
1855 struct netlink_ext_ack *ext_ack;
1856 struct net_device *slave;
1857 struct dsa_port *dp;
1858
1859 ext_ack = netdev_notifier_info_to_extack(&info->info);
1860
1861 if (!is_vlan_dev(dev))
1862 return NOTIFY_DONE;
1863
1864 slave = vlan_dev_real_dev(dev);
1865 if (!dsa_slave_dev_check(slave))
1866 return NOTIFY_DONE;
1867
1868 dp = dsa_slave_to_port(slave);
1869 if (!dp->bridge_dev)
1870 return NOTIFY_DONE;
1871
1872 /* Deny enslaving a VLAN device into a VLAN-aware bridge */
1873 if (br_vlan_enabled(dp->bridge_dev) &&
1874 netif_is_bridge_master(info->upper_dev) && info->linking) {
1875 NL_SET_ERR_MSG_MOD(ext_ack,
1876 "Cannot enslave VLAN device into VLAN aware bridge");
1877 return notifier_from_errno(-EINVAL);
1878 }
1879
1880 return NOTIFY_DONE;
1881 }
1882
1883 static int dsa_slave_netdevice_event(struct notifier_block *nb,
1884 unsigned long event, void *ptr)
1885 {
1886 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1887
1888 if (event == NETDEV_CHANGEUPPER) {
1889 if (!dsa_slave_dev_check(dev))
1890 return dsa_slave_upper_vlan_check(dev, ptr);
1891
1892 return dsa_slave_changeupper(dev, ptr);
1893 }
1894
1895 return NOTIFY_DONE;
1896 }
1897
1898 struct dsa_switchdev_event_work {
1899 struct work_struct work;
1900 struct switchdev_notifier_fdb_info fdb_info;
1901 struct net_device *dev;
1902 unsigned long event;
1903 };
1904
1905 static void dsa_slave_switchdev_event_work(struct work_struct *work)
1906 {
1907 struct dsa_switchdev_event_work *switchdev_work =
1908 container_of(work, struct dsa_switchdev_event_work, work);
1909 struct net_device *dev = switchdev_work->dev;
1910 struct switchdev_notifier_fdb_info *fdb_info;
1911 struct dsa_port *dp = dsa_slave_to_port(dev);
1912 int err;
1913
1914 rtnl_lock();
1915 switch (switchdev_work->event) {
1916 case SWITCHDEV_FDB_ADD_TO_DEVICE:
1917 fdb_info = &switchdev_work->fdb_info;
1918 if (!fdb_info->added_by_user)
1919 break;
1920
1921 err = dsa_port_fdb_add(dp, fdb_info->addr, fdb_info->vid);
1922 if (err) {
1923 netdev_dbg(dev, "fdb add failed err=%d\n", err);
1924 break;
1925 }
1926 fdb_info->offloaded = true;
1927 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
1928 &fdb_info->info, NULL);
1929 break;
1930
1931 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1932 fdb_info = &switchdev_work->fdb_info;
1933 if (!fdb_info->added_by_user)
1934 break;
1935
1936 err = dsa_port_fdb_del(dp, fdb_info->addr, fdb_info->vid);
1937 if (err) {
1938 netdev_dbg(dev, "fdb del failed err=%d\n", err);
1939 dev_close(dev);
1940 }
1941 break;
1942 }
1943 rtnl_unlock();
1944
1945 kfree(switchdev_work->fdb_info.addr);
1946 kfree(switchdev_work);
1947 dev_put(dev);
1948 }
1949
1950 static int
1951 dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work *
1952 switchdev_work,
1953 const struct switchdev_notifier_fdb_info *
1954 fdb_info)
1955 {
1956 memcpy(&switchdev_work->fdb_info, fdb_info,
1957 sizeof(switchdev_work->fdb_info));
1958 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
1959 if (!switchdev_work->fdb_info.addr)
1960 return -ENOMEM;
1961 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
1962 fdb_info->addr);
1963 return 0;
1964 }
1965
1966 /* Called under rcu_read_lock() */
1967 static int dsa_slave_switchdev_event(struct notifier_block *unused,
1968 unsigned long event, void *ptr)
1969 {
1970 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1971 struct dsa_switchdev_event_work *switchdev_work;
1972 int err;
1973
1974 if (event == SWITCHDEV_PORT_ATTR_SET) {
1975 err = switchdev_handle_port_attr_set(dev, ptr,
1976 dsa_slave_dev_check,
1977 dsa_slave_port_attr_set);
1978 return notifier_from_errno(err);
1979 }
1980
1981 if (!dsa_slave_dev_check(dev))
1982 return NOTIFY_DONE;
1983
1984 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
1985 if (!switchdev_work)
1986 return NOTIFY_BAD;
1987
1988 INIT_WORK(&switchdev_work->work,
1989 dsa_slave_switchdev_event_work);
1990 switchdev_work->dev = dev;
1991 switchdev_work->event = event;
1992
1993 switch (event) {
1994 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
1995 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1996 if (dsa_slave_switchdev_fdb_work_init(switchdev_work, ptr))
1997 goto err_fdb_work_init;
1998 dev_hold(dev);
1999 break;
2000 default:
2001 kfree(switchdev_work);
2002 return NOTIFY_DONE;
2003 }
2004
2005 dsa_schedule_work(&switchdev_work->work);
2006 return NOTIFY_OK;
2007
2008 err_fdb_work_init:
2009 kfree(switchdev_work);
2010 return NOTIFY_BAD;
2011 }
2012
2013 static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused,
2014 unsigned long event, void *ptr)
2015 {
2016 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2017 int err;
2018
2019 switch (event) {
2020 case SWITCHDEV_PORT_OBJ_ADD:
2021 err = switchdev_handle_port_obj_add(dev, ptr,
2022 dsa_slave_dev_check,
2023 dsa_slave_port_obj_add);
2024 return notifier_from_errno(err);
2025 case SWITCHDEV_PORT_OBJ_DEL:
2026 err = switchdev_handle_port_obj_del(dev, ptr,
2027 dsa_slave_dev_check,
2028 dsa_slave_port_obj_del);
2029 return notifier_from_errno(err);
2030 case SWITCHDEV_PORT_ATTR_SET:
2031 err = switchdev_handle_port_attr_set(dev, ptr,
2032 dsa_slave_dev_check,
2033 dsa_slave_port_attr_set);
2034 return notifier_from_errno(err);
2035 }
2036
2037 return NOTIFY_DONE;
2038 }
2039
2040 static struct notifier_block dsa_slave_nb __read_mostly = {
2041 .notifier_call = dsa_slave_netdevice_event,
2042 };
2043
2044 static struct notifier_block dsa_slave_switchdev_notifier = {
2045 .notifier_call = dsa_slave_switchdev_event,
2046 };
2047
2048 static struct notifier_block dsa_slave_switchdev_blocking_notifier = {
2049 .notifier_call = dsa_slave_switchdev_blocking_event,
2050 };
2051
2052 int dsa_slave_register_notifier(void)
2053 {
2054 struct notifier_block *nb;
2055 int err;
2056
2057 err = register_netdevice_notifier(&dsa_slave_nb);
2058 if (err)
2059 return err;
2060
2061 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier);
2062 if (err)
2063 goto err_switchdev_nb;
2064
2065 nb = &dsa_slave_switchdev_blocking_notifier;
2066 err = register_switchdev_blocking_notifier(nb);
2067 if (err)
2068 goto err_switchdev_blocking_nb;
2069
2070 return 0;
2071
2072 err_switchdev_blocking_nb:
2073 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
2074 err_switchdev_nb:
2075 unregister_netdevice_notifier(&dsa_slave_nb);
2076 return err;
2077 }
2078
2079 void dsa_slave_unregister_notifier(void)
2080 {
2081 struct notifier_block *nb;
2082 int err;
2083
2084 nb = &dsa_slave_switchdev_blocking_notifier;
2085 err = unregister_switchdev_blocking_notifier(nb);
2086 if (err)
2087 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err);
2088
2089 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
2090 if (err)
2091 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err);
2092
2093 err = unregister_netdevice_notifier(&dsa_slave_nb);
2094 if (err)
2095 pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
2096 }
A mirror of Linus' kernel repository