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