xref: /openbmc/linux/net/dsa/slave.c (revision c819e2cf)
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/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 /* slave mii_bus handling ***************************************************/
20 static 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 
30 static 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 
40 void 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 /* slave device handling ****************************************************/
54 static 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 
63 static 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 
101 clear_promisc:
102 	if (dev->flags & IFF_PROMISC)
103 		dev_set_promiscuity(master, 0);
104 clear_allmulti:
105 	if (dev->flags & IFF_ALLMULTI)
106 		dev_set_allmulti(master, -1);
107 del_unicast:
108 	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
109 		dev_uc_del(master, dev->dev_addr);
110 out:
111 	return err;
112 }
113 
114 static 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 
139 static 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 
150 static 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 
159 static 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 
181 out:
182 	ether_addr_copy(dev->dev_addr, addr->sa_data);
183 
184 	return 0;
185 }
186 
187 static 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 
197 static 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 
204 static 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 /* ethtool operations *******************************************************/
217 static int
218 dsa_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 
233 static int
234 dsa_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 
244 static 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 
253 static 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 
264 static void
265 dsa_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 
274 static 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 
284 static 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 
296 static 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 
310 static 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 
322 static 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 
334 static 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 
352 static 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 
367 static 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 
385 static 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 
394 static 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 
406 static 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 
425 static 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 
444 static 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 
464 static 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 
475 static 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 
503 static 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 /* slave device setup *******************************************************/
516 static 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 		/* In the case of a fixed PHY, the DT node associated
532 		 * to the fixed PHY is the Port DT node
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 	/* We could not connect to a designated PHY, so use the switch internal
555 	 * MDIO bus instead
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 
572 int 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 
589 int 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 
603 struct net_device *
604 dsa_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