projects / GitHub / moto-9609 / android_kernel_motorola_exynos9610.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[GitHub/moto-9609/android_kernel_motorola_exynos9610.git] / net / dsa / slave.c
1 /*
2 * net/dsa/slave.c - Slave device handling
3 * Copyright (c) 2008-2009 Marvell Semiconductor
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 */
10
11 #include <linux/list.h>
12 #include <linux/etherdevice.h>
13 #include <linux/netdevice.h>
14 #include <linux/phy.h>
15 #include <linux/phy_fixed.h>
16 #include <linux/of_net.h>
17 #include <linux/of_mdio.h>
18 #include <linux/mdio.h>
19 #include <linux/list.h>
20 #include <net/rtnetlink.h>
21 #include <net/pkt_cls.h>
22 #include <net/tc_act/tc_mirred.h>
23 #include <linux/if_bridge.h>
24 #include <linux/netpoll.h>
25
26 #include "dsa_priv.h"
27
28 static bool dsa_slave_dev_check(struct net_device *dev);
29
30 /* slave mii_bus handling ***************************************************/
31 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
32 {
33 struct dsa_switch *ds = bus->priv;
34
35 if (ds->phys_mii_mask & (1 << addr))
36 return ds->ops->phy_read(ds, addr, reg);
37
38 return 0xffff;
39 }
40
41 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
42 {
43 struct dsa_switch *ds = bus->priv;
44
45 if (ds->phys_mii_mask & (1 << addr))
46 return ds->ops->phy_write(ds, addr, reg, val);
47
48 return 0;
49 }
50
51 void dsa_slave_mii_bus_init(struct dsa_switch *ds)
52 {
53 ds->slave_mii_bus->priv = (void *)ds;
54 ds->slave_mii_bus->name = "dsa slave smi";
55 ds->slave_mii_bus->read = dsa_slave_phy_read;
56 ds->slave_mii_bus->write = dsa_slave_phy_write;
57 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
58 ds->dst->tree, ds->index);
59 ds->slave_mii_bus->parent = ds->dev;
60 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
61 }
62
63
64 /* slave device handling ****************************************************/
65 static int dsa_slave_get_iflink(const struct net_device *dev)
66 {
67 struct dsa_slave_priv *p = netdev_priv(dev);
68
69 return dsa_master_netdev(p)->ifindex;
70 }
71
72 static int dsa_slave_open(struct net_device *dev)
73 {
74 struct dsa_slave_priv *p = netdev_priv(dev);
75 struct dsa_port *dp = p->dp;
76 struct dsa_switch *ds = dp->ds;
77 struct net_device *master = dsa_master_netdev(p);
78 u8 stp_state = dp->bridge_dev ? BR_STATE_BLOCKING : BR_STATE_FORWARDING;
79 int err;
80
81 if (!(master->flags & IFF_UP))
82 return -ENETDOWN;
83
84 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
85 err = dev_uc_add(master, dev->dev_addr);
86 if (err < 0)
87 goto out;
88 }
89
90 if (dev->flags & IFF_ALLMULTI) {
91 err = dev_set_allmulti(master, 1);
92 if (err < 0)
93 goto del_unicast;
94 }
95 if (dev->flags & IFF_PROMISC) {
96 err = dev_set_promiscuity(master, 1);
97 if (err < 0)
98 goto clear_allmulti;
99 }
100
101 if (ds->ops->port_enable) {
102 err = ds->ops->port_enable(ds, p->dp->index, p->phy);
103 if (err)
104 goto clear_promisc;
105 }
106
107 dsa_port_set_state_now(p->dp, stp_state);
108
109 if (p->phy)
110 phy_start(p->phy);
111
112 return 0;
113
114 clear_promisc:
115 if (dev->flags & IFF_PROMISC)
116 dev_set_promiscuity(master, -1);
117 clear_allmulti:
118 if (dev->flags & IFF_ALLMULTI)
119 dev_set_allmulti(master, -1);
120 del_unicast:
121 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
122 dev_uc_del(master, dev->dev_addr);
123 out:
124 return err;
125 }
126
127 static int dsa_slave_close(struct net_device *dev)
128 {
129 struct dsa_slave_priv *p = netdev_priv(dev);
130 struct net_device *master = dsa_master_netdev(p);
131 struct dsa_switch *ds = p->dp->ds;
132
133 if (p->phy)
134 phy_stop(p->phy);
135
136 dev_mc_unsync(master, dev);
137 dev_uc_unsync(master, dev);
138 if (dev->flags & IFF_ALLMULTI)
139 dev_set_allmulti(master, -1);
140 if (dev->flags & IFF_PROMISC)
141 dev_set_promiscuity(master, -1);
142
143 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
144 dev_uc_del(master, dev->dev_addr);
145
146 if (ds->ops->port_disable)
147 ds->ops->port_disable(ds, p->dp->index, p->phy);
148
149 dsa_port_set_state_now(p->dp, BR_STATE_DISABLED);
150
151 return 0;
152 }
153
154 static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
155 {
156 struct dsa_slave_priv *p = netdev_priv(dev);
157 struct net_device *master = dsa_master_netdev(p);
158
159 if (change & IFF_ALLMULTI)
160 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
161 if (change & IFF_PROMISC)
162 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
163 }
164
165 static void dsa_slave_set_rx_mode(struct net_device *dev)
166 {
167 struct dsa_slave_priv *p = netdev_priv(dev);
168 struct net_device *master = dsa_master_netdev(p);
169
170 dev_mc_sync(master, dev);
171 dev_uc_sync(master, dev);
172 }
173
174 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
175 {
176 struct dsa_slave_priv *p = netdev_priv(dev);
177 struct net_device *master = dsa_master_netdev(p);
178 struct sockaddr *addr = a;
179 int err;
180
181 if (!is_valid_ether_addr(addr->sa_data))
182 return -EADDRNOTAVAIL;
183
184 if (!(dev->flags & IFF_UP))
185 goto out;
186
187 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
188 err = dev_uc_add(master, addr->sa_data);
189 if (err < 0)
190 return err;
191 }
192
193 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
194 dev_uc_del(master, dev->dev_addr);
195
196 out:
197 ether_addr_copy(dev->dev_addr, addr->sa_data);
198
199 return 0;
200 }
201
202 struct dsa_slave_dump_ctx {
203 struct net_device *dev;
204 struct sk_buff *skb;
205 struct netlink_callback *cb;
206 int idx;
207 };
208
209 static int
210 dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid,
211 bool is_static, void *data)
212 {
213 struct dsa_slave_dump_ctx *dump = data;
214 u32 portid = NETLINK_CB(dump->cb->skb).portid;
215 u32 seq = dump->cb->nlh->nlmsg_seq;
216 struct nlmsghdr *nlh;
217 struct ndmsg *ndm;
218
219 if (dump->idx < dump->cb->args[2])
220 goto skip;
221
222 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
223 sizeof(*ndm), NLM_F_MULTI);
224 if (!nlh)
225 return -EMSGSIZE;
226
227 ndm = nlmsg_data(nlh);
228 ndm->ndm_family = AF_BRIDGE;
229 ndm->ndm_pad1 = 0;
230 ndm->ndm_pad2 = 0;
231 ndm->ndm_flags = NTF_SELF;
232 ndm->ndm_type = 0;
233 ndm->ndm_ifindex = dump->dev->ifindex;
234 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE;
235
236 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))
237 goto nla_put_failure;
238
239 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))
240 goto nla_put_failure;
241
242 nlmsg_end(dump->skb, nlh);
243
244 skip:
245 dump->idx++;
246 return 0;
247
248 nla_put_failure:
249 nlmsg_cancel(dump->skb, nlh);
250 return -EMSGSIZE;
251 }
252
253 static int
254 dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
255 struct net_device *dev, struct net_device *filter_dev,
256 int *idx)
257 {
258 struct dsa_slave_dump_ctx dump = {
259 .dev = dev,
260 .skb = skb,
261 .cb = cb,
262 .idx = *idx,
263 };
264 struct dsa_slave_priv *p = netdev_priv(dev);
265 struct dsa_port *dp = p->dp;
266 struct dsa_switch *ds = dp->ds;
267 int err;
268
269 if (!ds->ops->port_fdb_dump)
270 return -EOPNOTSUPP;
271
272 err = ds->ops->port_fdb_dump(ds, dp->index,
273 dsa_slave_port_fdb_do_dump,
274 &dump);
275 *idx = dump.idx;
276 return err;
277 }
278
279 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
280 {
281 struct dsa_slave_priv *p = netdev_priv(dev);
282
283 if (p->phy != NULL)
284 return phy_mii_ioctl(p->phy, ifr, cmd);
285
286 return -EOPNOTSUPP;
287 }
288
289 static int dsa_slave_port_attr_set(struct net_device *dev,
290 const struct switchdev_attr *attr,
291 struct switchdev_trans *trans)
292 {
293 struct dsa_slave_priv *p = netdev_priv(dev);
294 struct dsa_port *dp = p->dp;
295 int ret;
296
297 switch (attr->id) {
298 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
299 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
300 break;
301 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
302 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
303 trans);
304 break;
305 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
306 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans);
307 break;
308 default:
309 ret = -EOPNOTSUPP;
310 break;
311 }
312
313 return ret;
314 }
315
316 static int dsa_slave_port_obj_add(struct net_device *dev,
317 const struct switchdev_obj *obj,
318 struct switchdev_trans *trans)
319 {
320 struct dsa_slave_priv *p = netdev_priv(dev);
321 struct dsa_port *dp = p->dp;
322 int err;
323
324 /* For the prepare phase, ensure the full set of changes is feasable in
325 * one go in order to signal a failure properly. If an operation is not
326 * supported, return -EOPNOTSUPP.
327 */
328
329 switch (obj->id) {
330 case SWITCHDEV_OBJ_ID_PORT_MDB:
331 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans);
332 break;
333 case SWITCHDEV_OBJ_ID_PORT_VLAN:
334 err = dsa_port_vlan_add(dp, SWITCHDEV_OBJ_PORT_VLAN(obj),
335 trans);
336 break;
337 default:
338 err = -EOPNOTSUPP;
339 break;
340 }
341
342 return err;
343 }
344
345 static int dsa_slave_port_obj_del(struct net_device *dev,
346 const struct switchdev_obj *obj)
347 {
348 struct dsa_slave_priv *p = netdev_priv(dev);
349 struct dsa_port *dp = p->dp;
350 int err;
351
352 switch (obj->id) {
353 case SWITCHDEV_OBJ_ID_PORT_MDB:
354 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
355 break;
356 case SWITCHDEV_OBJ_ID_PORT_VLAN:
357 err = dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));
358 break;
359 default:
360 err = -EOPNOTSUPP;
361 break;
362 }
363
364 return err;
365 }
366
367 static int dsa_slave_port_attr_get(struct net_device *dev,
368 struct switchdev_attr *attr)
369 {
370 struct dsa_slave_priv *p = netdev_priv(dev);
371 struct dsa_switch *ds = p->dp->ds;
372
373 switch (attr->id) {
374 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
375 attr->u.ppid.id_len = sizeof(ds->index);
376 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
377 break;
378 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
379 attr->u.brport_flags_support = 0;
380 break;
381 default:
382 return -EOPNOTSUPP;
383 }
384
385 return 0;
386 }
387
388 static inline netdev_tx_t dsa_netpoll_send_skb(struct dsa_slave_priv *p,
389 struct sk_buff *skb)
390 {
391 #ifdef CONFIG_NET_POLL_CONTROLLER
392 if (p->netpoll)
393 netpoll_send_skb(p->netpoll, skb);
394 #else
395 BUG();
396 #endif
397 return NETDEV_TX_OK;
398 }
399
400 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
401 {
402 struct dsa_slave_priv *p = netdev_priv(dev);
403 struct pcpu_sw_netstats *s;
404 struct sk_buff *nskb;
405
406 s = this_cpu_ptr(p->stats64);
407 u64_stats_update_begin(&s->syncp);
408 s->tx_packets++;
409 s->tx_bytes += skb->len;
410 u64_stats_update_end(&s->syncp);
411
412 /* Transmit function may have to reallocate the original SKB,
413 * in which case it must have freed it. Only free it here on error.
414 */
415 nskb = p->xmit(skb, dev);
416 if (!nskb) {
417 kfree_skb(skb);
418 return NETDEV_TX_OK;
419 }
420
421 /* SKB for netpoll still need to be mangled with the protocol-specific
422 * tag to be successfully transmitted
423 */
424 if (unlikely(netpoll_tx_running(dev)))
425 return dsa_netpoll_send_skb(p, nskb);
426
427 /* Queue the SKB for transmission on the parent interface, but
428 * do not modify its EtherType
429 */
430 nskb->dev = dsa_master_netdev(p);
431 dev_queue_xmit(nskb);
432
433 return NETDEV_TX_OK;
434 }
435
436 /* ethtool operations *******************************************************/
437 static int
438 dsa_slave_get_link_ksettings(struct net_device *dev,
439 struct ethtool_link_ksettings *cmd)
440 {
441 struct dsa_slave_priv *p = netdev_priv(dev);
442
443 if (!p->phy)
444 return -EOPNOTSUPP;
445
446 phy_ethtool_ksettings_get(p->phy, cmd);
447
448 return 0;
449 }
450
451 static int
452 dsa_slave_set_link_ksettings(struct net_device *dev,
453 const struct ethtool_link_ksettings *cmd)
454 {
455 struct dsa_slave_priv *p = netdev_priv(dev);
456
457 if (p->phy != NULL)
458 return phy_ethtool_ksettings_set(p->phy, cmd);
459
460 return -EOPNOTSUPP;
461 }
462
463 static void dsa_slave_get_drvinfo(struct net_device *dev,
464 struct ethtool_drvinfo *drvinfo)
465 {
466 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
467 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
468 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
469 }
470
471 static int dsa_slave_get_regs_len(struct net_device *dev)
472 {
473 struct dsa_slave_priv *p = netdev_priv(dev);
474 struct dsa_switch *ds = p->dp->ds;
475
476 if (ds->ops->get_regs_len)
477 return ds->ops->get_regs_len(ds, p->dp->index);
478
479 return -EOPNOTSUPP;
480 }
481
482 static void
483 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
484 {
485 struct dsa_slave_priv *p = netdev_priv(dev);
486 struct dsa_switch *ds = p->dp->ds;
487
488 if (ds->ops->get_regs)
489 ds->ops->get_regs(ds, p->dp->index, regs, _p);
490 }
491
492 static int dsa_slave_nway_reset(struct net_device *dev)
493 {
494 struct dsa_slave_priv *p = netdev_priv(dev);
495
496 if (p->phy != NULL)
497 return genphy_restart_aneg(p->phy);
498
499 return -EOPNOTSUPP;
500 }
501
502 static u32 dsa_slave_get_link(struct net_device *dev)
503 {
504 struct dsa_slave_priv *p = netdev_priv(dev);
505
506 if (p->phy != NULL) {
507 genphy_update_link(p->phy);
508 return p->phy->link;
509 }
510
511 return -EOPNOTSUPP;
512 }
513
514 static int dsa_slave_get_eeprom_len(struct net_device *dev)
515 {
516 struct dsa_slave_priv *p = netdev_priv(dev);
517 struct dsa_switch *ds = p->dp->ds;
518
519 if (ds->cd && ds->cd->eeprom_len)
520 return ds->cd->eeprom_len;
521
522 if (ds->ops->get_eeprom_len)
523 return ds->ops->get_eeprom_len(ds);
524
525 return 0;
526 }
527
528 static int dsa_slave_get_eeprom(struct net_device *dev,
529 struct ethtool_eeprom *eeprom, u8 *data)
530 {
531 struct dsa_slave_priv *p = netdev_priv(dev);
532 struct dsa_switch *ds = p->dp->ds;
533
534 if (ds->ops->get_eeprom)
535 return ds->ops->get_eeprom(ds, eeprom, data);
536
537 return -EOPNOTSUPP;
538 }
539
540 static int dsa_slave_set_eeprom(struct net_device *dev,
541 struct ethtool_eeprom *eeprom, u8 *data)
542 {
543 struct dsa_slave_priv *p = netdev_priv(dev);
544 struct dsa_switch *ds = p->dp->ds;
545
546 if (ds->ops->set_eeprom)
547 return ds->ops->set_eeprom(ds, eeprom, data);
548
549 return -EOPNOTSUPP;
550 }
551
552 static void dsa_slave_get_strings(struct net_device *dev,
553 uint32_t stringset, uint8_t *data)
554 {
555 struct dsa_slave_priv *p = netdev_priv(dev);
556 struct dsa_switch *ds = p->dp->ds;
557
558 if (stringset == ETH_SS_STATS) {
559 int len = ETH_GSTRING_LEN;
560
561 strncpy(data, "tx_packets", len);
562 strncpy(data + len, "tx_bytes", len);
563 strncpy(data + 2 * len, "rx_packets", len);
564 strncpy(data + 3 * len, "rx_bytes", len);
565 if (ds->ops->get_strings)
566 ds->ops->get_strings(ds, p->dp->index, data + 4 * len);
567 }
568 }
569
570 static void dsa_cpu_port_get_ethtool_stats(struct net_device *dev,
571 struct ethtool_stats *stats,
572 uint64_t *data)
573 {
574 struct dsa_switch_tree *dst = dev->dsa_ptr;
575 struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
576 struct dsa_switch *ds = cpu_dp->ds;
577 s8 cpu_port = cpu_dp->index;
578 int count = 0;
579
580 if (cpu_dp->ethtool_ops.get_sset_count) {
581 count = cpu_dp->ethtool_ops.get_sset_count(dev, ETH_SS_STATS);
582 cpu_dp->ethtool_ops.get_ethtool_stats(dev, stats, data);
583 }
584
585 if (ds->ops->get_ethtool_stats)
586 ds->ops->get_ethtool_stats(ds, cpu_port, data + count);
587 }
588
589 static int dsa_cpu_port_get_sset_count(struct net_device *dev, int sset)
590 {
591 struct dsa_switch_tree *dst = dev->dsa_ptr;
592 struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
593 struct dsa_switch *ds = cpu_dp->ds;
594 int count = 0;
595
596 if (cpu_dp->ethtool_ops.get_sset_count)
597 count += cpu_dp->ethtool_ops.get_sset_count(dev, sset);
598
599 if (sset == ETH_SS_STATS && ds->ops->get_sset_count)
600 count += ds->ops->get_sset_count(ds);
601
602 return count;
603 }
604
605 static void dsa_cpu_port_get_strings(struct net_device *dev,
606 uint32_t stringset, uint8_t *data)
607 {
608 struct dsa_switch_tree *dst = dev->dsa_ptr;
609 struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
610 struct dsa_switch *ds = cpu_dp->ds;
611 s8 cpu_port = cpu_dp->index;
612 int len = ETH_GSTRING_LEN;
613 int mcount = 0, count;
614 unsigned int i;
615 uint8_t pfx[4];
616 uint8_t *ndata;
617
618 snprintf(pfx, sizeof(pfx), "p%.2d", cpu_port);
619 /* We do not want to be NULL-terminated, since this is a prefix */
620 pfx[sizeof(pfx) - 1] = '_';
621
622 if (cpu_dp->ethtool_ops.get_sset_count) {
623 mcount = cpu_dp->ethtool_ops.get_sset_count(dev, ETH_SS_STATS);
624 cpu_dp->ethtool_ops.get_strings(dev, stringset, data);
625 }
626
627 if (stringset == ETH_SS_STATS && ds->ops->get_strings) {
628 ndata = data + mcount * len;
629 /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
630 * the output after to prepend our CPU port prefix we
631 * constructed earlier
632 */
633 ds->ops->get_strings(ds, cpu_port, ndata);
634 count = ds->ops->get_sset_count(ds);
635 for (i = 0; i < count; i++) {
636 memmove(ndata + (i * len + sizeof(pfx)),
637 ndata + i * len, len - sizeof(pfx));
638 memcpy(ndata + i * len, pfx, sizeof(pfx));
639 }
640 }
641 }
642
643 static void dsa_slave_get_ethtool_stats(struct net_device *dev,
644 struct ethtool_stats *stats,
645 uint64_t *data)
646 {
647 struct dsa_slave_priv *p = netdev_priv(dev);
648 struct dsa_switch *ds = p->dp->ds;
649 struct pcpu_sw_netstats *s;
650 unsigned int start;
651 int i;
652
653 for_each_possible_cpu(i) {
654 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
655
656 s = per_cpu_ptr(p->stats64, i);
657 do {
658 start = u64_stats_fetch_begin_irq(&s->syncp);
659 tx_packets = s->tx_packets;
660 tx_bytes = s->tx_bytes;
661 rx_packets = s->rx_packets;
662 rx_bytes = s->rx_bytes;
663 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
664 data[0] += tx_packets;
665 data[1] += tx_bytes;
666 data[2] += rx_packets;
667 data[3] += rx_bytes;
668 }
669 if (ds->ops->get_ethtool_stats)
670 ds->ops->get_ethtool_stats(ds, p->dp->index, data + 4);
671 }
672
673 static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
674 {
675 struct dsa_slave_priv *p = netdev_priv(dev);
676 struct dsa_switch *ds = p->dp->ds;
677
678 if (sset == ETH_SS_STATS) {
679 int count;
680
681 count = 4;
682 if (ds->ops->get_sset_count)
683 count += ds->ops->get_sset_count(ds);
684
685 return count;
686 }
687
688 return -EOPNOTSUPP;
689 }
690
691 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
692 {
693 struct dsa_slave_priv *p = netdev_priv(dev);
694 struct dsa_switch *ds = p->dp->ds;
695
696 if (ds->ops->get_wol)
697 ds->ops->get_wol(ds, p->dp->index, w);
698 }
699
700 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
701 {
702 struct dsa_slave_priv *p = netdev_priv(dev);
703 struct dsa_switch *ds = p->dp->ds;
704 int ret = -EOPNOTSUPP;
705
706 if (ds->ops->set_wol)
707 ret = ds->ops->set_wol(ds, p->dp->index, w);
708
709 return ret;
710 }
711
712 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
713 {
714 struct dsa_slave_priv *p = netdev_priv(dev);
715 struct dsa_switch *ds = p->dp->ds;
716 int ret;
717
718 /* Port's PHY and MAC both need to be EEE capable */
719 if (!p->phy)
720 return -ENODEV;
721
722 if (!ds->ops->set_mac_eee)
723 return -EOPNOTSUPP;
724
725 ret = ds->ops->set_mac_eee(ds, p->dp->index, e);
726 if (ret)
727 return ret;
728
729 if (e->eee_enabled) {
730 ret = phy_init_eee(p->phy, 0);
731 if (ret)
732 return ret;
733 }
734
735 return phy_ethtool_set_eee(p->phy, e);
736 }
737
738 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
739 {
740 struct dsa_slave_priv *p = netdev_priv(dev);
741 struct dsa_switch *ds = p->dp->ds;
742 int ret;
743
744 /* Port's PHY and MAC both need to be EEE capable */
745 if (!p->phy)
746 return -ENODEV;
747
748 if (!ds->ops->get_mac_eee)
749 return -EOPNOTSUPP;
750
751 ret = ds->ops->get_mac_eee(ds, p->dp->index, e);
752 if (ret)
753 return ret;
754
755 return phy_ethtool_get_eee(p->phy, e);
756 }
757
758 #ifdef CONFIG_NET_POLL_CONTROLLER
759 static int dsa_slave_netpoll_setup(struct net_device *dev,
760 struct netpoll_info *ni)
761 {
762 struct dsa_slave_priv *p = netdev_priv(dev);
763 struct net_device *master = dsa_master_netdev(p);
764 struct netpoll *netpoll;
765 int err = 0;
766
767 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
768 if (!netpoll)
769 return -ENOMEM;
770
771 err = __netpoll_setup(netpoll, master);
772 if (err) {
773 kfree(netpoll);
774 goto out;
775 }
776
777 p->netpoll = netpoll;
778 out:
779 return err;
780 }
781
782 static void dsa_slave_netpoll_cleanup(struct net_device *dev)
783 {
784 struct dsa_slave_priv *p = netdev_priv(dev);
785 struct netpoll *netpoll = p->netpoll;
786
787 if (!netpoll)
788 return;
789
790 p->netpoll = NULL;
791
792 __netpoll_free_async(netpoll);
793 }
794
795 static void dsa_slave_poll_controller(struct net_device *dev)
796 {
797 }
798 #endif
799
800 static int dsa_slave_get_phys_port_name(struct net_device *dev,
801 char *name, size_t len)
802 {
803 struct dsa_slave_priv *p = netdev_priv(dev);
804
805 if (snprintf(name, len, "p%d", p->dp->index) >= len)
806 return -EINVAL;
807
808 return 0;
809 }
810
811 static struct dsa_mall_tc_entry *
812 dsa_slave_mall_tc_entry_find(struct dsa_slave_priv *p,
813 unsigned long cookie)
814 {
815 struct dsa_mall_tc_entry *mall_tc_entry;
816
817 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
818 if (mall_tc_entry->cookie == cookie)
819 return mall_tc_entry;
820
821 return NULL;
822 }
823
824 static int dsa_slave_add_cls_matchall(struct net_device *dev,
825 struct tc_cls_matchall_offload *cls,
826 bool ingress)
827 {
828 struct dsa_slave_priv *p = netdev_priv(dev);
829 struct dsa_mall_tc_entry *mall_tc_entry;
830 __be16 protocol = cls->common.protocol;
831 struct dsa_switch *ds = p->dp->ds;
832 struct net *net = dev_net(dev);
833 struct dsa_slave_priv *to_p;
834 struct net_device *to_dev;
835 const struct tc_action *a;
836 int err = -EOPNOTSUPP;
837 LIST_HEAD(actions);
838 int ifindex;
839
840 if (!ds->ops->port_mirror_add)
841 return err;
842
843 if (!tcf_exts_has_one_action(cls->exts))
844 return err;
845
846 tcf_exts_to_list(cls->exts, &actions);
847 a = list_first_entry(&actions, struct tc_action, list);
848
849 if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) {
850 struct dsa_mall_mirror_tc_entry *mirror;
851
852 ifindex = tcf_mirred_ifindex(a);
853 to_dev = __dev_get_by_index(net, ifindex);
854 if (!to_dev)
855 return -EINVAL;
856
857 if (!dsa_slave_dev_check(to_dev))
858 return -EOPNOTSUPP;
859
860 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
861 if (!mall_tc_entry)
862 return -ENOMEM;
863
864 mall_tc_entry->cookie = cls->cookie;
865 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
866 mirror = &mall_tc_entry->mirror;
867
868 to_p = netdev_priv(to_dev);
869
870 mirror->to_local_port = to_p->dp->index;
871 mirror->ingress = ingress;
872
873 err = ds->ops->port_mirror_add(ds, p->dp->index, mirror,
874 ingress);
875 if (err) {
876 kfree(mall_tc_entry);
877 return err;
878 }
879
880 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
881 }
882
883 return 0;
884 }
885
886 static void dsa_slave_del_cls_matchall(struct net_device *dev,
887 struct tc_cls_matchall_offload *cls)
888 {
889 struct dsa_slave_priv *p = netdev_priv(dev);
890 struct dsa_mall_tc_entry *mall_tc_entry;
891 struct dsa_switch *ds = p->dp->ds;
892
893 if (!ds->ops->port_mirror_del)
894 return;
895
896 mall_tc_entry = dsa_slave_mall_tc_entry_find(p, cls->cookie);
897 if (!mall_tc_entry)
898 return;
899
900 list_del(&mall_tc_entry->list);
901
902 switch (mall_tc_entry->type) {
903 case DSA_PORT_MALL_MIRROR:
904 ds->ops->port_mirror_del(ds, p->dp->index,
905 &mall_tc_entry->mirror);
906 break;
907 default:
908 WARN_ON(1);
909 }
910
911 kfree(mall_tc_entry);
912 }
913
914 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
915 struct tc_cls_matchall_offload *cls)
916 {
917 bool ingress;
918
919 if (is_classid_clsact_ingress(cls->common.classid))
920 ingress = true;
921 else if (is_classid_clsact_egress(cls->common.classid))
922 ingress = false;
923 else
924 return -EOPNOTSUPP;
925
926 if (cls->common.chain_index)
927 return -EOPNOTSUPP;
928
929 switch (cls->command) {
930 case TC_CLSMATCHALL_REPLACE:
931 return dsa_slave_add_cls_matchall(dev, cls, ingress);
932 case TC_CLSMATCHALL_DESTROY:
933 dsa_slave_del_cls_matchall(dev, cls);
934 return 0;
935 default:
936 return -EOPNOTSUPP;
937 }
938 }
939
940 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
941 void *type_data)
942 {
943 switch (type) {
944 case TC_SETUP_CLSMATCHALL:
945 return dsa_slave_setup_tc_cls_matchall(dev, type_data);
946 default:
947 return -EOPNOTSUPP;
948 }
949 }
950
951 static void dsa_slave_get_stats64(struct net_device *dev,
952 struct rtnl_link_stats64 *stats)
953 {
954 struct dsa_slave_priv *p = netdev_priv(dev);
955 struct pcpu_sw_netstats *s;
956 unsigned int start;
957 int i;
958
959 netdev_stats_to_stats64(stats, &dev->stats);
960 for_each_possible_cpu(i) {
961 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
962
963 s = per_cpu_ptr(p->stats64, i);
964 do {
965 start = u64_stats_fetch_begin_irq(&s->syncp);
966 tx_packets = s->tx_packets;
967 tx_bytes = s->tx_bytes;
968 rx_packets = s->rx_packets;
969 rx_bytes = s->rx_bytes;
970 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
971
972 stats->tx_packets += tx_packets;
973 stats->tx_bytes += tx_bytes;
974 stats->rx_packets += rx_packets;
975 stats->rx_bytes += rx_bytes;
976 }
977 }
978
979 void dsa_cpu_port_ethtool_init(struct ethtool_ops *ops)
980 {
981 ops->get_sset_count = dsa_cpu_port_get_sset_count;
982 ops->get_ethtool_stats = dsa_cpu_port_get_ethtool_stats;
983 ops->get_strings = dsa_cpu_port_get_strings;
984 }
985
986 static int dsa_slave_get_rxnfc(struct net_device *dev,
987 struct ethtool_rxnfc *nfc, u32 *rule_locs)
988 {
989 struct dsa_slave_priv *p = netdev_priv(dev);
990 struct dsa_switch *ds = p->dp->ds;
991
992 if (!ds->ops->get_rxnfc)
993 return -EOPNOTSUPP;
994
995 return ds->ops->get_rxnfc(ds, p->dp->index, nfc, rule_locs);
996 }
997
998 static int dsa_slave_set_rxnfc(struct net_device *dev,
999 struct ethtool_rxnfc *nfc)
1000 {
1001 struct dsa_slave_priv *p = netdev_priv(dev);
1002 struct dsa_switch *ds = p->dp->ds;
1003
1004 if (!ds->ops->set_rxnfc)
1005 return -EOPNOTSUPP;
1006
1007 return ds->ops->set_rxnfc(ds, p->dp->index, nfc);
1008 }
1009
1010 static const struct ethtool_ops dsa_slave_ethtool_ops = {
1011 .get_drvinfo = dsa_slave_get_drvinfo,
1012 .get_regs_len = dsa_slave_get_regs_len,
1013 .get_regs = dsa_slave_get_regs,
1014 .nway_reset = dsa_slave_nway_reset,
1015 .get_link = dsa_slave_get_link,
1016 .get_eeprom_len = dsa_slave_get_eeprom_len,
1017 .get_eeprom = dsa_slave_get_eeprom,
1018 .set_eeprom = dsa_slave_set_eeprom,
1019 .get_strings = dsa_slave_get_strings,
1020 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
1021 .get_sset_count = dsa_slave_get_sset_count,
1022 .set_wol = dsa_slave_set_wol,
1023 .get_wol = dsa_slave_get_wol,
1024 .set_eee = dsa_slave_set_eee,
1025 .get_eee = dsa_slave_get_eee,
1026 .get_link_ksettings = dsa_slave_get_link_ksettings,
1027 .set_link_ksettings = dsa_slave_set_link_ksettings,
1028 .get_rxnfc = dsa_slave_get_rxnfc,
1029 .set_rxnfc = dsa_slave_set_rxnfc,
1030 };
1031
1032 static const struct net_device_ops dsa_slave_netdev_ops = {
1033 .ndo_open = dsa_slave_open,
1034 .ndo_stop = dsa_slave_close,
1035 .ndo_start_xmit = dsa_slave_xmit,
1036 .ndo_change_rx_flags = dsa_slave_change_rx_flags,
1037 .ndo_set_rx_mode = dsa_slave_set_rx_mode,
1038 .ndo_set_mac_address = dsa_slave_set_mac_address,
1039 .ndo_fdb_add = dsa_legacy_fdb_add,
1040 .ndo_fdb_del = dsa_legacy_fdb_del,
1041 .ndo_fdb_dump = dsa_slave_fdb_dump,
1042 .ndo_do_ioctl = dsa_slave_ioctl,
1043 .ndo_get_iflink = dsa_slave_get_iflink,
1044 #ifdef CONFIG_NET_POLL_CONTROLLER
1045 .ndo_netpoll_setup = dsa_slave_netpoll_setup,
1046 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup,
1047 .ndo_poll_controller = dsa_slave_poll_controller,
1048 #endif
1049 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
1050 .ndo_setup_tc = dsa_slave_setup_tc,
1051 .ndo_get_stats64 = dsa_slave_get_stats64,
1052 };
1053
1054 static const struct switchdev_ops dsa_slave_switchdev_ops = {
1055 .switchdev_port_attr_get = dsa_slave_port_attr_get,
1056 .switchdev_port_attr_set = dsa_slave_port_attr_set,
1057 .switchdev_port_obj_add = dsa_slave_port_obj_add,
1058 .switchdev_port_obj_del = dsa_slave_port_obj_del,
1059 };
1060
1061 static struct device_type dsa_type = {
1062 .name = "dsa",
1063 };
1064
1065 static void dsa_slave_adjust_link(struct net_device *dev)
1066 {
1067 struct dsa_slave_priv *p = netdev_priv(dev);
1068 struct dsa_switch *ds = p->dp->ds;
1069 unsigned int status_changed = 0;
1070
1071 if (p->old_link != p->phy->link) {
1072 status_changed = 1;
1073 p->old_link = p->phy->link;
1074 }
1075
1076 if (p->old_duplex != p->phy->duplex) {
1077 status_changed = 1;
1078 p->old_duplex = p->phy->duplex;
1079 }
1080
1081 if (p->old_pause != p->phy->pause) {
1082 status_changed = 1;
1083 p->old_pause = p->phy->pause;
1084 }
1085
1086 if (ds->ops->adjust_link && status_changed)
1087 ds->ops->adjust_link(ds, p->dp->index, p->phy);
1088
1089 if (status_changed)
1090 phy_print_status(p->phy);
1091 }
1092
1093 static int dsa_slave_fixed_link_update(struct net_device *dev,
1094 struct fixed_phy_status *status)
1095 {
1096 struct dsa_slave_priv *p;
1097 struct dsa_switch *ds;
1098
1099 if (dev) {
1100 p = netdev_priv(dev);
1101 ds = p->dp->ds;
1102 if (ds->ops->fixed_link_update)
1103 ds->ops->fixed_link_update(ds, p->dp->index, status);
1104 }
1105
1106 return 0;
1107 }
1108
1109 /* slave device setup *******************************************************/
1110 static int dsa_slave_phy_connect(struct dsa_slave_priv *p,
1111 struct net_device *slave_dev,
1112 int addr)
1113 {
1114 struct dsa_switch *ds = p->dp->ds;
1115
1116 p->phy = mdiobus_get_phy(ds->slave_mii_bus, addr);
1117 if (!p->phy) {
1118 netdev_err(slave_dev, "no phy at %d\n", addr);
1119 return -ENODEV;
1120 }
1121
1122 /* Use already configured phy mode */
1123 if (p->phy_interface == PHY_INTERFACE_MODE_NA)
1124 p->phy_interface = p->phy->interface;
1125 return phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
1126 p->phy_interface);
1127 }
1128
1129 static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
1130 struct net_device *slave_dev)
1131 {
1132 struct dsa_switch *ds = p->dp->ds;
1133 struct device_node *phy_dn, *port_dn;
1134 bool phy_is_fixed = false;
1135 u32 phy_flags = 0;
1136 int mode, ret;
1137
1138 port_dn = p->dp->dn;
1139 mode = of_get_phy_mode(port_dn);
1140 if (mode < 0)
1141 mode = PHY_INTERFACE_MODE_NA;
1142 p->phy_interface = mode;
1143
1144 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
1145 if (!phy_dn && of_phy_is_fixed_link(port_dn)) {
1146 /* In the case of a fixed PHY, the DT node associated
1147 * to the fixed PHY is the Port DT node
1148 */
1149 ret = of_phy_register_fixed_link(port_dn);
1150 if (ret) {
1151 netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
1152 return ret;
1153 }
1154 phy_is_fixed = true;
1155 phy_dn = of_node_get(port_dn);
1156 }
1157
1158 if (ds->ops->get_phy_flags)
1159 phy_flags = ds->ops->get_phy_flags(ds, p->dp->index);
1160
1161 if (phy_dn) {
1162 int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn);
1163
1164 /* If this PHY address is part of phys_mii_mask, which means
1165 * that we need to divert reads and writes to/from it, then we
1166 * want to bind this device using the slave MII bus created by
1167 * DSA to make that happen.
1168 */
1169 if (!phy_is_fixed && phy_id >= 0 &&
1170 (ds->phys_mii_mask & (1 << phy_id))) {
1171 ret = dsa_slave_phy_connect(p, slave_dev, phy_id);
1172 if (ret) {
1173 netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret);
1174 of_node_put(phy_dn);
1175 return ret;
1176 }
1177 } else {
1178 p->phy = of_phy_connect(slave_dev, phy_dn,
1179 dsa_slave_adjust_link,
1180 phy_flags,
1181 p->phy_interface);
1182 }
1183
1184 of_node_put(phy_dn);
1185 }
1186
1187 if (p->phy && phy_is_fixed)
1188 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);
1189
1190 /* We could not connect to a designated PHY, so use the switch internal
1191 * MDIO bus instead
1192 */
1193 if (!p->phy) {
1194 ret = dsa_slave_phy_connect(p, slave_dev, p->dp->index);
1195 if (ret) {
1196 netdev_err(slave_dev, "failed to connect to port %d: %d\n",
1197 p->dp->index, ret);
1198 if (phy_is_fixed)
1199 of_phy_deregister_fixed_link(port_dn);
1200 return ret;
1201 }
1202 }
1203
1204 phy_attached_info(p->phy);
1205
1206 return 0;
1207 }
1208
1209 static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
1210 static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
1211 struct netdev_queue *txq,
1212 void *_unused)
1213 {
1214 lockdep_set_class(&txq->_xmit_lock,
1215 &dsa_slave_netdev_xmit_lock_key);
1216 }
1217
1218 int dsa_slave_suspend(struct net_device *slave_dev)
1219 {
1220 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1221
1222 netif_device_detach(slave_dev);
1223
1224 if (p->phy) {
1225 phy_stop(p->phy);
1226 p->old_pause = -1;
1227 p->old_link = -1;
1228 p->old_duplex = -1;
1229 phy_suspend(p->phy);
1230 }
1231
1232 return 0;
1233 }
1234
1235 int dsa_slave_resume(struct net_device *slave_dev)
1236 {
1237 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1238
1239 netif_device_attach(slave_dev);
1240
1241 if (p->phy) {
1242 phy_resume(p->phy);
1243 phy_start(p->phy);
1244 }
1245
1246 return 0;
1247 }
1248
1249 int dsa_slave_create(struct dsa_port *port, const char *name)
1250 {
1251 struct dsa_switch *ds = port->ds;
1252 struct dsa_switch_tree *dst = ds->dst;
1253 struct net_device *master;
1254 struct net_device *slave_dev;
1255 struct dsa_slave_priv *p;
1256 struct dsa_port *cpu_dp;
1257 int ret;
1258
1259 cpu_dp = ds->dst->cpu_dp;
1260 master = cpu_dp->netdev;
1261
1262 if (!ds->num_tx_queues)
1263 ds->num_tx_queues = 1;
1264
1265 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1266 NET_NAME_UNKNOWN, ether_setup,
1267 ds->num_tx_queues, 1);
1268 if (slave_dev == NULL)
1269 return -ENOMEM;
1270
1271 slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
1272 slave_dev->hw_features |= NETIF_F_HW_TC;
1273 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1274 eth_hw_addr_inherit(slave_dev, master);
1275 slave_dev->priv_flags |= IFF_NO_QUEUE;
1276 slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1277 slave_dev->switchdev_ops = &dsa_slave_switchdev_ops;
1278 slave_dev->min_mtu = 0;
1279 slave_dev->max_mtu = ETH_MAX_MTU;
1280 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1281
1282 netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one,
1283 NULL);
1284
1285 SET_NETDEV_DEV(slave_dev, port->ds->dev);
1286 slave_dev->dev.of_node = port->dn;
1287 slave_dev->vlan_features = master->vlan_features;
1288
1289 p = netdev_priv(slave_dev);
1290 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1291 if (!p->stats64) {
1292 free_netdev(slave_dev);
1293 return -ENOMEM;
1294 }
1295 p->dp = port;
1296 INIT_LIST_HEAD(&p->mall_tc_list);
1297 p->xmit = dst->tag_ops->xmit;
1298
1299 p->old_pause = -1;
1300 p->old_link = -1;
1301 p->old_duplex = -1;
1302
1303 port->netdev = slave_dev;
1304
1305 netif_carrier_off(slave_dev);
1306
1307 ret = dsa_slave_phy_setup(p, slave_dev);
1308 if (ret) {
1309 netdev_err(master, "error %d setting up slave phy\n", ret);
1310 goto out_free;
1311 }
1312
1313 ret = register_netdev(slave_dev);
1314 if (ret) {
1315 netdev_err(master, "error %d registering interface %s\n",
1316 ret, slave_dev->name);
1317 goto out_phy;
1318 }
1319
1320 return 0;
1321
1322 out_phy:
1323 phy_disconnect(p->phy);
1324 if (of_phy_is_fixed_link(p->dp->dn))
1325 of_phy_deregister_fixed_link(p->dp->dn);
1326 out_free:
1327 free_percpu(p->stats64);
1328 free_netdev(slave_dev);
1329 port->netdev = NULL;
1330 return ret;
1331 }
1332
1333 void dsa_slave_destroy(struct net_device *slave_dev)
1334 {
1335 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1336 struct device_node *port_dn;
1337
1338 port_dn = p->dp->dn;
1339
1340 netif_carrier_off(slave_dev);
1341 if (p->phy) {
1342 phy_disconnect(p->phy);
1343
1344 if (of_phy_is_fixed_link(port_dn))
1345 of_phy_deregister_fixed_link(port_dn);
1346 }
1347 unregister_netdev(slave_dev);
1348 free_percpu(p->stats64);
1349 free_netdev(slave_dev);
1350 }
1351
1352 static bool dsa_slave_dev_check(struct net_device *dev)
1353 {
1354 return dev->netdev_ops == &dsa_slave_netdev_ops;
1355 }
1356
1357 static int dsa_slave_changeupper(struct net_device *dev,
1358 struct netdev_notifier_changeupper_info *info)
1359 {
1360 struct dsa_slave_priv *p = netdev_priv(dev);
1361 struct dsa_port *dp = p->dp;
1362 int err = NOTIFY_DONE;
1363
1364 if (netif_is_bridge_master(info->upper_dev)) {
1365 if (info->linking) {
1366 err = dsa_port_bridge_join(dp, info->upper_dev);
1367 err = notifier_from_errno(err);
1368 } else {
1369 dsa_port_bridge_leave(dp, info->upper_dev);
1370 err = NOTIFY_OK;
1371 }
1372 }
1373
1374 return err;
1375 }
1376
1377 static int dsa_slave_netdevice_event(struct notifier_block *nb,
1378 unsigned long event, void *ptr)
1379 {
1380 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1381
1382 if (dev->netdev_ops != &dsa_slave_netdev_ops)
1383 return NOTIFY_DONE;
1384
1385 if (event == NETDEV_CHANGEUPPER)
1386 return dsa_slave_changeupper(dev, ptr);
1387
1388 return NOTIFY_DONE;
1389 }
1390
1391 struct dsa_switchdev_event_work {
1392 struct work_struct work;
1393 struct switchdev_notifier_fdb_info fdb_info;
1394 struct net_device *dev;
1395 unsigned long event;
1396 };
1397
1398 static void dsa_slave_switchdev_event_work(struct work_struct *work)
1399 {
1400 struct dsa_switchdev_event_work *switchdev_work =
1401 container_of(work, struct dsa_switchdev_event_work, work);
1402 struct net_device *dev = switchdev_work->dev;
1403 struct switchdev_notifier_fdb_info *fdb_info;
1404 struct dsa_slave_priv *p = netdev_priv(dev);
1405 int err;
1406
1407 rtnl_lock();
1408 switch (switchdev_work->event) {
1409 case SWITCHDEV_FDB_ADD_TO_DEVICE:
1410 fdb_info = &switchdev_work->fdb_info;
1411 err = dsa_port_fdb_add(p->dp, fdb_info->addr, fdb_info->vid);
1412 if (err) {
1413 netdev_dbg(dev, "fdb add failed err=%d\n", err);
1414 break;
1415 }
1416 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
1417 &fdb_info->info);
1418 break;
1419
1420 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1421 fdb_info = &switchdev_work->fdb_info;
1422 err = dsa_port_fdb_del(p->dp, fdb_info->addr, fdb_info->vid);
1423 if (err) {
1424 netdev_dbg(dev, "fdb del failed err=%d\n", err);
1425 dev_close(dev);
1426 }
1427 break;
1428 }
1429 rtnl_unlock();
1430
1431 kfree(switchdev_work->fdb_info.addr);
1432 kfree(switchdev_work);
1433 dev_put(dev);
1434 }
1435
1436 static int
1437 dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work *
1438 switchdev_work,
1439 const struct switchdev_notifier_fdb_info *
1440 fdb_info)
1441 {
1442 memcpy(&switchdev_work->fdb_info, fdb_info,
1443 sizeof(switchdev_work->fdb_info));
1444 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
1445 if (!switchdev_work->fdb_info.addr)
1446 return -ENOMEM;
1447 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
1448 fdb_info->addr);
1449 return 0;
1450 }
1451
1452 /* Called under rcu_read_lock() */
1453 static int dsa_slave_switchdev_event(struct notifier_block *unused,
1454 unsigned long event, void *ptr)
1455 {
1456 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1457 struct dsa_switchdev_event_work *switchdev_work;
1458
1459 if (!dsa_slave_dev_check(dev))
1460 return NOTIFY_DONE;
1461
1462 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
1463 if (!switchdev_work)
1464 return NOTIFY_BAD;
1465
1466 INIT_WORK(&switchdev_work->work,
1467 dsa_slave_switchdev_event_work);
1468 switchdev_work->dev = dev;
1469 switchdev_work->event = event;
1470
1471 switch (event) {
1472 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
1473 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1474 if (dsa_slave_switchdev_fdb_work_init(switchdev_work,
1475 ptr))
1476 goto err_fdb_work_init;
1477 dev_hold(dev);
1478 break;
1479 default:
1480 kfree(switchdev_work);
1481 return NOTIFY_DONE;
1482 }
1483
1484 dsa_schedule_work(&switchdev_work->work);
1485 return NOTIFY_OK;
1486
1487 err_fdb_work_init:
1488 kfree(switchdev_work);
1489 return NOTIFY_BAD;
1490 }
1491
1492 static struct notifier_block dsa_slave_nb __read_mostly = {
1493 .notifier_call = dsa_slave_netdevice_event,
1494 };
1495
1496 static struct notifier_block dsa_slave_switchdev_notifier = {
1497 .notifier_call = dsa_slave_switchdev_event,
1498 };
1499
1500 int dsa_slave_register_notifier(void)
1501 {
1502 int err;
1503
1504 err = register_netdevice_notifier(&dsa_slave_nb);
1505 if (err)
1506 return err;
1507
1508 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier);
1509 if (err)
1510 goto err_switchdev_nb;
1511
1512 return 0;
1513
1514 err_switchdev_nb:
1515 unregister_netdevice_notifier(&dsa_slave_nb);
1516 return err;
1517 }
1518
1519 void dsa_slave_unregister_notifier(void)
1520 {
1521 int err;
1522
1523 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
1524 if (err)
1525 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err);
1526
1527 err = unregister_netdevice_notifier(&dsa_slave_nb);
1528 if (err)
1529 pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
1530 }