1
2
3
4
5
6
7
8
9
10
11#include <linux/list.h>
12#include <linux/etherdevice.h>
13#include <linux/phy.h>
14#include <linux/phy_fixed.h>
15#include <linux/of_net.h>
16#include <linux/of_mdio.h>
17#include "dsa_priv.h"
18
19
20static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
21{
22 struct dsa_switch *ds = bus->priv;
23
24 if (ds->phys_mii_mask & (1 << addr))
25 return ds->drv->phy_read(ds, addr, reg);
26
27 return 0xffff;
28}
29
30static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
31{
32 struct dsa_switch *ds = bus->priv;
33
34 if (ds->phys_mii_mask & (1 << addr))
35 return ds->drv->phy_write(ds, addr, reg, val);
36
37 return 0;
38}
39
40void dsa_slave_mii_bus_init(struct dsa_switch *ds)
41{
42 ds->slave_mii_bus->priv = (void *)ds;
43 ds->slave_mii_bus->name = "dsa slave smi";
44 ds->slave_mii_bus->read = dsa_slave_phy_read;
45 ds->slave_mii_bus->write = dsa_slave_phy_write;
46 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d:%.2x",
47 ds->index, ds->pd->sw_addr);
48 ds->slave_mii_bus->parent = ds->master_dev;
49 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
50}
51
52
53
54static int dsa_slave_init(struct net_device *dev)
55{
56 struct dsa_slave_priv *p = netdev_priv(dev);
57
58 dev->iflink = p->parent->dst->master_netdev->ifindex;
59
60 return 0;
61}
62
63static int dsa_slave_open(struct net_device *dev)
64{
65 struct dsa_slave_priv *p = netdev_priv(dev);
66 struct net_device *master = p->parent->dst->master_netdev;
67 struct dsa_switch *ds = p->parent;
68 int err;
69
70 if (!(master->flags & IFF_UP))
71 return -ENETDOWN;
72
73 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
74 err = dev_uc_add(master, dev->dev_addr);
75 if (err < 0)
76 goto out;
77 }
78
79 if (dev->flags & IFF_ALLMULTI) {
80 err = dev_set_allmulti(master, 1);
81 if (err < 0)
82 goto del_unicast;
83 }
84 if (dev->flags & IFF_PROMISC) {
85 err = dev_set_promiscuity(master, 1);
86 if (err < 0)
87 goto clear_allmulti;
88 }
89
90 if (ds->drv->port_enable) {
91 err = ds->drv->port_enable(ds, p->port, p->phy);
92 if (err)
93 goto clear_promisc;
94 }
95
96 if (p->phy)
97 phy_start(p->phy);
98
99 return 0;
100
101clear_promisc:
102 if (dev->flags & IFF_PROMISC)
103 dev_set_promiscuity(master, 0);
104clear_allmulti:
105 if (dev->flags & IFF_ALLMULTI)
106 dev_set_allmulti(master, -1);
107del_unicast:
108 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
109 dev_uc_del(master, dev->dev_addr);
110out:
111 return err;
112}
113
114static int dsa_slave_close(struct net_device *dev)
115{
116 struct dsa_slave_priv *p = netdev_priv(dev);
117 struct net_device *master = p->parent->dst->master_netdev;
118 struct dsa_switch *ds = p->parent;
119
120 if (p->phy)
121 phy_stop(p->phy);
122
123 dev_mc_unsync(master, dev);
124 dev_uc_unsync(master, dev);
125 if (dev->flags & IFF_ALLMULTI)
126 dev_set_allmulti(master, -1);
127 if (dev->flags & IFF_PROMISC)
128 dev_set_promiscuity(master, -1);
129
130 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
131 dev_uc_del(master, dev->dev_addr);
132
133 if (ds->drv->port_disable)
134 ds->drv->port_disable(ds, p->port, p->phy);
135
136 return 0;
137}
138
139static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
140{
141 struct dsa_slave_priv *p = netdev_priv(dev);
142 struct net_device *master = p->parent->dst->master_netdev;
143
144 if (change & IFF_ALLMULTI)
145 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
146 if (change & IFF_PROMISC)
147 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
148}
149
150static void dsa_slave_set_rx_mode(struct net_device *dev)
151{
152 struct dsa_slave_priv *p = netdev_priv(dev);
153 struct net_device *master = p->parent->dst->master_netdev;
154
155 dev_mc_sync(master, dev);
156 dev_uc_sync(master, dev);
157}
158
159static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
160{
161 struct dsa_slave_priv *p = netdev_priv(dev);
162 struct net_device *master = p->parent->dst->master_netdev;
163 struct sockaddr *addr = a;
164 int err;
165
166 if (!is_valid_ether_addr(addr->sa_data))
167 return -EADDRNOTAVAIL;
168
169 if (!(dev->flags & IFF_UP))
170 goto out;
171
172 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
173 err = dev_uc_add(master, addr->sa_data);
174 if (err < 0)
175 return err;
176 }
177
178 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
179 dev_uc_del(master, dev->dev_addr);
180
181out:
182 ether_addr_copy(dev->dev_addr, addr->sa_data);
183
184 return 0;
185}
186
187static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
188{
189 struct dsa_slave_priv *p = netdev_priv(dev);
190
191 if (p->phy != NULL)
192 return phy_mii_ioctl(p->phy, ifr, cmd);
193
194 return -EOPNOTSUPP;
195}
196
197static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
198{
199 struct dsa_slave_priv *p = netdev_priv(dev);
200
201 return p->xmit(skb, dev);
202}
203
204static netdev_tx_t dsa_slave_notag_xmit(struct sk_buff *skb,
205 struct net_device *dev)
206{
207 struct dsa_slave_priv *p = netdev_priv(dev);
208
209 skb->dev = p->parent->dst->master_netdev;
210 dev_queue_xmit(skb);
211
212 return NETDEV_TX_OK;
213}
214
215
216
217static int
218dsa_slave_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
219{
220 struct dsa_slave_priv *p = netdev_priv(dev);
221 int err;
222
223 err = -EOPNOTSUPP;
224 if (p->phy != NULL) {
225 err = phy_read_status(p->phy);
226 if (err == 0)
227 err = phy_ethtool_gset(p->phy, cmd);
228 }
229
230 return err;
231}
232
233static int
234dsa_slave_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
235{
236 struct dsa_slave_priv *p = netdev_priv(dev);
237
238 if (p->phy != NULL)
239 return phy_ethtool_sset(p->phy, cmd);
240
241 return -EOPNOTSUPP;
242}
243
244static void dsa_slave_get_drvinfo(struct net_device *dev,
245 struct ethtool_drvinfo *drvinfo)
246{
247 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
248 strlcpy(drvinfo->version, dsa_driver_version, sizeof(drvinfo->version));
249 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
250 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
251}
252
253static int dsa_slave_get_regs_len(struct net_device *dev)
254{
255 struct dsa_slave_priv *p = netdev_priv(dev);
256 struct dsa_switch *ds = p->parent;
257
258 if (ds->drv->get_regs_len)
259 return ds->drv->get_regs_len(ds, p->port);
260
261 return -EOPNOTSUPP;
262}
263
264static void
265dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
266{
267 struct dsa_slave_priv *p = netdev_priv(dev);
268 struct dsa_switch *ds = p->parent;
269
270 if (ds->drv->get_regs)
271 ds->drv->get_regs(ds, p->port, regs, _p);
272}
273
274static int dsa_slave_nway_reset(struct net_device *dev)
275{
276 struct dsa_slave_priv *p = netdev_priv(dev);
277
278 if (p->phy != NULL)
279 return genphy_restart_aneg(p->phy);
280
281 return -EOPNOTSUPP;
282}
283
284static u32 dsa_slave_get_link(struct net_device *dev)
285{
286 struct dsa_slave_priv *p = netdev_priv(dev);
287
288 if (p->phy != NULL) {
289 genphy_update_link(p->phy);
290 return p->phy->link;
291 }
292
293 return -EOPNOTSUPP;
294}
295
296static int dsa_slave_get_eeprom_len(struct net_device *dev)
297{
298 struct dsa_slave_priv *p = netdev_priv(dev);
299 struct dsa_switch *ds = p->parent;
300
301 if (ds->pd->eeprom_len)
302 return ds->pd->eeprom_len;
303
304 if (ds->drv->get_eeprom_len)
305 return ds->drv->get_eeprom_len(ds);
306
307 return 0;
308}
309
310static int dsa_slave_get_eeprom(struct net_device *dev,
311 struct ethtool_eeprom *eeprom, u8 *data)
312{
313 struct dsa_slave_priv *p = netdev_priv(dev);
314 struct dsa_switch *ds = p->parent;
315
316 if (ds->drv->get_eeprom)
317 return ds->drv->get_eeprom(ds, eeprom, data);
318
319 return -EOPNOTSUPP;
320}
321
322static int dsa_slave_set_eeprom(struct net_device *dev,
323 struct ethtool_eeprom *eeprom, u8 *data)
324{
325 struct dsa_slave_priv *p = netdev_priv(dev);
326 struct dsa_switch *ds = p->parent;
327
328 if (ds->drv->set_eeprom)
329 return ds->drv->set_eeprom(ds, eeprom, data);
330
331 return -EOPNOTSUPP;
332}
333
334static void dsa_slave_get_strings(struct net_device *dev,
335 uint32_t stringset, uint8_t *data)
336{
337 struct dsa_slave_priv *p = netdev_priv(dev);
338 struct dsa_switch *ds = p->parent;
339
340 if (stringset == ETH_SS_STATS) {
341 int len = ETH_GSTRING_LEN;
342
343 strncpy(data, "tx_packets", len);
344 strncpy(data + len, "tx_bytes", len);
345 strncpy(data + 2 * len, "rx_packets", len);
346 strncpy(data + 3 * len, "rx_bytes", len);
347 if (ds->drv->get_strings != NULL)
348 ds->drv->get_strings(ds, p->port, data + 4 * len);
349 }
350}
351
352static void dsa_slave_get_ethtool_stats(struct net_device *dev,
353 struct ethtool_stats *stats,
354 uint64_t *data)
355{
356 struct dsa_slave_priv *p = netdev_priv(dev);
357 struct dsa_switch *ds = p->parent;
358
359 data[0] = p->dev->stats.tx_packets;
360 data[1] = p->dev->stats.tx_bytes;
361 data[2] = p->dev->stats.rx_packets;
362 data[3] = p->dev->stats.rx_bytes;
363 if (ds->drv->get_ethtool_stats != NULL)
364 ds->drv->get_ethtool_stats(ds, p->port, data + 4);
365}
366
367static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
368{
369 struct dsa_slave_priv *p = netdev_priv(dev);
370 struct dsa_switch *ds = p->parent;
371
372 if (sset == ETH_SS_STATS) {
373 int count;
374
375 count = 4;
376 if (ds->drv->get_sset_count != NULL)
377 count += ds->drv->get_sset_count(ds);
378
379 return count;
380 }
381
382 return -EOPNOTSUPP;
383}
384
385static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
386{
387 struct dsa_slave_priv *p = netdev_priv(dev);
388 struct dsa_switch *ds = p->parent;
389
390 if (ds->drv->get_wol)
391 ds->drv->get_wol(ds, p->port, w);
392}
393
394static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
395{
396 struct dsa_slave_priv *p = netdev_priv(dev);
397 struct dsa_switch *ds = p->parent;
398 int ret = -EOPNOTSUPP;
399
400 if (ds->drv->set_wol)
401 ret = ds->drv->set_wol(ds, p->port, w);
402
403 return ret;
404}
405
406static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
407{
408 struct dsa_slave_priv *p = netdev_priv(dev);
409 struct dsa_switch *ds = p->parent;
410 int ret;
411
412 if (!ds->drv->set_eee)
413 return -EOPNOTSUPP;
414
415 ret = ds->drv->set_eee(ds, p->port, p->phy, e);
416 if (ret)
417 return ret;
418
419 if (p->phy)
420 ret = phy_ethtool_set_eee(p->phy, e);
421
422 return ret;
423}
424
425static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
426{
427 struct dsa_slave_priv *p = netdev_priv(dev);
428 struct dsa_switch *ds = p->parent;
429 int ret;
430
431 if (!ds->drv->get_eee)
432 return -EOPNOTSUPP;
433
434 ret = ds->drv->get_eee(ds, p->port, e);
435 if (ret)
436 return ret;
437
438 if (p->phy)
439 ret = phy_ethtool_get_eee(p->phy, e);
440
441 return ret;
442}
443
444static const struct ethtool_ops dsa_slave_ethtool_ops = {
445 .get_settings = dsa_slave_get_settings,
446 .set_settings = dsa_slave_set_settings,
447 .get_drvinfo = dsa_slave_get_drvinfo,
448 .get_regs_len = dsa_slave_get_regs_len,
449 .get_regs = dsa_slave_get_regs,
450 .nway_reset = dsa_slave_nway_reset,
451 .get_link = dsa_slave_get_link,
452 .get_eeprom_len = dsa_slave_get_eeprom_len,
453 .get_eeprom = dsa_slave_get_eeprom,
454 .set_eeprom = dsa_slave_set_eeprom,
455 .get_strings = dsa_slave_get_strings,
456 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
457 .get_sset_count = dsa_slave_get_sset_count,
458 .set_wol = dsa_slave_set_wol,
459 .get_wol = dsa_slave_get_wol,
460 .set_eee = dsa_slave_set_eee,
461 .get_eee = dsa_slave_get_eee,
462};
463
464static const struct net_device_ops dsa_slave_netdev_ops = {
465 .ndo_init = dsa_slave_init,
466 .ndo_open = dsa_slave_open,
467 .ndo_stop = dsa_slave_close,
468 .ndo_start_xmit = dsa_slave_xmit,
469 .ndo_change_rx_flags = dsa_slave_change_rx_flags,
470 .ndo_set_rx_mode = dsa_slave_set_rx_mode,
471 .ndo_set_mac_address = dsa_slave_set_mac_address,
472 .ndo_do_ioctl = dsa_slave_ioctl,
473};
474
475static void dsa_slave_adjust_link(struct net_device *dev)
476{
477 struct dsa_slave_priv *p = netdev_priv(dev);
478 struct dsa_switch *ds = p->parent;
479 unsigned int status_changed = 0;
480
481 if (p->old_link != p->phy->link) {
482 status_changed = 1;
483 p->old_link = p->phy->link;
484 }
485
486 if (p->old_duplex != p->phy->duplex) {
487 status_changed = 1;
488 p->old_duplex = p->phy->duplex;
489 }
490
491 if (p->old_pause != p->phy->pause) {
492 status_changed = 1;
493 p->old_pause = p->phy->pause;
494 }
495
496 if (ds->drv->adjust_link && status_changed)
497 ds->drv->adjust_link(ds, p->port, p->phy);
498
499 if (status_changed)
500 phy_print_status(p->phy);
501}
502
503static int dsa_slave_fixed_link_update(struct net_device *dev,
504 struct fixed_phy_status *status)
505{
506 struct dsa_slave_priv *p = netdev_priv(dev);
507 struct dsa_switch *ds = p->parent;
508
509 if (ds->drv->fixed_link_update)
510 ds->drv->fixed_link_update(ds, p->port, status);
511
512 return 0;
513}
514
515
516static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
517 struct net_device *slave_dev)
518{
519 struct dsa_switch *ds = p->parent;
520 struct dsa_chip_data *cd = ds->pd;
521 struct device_node *phy_dn, *port_dn;
522 bool phy_is_fixed = false;
523 u32 phy_flags = 0;
524 int ret;
525
526 port_dn = cd->port_dn[p->port];
527 p->phy_interface = of_get_phy_mode(port_dn);
528
529 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
530 if (of_phy_is_fixed_link(port_dn)) {
531
532
533
534 ret = of_phy_register_fixed_link(port_dn);
535 if (ret) {
536 netdev_err(slave_dev, "failed to register fixed PHY\n");
537 return ret;
538 }
539 phy_is_fixed = true;
540 phy_dn = port_dn;
541 }
542
543 if (ds->drv->get_phy_flags)
544 phy_flags = ds->drv->get_phy_flags(ds, p->port);
545
546 if (phy_dn)
547 p->phy = of_phy_connect(slave_dev, phy_dn,
548 dsa_slave_adjust_link, phy_flags,
549 p->phy_interface);
550
551 if (p->phy && phy_is_fixed)
552 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);
553
554
555
556
557 if (!p->phy) {
558 p->phy = ds->slave_mii_bus->phy_map[p->port];
559 if (!p->phy)
560 return -ENODEV;
561
562 phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
563 p->phy_interface);
564 } else {
565 netdev_info(slave_dev, "attached PHY at address %d [%s]\n",
566 p->phy->addr, p->phy->drv->name);
567 }
568
569 return 0;
570}
571
572int dsa_slave_suspend(struct net_device *slave_dev)
573{
574 struct dsa_slave_priv *p = netdev_priv(slave_dev);
575
576 netif_device_detach(slave_dev);
577
578 if (p->phy) {
579 phy_stop(p->phy);
580 p->old_pause = -1;
581 p->old_link = -1;
582 p->old_duplex = -1;
583 phy_suspend(p->phy);
584 }
585
586 return 0;
587}
588
589int dsa_slave_resume(struct net_device *slave_dev)
590{
591 struct dsa_slave_priv *p = netdev_priv(slave_dev);
592
593 netif_device_attach(slave_dev);
594
595 if (p->phy) {
596 phy_resume(p->phy);
597 phy_start(p->phy);
598 }
599
600 return 0;
601}
602
603struct net_device *
604dsa_slave_create(struct dsa_switch *ds, struct device *parent,
605 int port, char *name)
606{
607 struct net_device *master = ds->dst->master_netdev;
608 struct net_device *slave_dev;
609 struct dsa_slave_priv *p;
610 int ret;
611
612 slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name,
613 NET_NAME_UNKNOWN, ether_setup);
614 if (slave_dev == NULL)
615 return slave_dev;
616
617 slave_dev->features = master->vlan_features;
618 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
619 eth_hw_addr_inherit(slave_dev, master);
620 slave_dev->tx_queue_len = 0;
621 slave_dev->netdev_ops = &dsa_slave_netdev_ops;
622
623 SET_NETDEV_DEV(slave_dev, parent);
624 slave_dev->dev.of_node = ds->pd->port_dn[port];
625 slave_dev->vlan_features = master->vlan_features;
626
627 p = netdev_priv(slave_dev);
628 p->dev = slave_dev;
629 p->parent = ds;
630 p->port = port;
631
632 switch (ds->dst->tag_protocol) {
633#ifdef CONFIG_NET_DSA_TAG_DSA
634 case DSA_TAG_PROTO_DSA:
635 p->xmit = dsa_netdev_ops.xmit;
636 break;
637#endif
638#ifdef CONFIG_NET_DSA_TAG_EDSA
639 case DSA_TAG_PROTO_EDSA:
640 p->xmit = edsa_netdev_ops.xmit;
641 break;
642#endif
643#ifdef CONFIG_NET_DSA_TAG_TRAILER
644 case DSA_TAG_PROTO_TRAILER:
645 p->xmit = trailer_netdev_ops.xmit;
646 break;
647#endif
648#ifdef CONFIG_NET_DSA_TAG_BRCM
649 case DSA_TAG_PROTO_BRCM:
650 p->xmit = brcm_netdev_ops.xmit;
651 break;
652#endif
653 default:
654 p->xmit = dsa_slave_notag_xmit;
655 break;
656 }
657
658 p->old_pause = -1;
659 p->old_link = -1;
660 p->old_duplex = -1;
661
662 ret = dsa_slave_phy_setup(p, slave_dev);
663 if (ret) {
664 free_netdev(slave_dev);
665 return NULL;
666 }
667
668 ret = register_netdev(slave_dev);
669 if (ret) {
670 netdev_err(master, "error %d registering interface %s\n",
671 ret, slave_dev->name);
672 phy_disconnect(p->phy);
673 free_netdev(slave_dev);
674 return NULL;
675 }
676
677 netif_carrier_off(slave_dev);
678
679 if (p->phy != NULL) {
680 if (ds->drv->get_phy_flags)
681 p->phy->dev_flags |= ds->drv->get_phy_flags(ds, port);
682
683 phy_attach(slave_dev, dev_name(&p->phy->dev),
684 PHY_INTERFACE_MODE_GMII);
685
686 p->phy->autoneg = AUTONEG_ENABLE;
687 p->phy->speed = 0;
688 p->phy->duplex = 0;
689 p->phy->advertising = p->phy->supported | ADVERTISED_Autoneg;
690 }
691
692 return slave_dev;
693}
694
