xref: /openbmc/linux/net/dsa/port.c (revision d198b34f3855eee2571dda03eea75a09c7c31480)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Handling of a single switch port
4  *
5  * Copyright (c) 2017 Savoir-faire Linux Inc.
6  *	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
7  */
8 
9 #include <linux/if_bridge.h>
10 #include <linux/notifier.h>
11 #include <linux/of_mdio.h>
12 #include <linux/of_net.h>
13 
14 #include "dsa_priv.h"
15 
16 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
17 {
18 	struct raw_notifier_head *nh = &dp->ds->dst->nh;
19 	int err;
20 
21 	err = raw_notifier_call_chain(nh, e, v);
22 
23 	return notifier_to_errno(err);
24 }
25 
26 int dsa_port_set_state(struct dsa_port *dp, u8 state,
27 		       struct switchdev_trans *trans)
28 {
29 	struct dsa_switch *ds = dp->ds;
30 	int port = dp->index;
31 
32 	if (switchdev_trans_ph_prepare(trans))
33 		return ds->ops->port_stp_state_set ? 0 : -EOPNOTSUPP;
34 
35 	if (ds->ops->port_stp_state_set)
36 		ds->ops->port_stp_state_set(ds, port, state);
37 
38 	if (ds->ops->port_fast_age) {
39 		/* Fast age FDB entries or flush appropriate forwarding database
40 		 * for the given port, if we are moving it from Learning or
41 		 * Forwarding state, to Disabled or Blocking or Listening state.
42 		 */
43 
44 		if ((dp->stp_state == BR_STATE_LEARNING ||
45 		     dp->stp_state == BR_STATE_FORWARDING) &&
46 		    (state == BR_STATE_DISABLED ||
47 		     state == BR_STATE_BLOCKING ||
48 		     state == BR_STATE_LISTENING))
49 			ds->ops->port_fast_age(ds, port);
50 	}
51 
52 	dp->stp_state = state;
53 
54 	return 0;
55 }
56 
57 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
58 {
59 	int err;
60 
61 	err = dsa_port_set_state(dp, state, NULL);
62 	if (err)
63 		pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
64 }
65 
66 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
67 {
68 	struct dsa_switch *ds = dp->ds;
69 	int port = dp->index;
70 	int err;
71 
72 	if (ds->ops->port_enable) {
73 		err = ds->ops->port_enable(ds, port, phy);
74 		if (err)
75 			return err;
76 	}
77 
78 	if (!dp->bridge_dev)
79 		dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
80 
81 	if (dp->pl)
82 		phylink_start(dp->pl);
83 
84 	return 0;
85 }
86 
87 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
88 {
89 	int err;
90 
91 	rtnl_lock();
92 	err = dsa_port_enable_rt(dp, phy);
93 	rtnl_unlock();
94 
95 	return err;
96 }
97 
98 void dsa_port_disable_rt(struct dsa_port *dp)
99 {
100 	struct dsa_switch *ds = dp->ds;
101 	int port = dp->index;
102 
103 	if (dp->pl)
104 		phylink_stop(dp->pl);
105 
106 	if (!dp->bridge_dev)
107 		dsa_port_set_state_now(dp, BR_STATE_DISABLED);
108 
109 	if (ds->ops->port_disable)
110 		ds->ops->port_disable(ds, port);
111 }
112 
113 void dsa_port_disable(struct dsa_port *dp)
114 {
115 	rtnl_lock();
116 	dsa_port_disable_rt(dp);
117 	rtnl_unlock();
118 }
119 
120 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br)
121 {
122 	struct dsa_notifier_bridge_info info = {
123 		.sw_index = dp->ds->index,
124 		.port = dp->index,
125 		.br = br,
126 	};
127 	int err;
128 
129 	/* Set the flooding mode before joining the port in the switch */
130 	err = dsa_port_bridge_flags(dp, BR_FLOOD | BR_MCAST_FLOOD, NULL);
131 	if (err)
132 		return err;
133 
134 	/* Here the interface is already bridged. Reflect the current
135 	 * configuration so that drivers can program their chips accordingly.
136 	 */
137 	dp->bridge_dev = br;
138 
139 	err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info);
140 
141 	/* The bridging is rolled back on error */
142 	if (err) {
143 		dsa_port_bridge_flags(dp, 0, NULL);
144 		dp->bridge_dev = NULL;
145 	}
146 
147 	return err;
148 }
149 
150 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
151 {
152 	struct dsa_notifier_bridge_info info = {
153 		.sw_index = dp->ds->index,
154 		.port = dp->index,
155 		.br = br,
156 	};
157 	int err;
158 
159 	/* Here the port is already unbridged. Reflect the current configuration
160 	 * so that drivers can program their chips accordingly.
161 	 */
162 	dp->bridge_dev = NULL;
163 
164 	err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info);
165 	if (err)
166 		pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
167 
168 	/* Port is leaving the bridge, disable flooding */
169 	dsa_port_bridge_flags(dp, 0, NULL);
170 
171 	/* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
172 	 * so allow it to be in BR_STATE_FORWARDING to be kept functional
173 	 */
174 	dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
175 }
176 
177 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
178 					      bool vlan_filtering)
179 {
180 	struct dsa_switch *ds = dp->ds;
181 	int i;
182 
183 	if (!ds->vlan_filtering_is_global)
184 		return true;
185 
186 	/* For cases where enabling/disabling VLAN awareness is global to the
187 	 * switch, we need to handle the case where multiple bridges span
188 	 * different ports of the same switch device and one of them has a
189 	 * different setting than what is being requested.
190 	 */
191 	for (i = 0; i < ds->num_ports; i++) {
192 		struct net_device *other_bridge;
193 
194 		other_bridge = dsa_to_port(ds, i)->bridge_dev;
195 		if (!other_bridge)
196 			continue;
197 		/* If it's the same bridge, it also has same
198 		 * vlan_filtering setting => no need to check
199 		 */
200 		if (other_bridge == dp->bridge_dev)
201 			continue;
202 		if (br_vlan_enabled(other_bridge) != vlan_filtering) {
203 			dev_err(ds->dev, "VLAN filtering is a global setting\n");
204 			return false;
205 		}
206 	}
207 	return true;
208 }
209 
210 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
211 			    struct switchdev_trans *trans)
212 {
213 	struct dsa_switch *ds = dp->ds;
214 	int err;
215 
216 	/* bridge skips -EOPNOTSUPP, so skip the prepare phase */
217 	if (switchdev_trans_ph_prepare(trans))
218 		return 0;
219 
220 	if (!ds->ops->port_vlan_filtering)
221 		return 0;
222 
223 	if (!dsa_port_can_apply_vlan_filtering(dp, vlan_filtering))
224 		return -EINVAL;
225 
226 	if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
227 		return 0;
228 
229 	err = ds->ops->port_vlan_filtering(ds, dp->index,
230 					   vlan_filtering);
231 	if (err)
232 		return err;
233 
234 	if (ds->vlan_filtering_is_global)
235 		ds->vlan_filtering = vlan_filtering;
236 	else
237 		dp->vlan_filtering = vlan_filtering;
238 	return 0;
239 }
240 
241 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock,
242 			 struct switchdev_trans *trans)
243 {
244 	unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
245 	unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
246 	struct dsa_notifier_ageing_time_info info = {
247 		.ageing_time = ageing_time,
248 		.trans = trans,
249 	};
250 
251 	if (switchdev_trans_ph_prepare(trans))
252 		return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
253 
254 	dp->ageing_time = ageing_time;
255 
256 	return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
257 }
258 
259 int dsa_port_pre_bridge_flags(const struct dsa_port *dp, unsigned long flags,
260 			      struct switchdev_trans *trans)
261 {
262 	struct dsa_switch *ds = dp->ds;
263 
264 	if (!ds->ops->port_egress_floods ||
265 	    (flags & ~(BR_FLOOD | BR_MCAST_FLOOD)))
266 		return -EINVAL;
267 
268 	return 0;
269 }
270 
271 int dsa_port_bridge_flags(const struct dsa_port *dp, unsigned long flags,
272 			  struct switchdev_trans *trans)
273 {
274 	struct dsa_switch *ds = dp->ds;
275 	int port = dp->index;
276 	int err = 0;
277 
278 	if (switchdev_trans_ph_prepare(trans))
279 		return 0;
280 
281 	if (ds->ops->port_egress_floods)
282 		err = ds->ops->port_egress_floods(ds, port, flags & BR_FLOOD,
283 						  flags & BR_MCAST_FLOOD);
284 
285 	return err;
286 }
287 
288 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter,
289 		     struct switchdev_trans *trans)
290 {
291 	struct dsa_switch *ds = dp->ds;
292 	int port = dp->index;
293 
294 	if (switchdev_trans_ph_prepare(trans))
295 		return ds->ops->port_egress_floods ? 0 : -EOPNOTSUPP;
296 
297 	return ds->ops->port_egress_floods(ds, port, true, mrouter);
298 }
299 
300 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
301 		     u16 vid)
302 {
303 	struct dsa_notifier_fdb_info info = {
304 		.sw_index = dp->ds->index,
305 		.port = dp->index,
306 		.addr = addr,
307 		.vid = vid,
308 	};
309 
310 	return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
311 }
312 
313 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
314 		     u16 vid)
315 {
316 	struct dsa_notifier_fdb_info info = {
317 		.sw_index = dp->ds->index,
318 		.port = dp->index,
319 		.addr = addr,
320 		.vid = vid,
321 
322 	};
323 
324 	return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
325 }
326 
327 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
328 {
329 	struct dsa_switch *ds = dp->ds;
330 	int port = dp->index;
331 
332 	if (!ds->ops->port_fdb_dump)
333 		return -EOPNOTSUPP;
334 
335 	return ds->ops->port_fdb_dump(ds, port, cb, data);
336 }
337 
338 int dsa_port_mdb_add(const struct dsa_port *dp,
339 		     const struct switchdev_obj_port_mdb *mdb,
340 		     struct switchdev_trans *trans)
341 {
342 	struct dsa_notifier_mdb_info info = {
343 		.sw_index = dp->ds->index,
344 		.port = dp->index,
345 		.trans = trans,
346 		.mdb = mdb,
347 	};
348 
349 	return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
350 }
351 
352 int dsa_port_mdb_del(const struct dsa_port *dp,
353 		     const struct switchdev_obj_port_mdb *mdb)
354 {
355 	struct dsa_notifier_mdb_info info = {
356 		.sw_index = dp->ds->index,
357 		.port = dp->index,
358 		.mdb = mdb,
359 	};
360 
361 	return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
362 }
363 
364 int dsa_port_vlan_add(struct dsa_port *dp,
365 		      const struct switchdev_obj_port_vlan *vlan,
366 		      struct switchdev_trans *trans)
367 {
368 	struct dsa_notifier_vlan_info info = {
369 		.sw_index = dp->ds->index,
370 		.port = dp->index,
371 		.trans = trans,
372 		.vlan = vlan,
373 	};
374 
375 	return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
376 }
377 
378 int dsa_port_vlan_del(struct dsa_port *dp,
379 		      const struct switchdev_obj_port_vlan *vlan)
380 {
381 	struct dsa_notifier_vlan_info info = {
382 		.sw_index = dp->ds->index,
383 		.port = dp->index,
384 		.vlan = vlan,
385 	};
386 
387 	return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
388 }
389 
390 int dsa_port_vid_add(struct dsa_port *dp, u16 vid, u16 flags)
391 {
392 	struct switchdev_obj_port_vlan vlan = {
393 		.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
394 		.flags = flags,
395 		.vid_begin = vid,
396 		.vid_end = vid,
397 	};
398 	struct switchdev_trans trans;
399 	int err;
400 
401 	trans.ph_prepare = true;
402 	err = dsa_port_vlan_add(dp, &vlan, &trans);
403 	if (err)
404 		return err;
405 
406 	trans.ph_prepare = false;
407 	return dsa_port_vlan_add(dp, &vlan, &trans);
408 }
409 EXPORT_SYMBOL(dsa_port_vid_add);
410 
411 int dsa_port_vid_del(struct dsa_port *dp, u16 vid)
412 {
413 	struct switchdev_obj_port_vlan vlan = {
414 		.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
415 		.vid_begin = vid,
416 		.vid_end = vid,
417 	};
418 
419 	return dsa_port_vlan_del(dp, &vlan);
420 }
421 EXPORT_SYMBOL(dsa_port_vid_del);
422 
423 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
424 {
425 	struct device_node *phy_dn;
426 	struct phy_device *phydev;
427 
428 	phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
429 	if (!phy_dn)
430 		return NULL;
431 
432 	phydev = of_phy_find_device(phy_dn);
433 	if (!phydev) {
434 		of_node_put(phy_dn);
435 		return ERR_PTR(-EPROBE_DEFER);
436 	}
437 
438 	of_node_put(phy_dn);
439 	return phydev;
440 }
441 
442 static void dsa_port_phylink_validate(struct phylink_config *config,
443 				      unsigned long *supported,
444 				      struct phylink_link_state *state)
445 {
446 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
447 	struct dsa_switch *ds = dp->ds;
448 
449 	if (!ds->ops->phylink_validate)
450 		return;
451 
452 	ds->ops->phylink_validate(ds, dp->index, supported, state);
453 }
454 
455 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
456 					       struct phylink_link_state *state)
457 {
458 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
459 	struct dsa_switch *ds = dp->ds;
460 
461 	/* Only called for inband modes */
462 	if (!ds->ops->phylink_mac_link_state) {
463 		state->link = 0;
464 		return;
465 	}
466 
467 	if (ds->ops->phylink_mac_link_state(ds, dp->index, state) < 0)
468 		state->link = 0;
469 }
470 
471 static void dsa_port_phylink_mac_config(struct phylink_config *config,
472 					unsigned int mode,
473 					const struct phylink_link_state *state)
474 {
475 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
476 	struct dsa_switch *ds = dp->ds;
477 
478 	if (!ds->ops->phylink_mac_config)
479 		return;
480 
481 	ds->ops->phylink_mac_config(ds, dp->index, mode, state);
482 }
483 
484 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
485 {
486 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
487 	struct dsa_switch *ds = dp->ds;
488 
489 	if (!ds->ops->phylink_mac_an_restart)
490 		return;
491 
492 	ds->ops->phylink_mac_an_restart(ds, dp->index);
493 }
494 
495 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
496 					   unsigned int mode,
497 					   phy_interface_t interface)
498 {
499 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
500 	struct phy_device *phydev = NULL;
501 	struct dsa_switch *ds = dp->ds;
502 
503 	if (dsa_is_user_port(ds, dp->index))
504 		phydev = dp->slave->phydev;
505 
506 	if (!ds->ops->phylink_mac_link_down) {
507 		if (ds->ops->adjust_link && phydev)
508 			ds->ops->adjust_link(ds, dp->index, phydev);
509 		return;
510 	}
511 
512 	ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
513 }
514 
515 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
516 					 unsigned int mode,
517 					 phy_interface_t interface,
518 					 struct phy_device *phydev)
519 {
520 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
521 	struct dsa_switch *ds = dp->ds;
522 
523 	if (!ds->ops->phylink_mac_link_up) {
524 		if (ds->ops->adjust_link && phydev)
525 			ds->ops->adjust_link(ds, dp->index, phydev);
526 		return;
527 	}
528 
529 	ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev);
530 }
531 
532 const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
533 	.validate = dsa_port_phylink_validate,
534 	.mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
535 	.mac_config = dsa_port_phylink_mac_config,
536 	.mac_an_restart = dsa_port_phylink_mac_an_restart,
537 	.mac_link_down = dsa_port_phylink_mac_link_down,
538 	.mac_link_up = dsa_port_phylink_mac_link_up,
539 };
540 
541 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
542 {
543 	struct dsa_switch *ds = dp->ds;
544 	struct phy_device *phydev;
545 	int port = dp->index;
546 	int err = 0;
547 
548 	phydev = dsa_port_get_phy_device(dp);
549 	if (!phydev)
550 		return 0;
551 
552 	if (IS_ERR(phydev))
553 		return PTR_ERR(phydev);
554 
555 	if (enable) {
556 		err = genphy_resume(phydev);
557 		if (err < 0)
558 			goto err_put_dev;
559 
560 		err = genphy_read_status(phydev);
561 		if (err < 0)
562 			goto err_put_dev;
563 	} else {
564 		err = genphy_suspend(phydev);
565 		if (err < 0)
566 			goto err_put_dev;
567 	}
568 
569 	if (ds->ops->adjust_link)
570 		ds->ops->adjust_link(ds, port, phydev);
571 
572 	dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
573 
574 err_put_dev:
575 	put_device(&phydev->mdio.dev);
576 	return err;
577 }
578 
579 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
580 {
581 	struct device_node *dn = dp->dn;
582 	struct dsa_switch *ds = dp->ds;
583 	struct phy_device *phydev;
584 	int port = dp->index;
585 	phy_interface_t mode;
586 	int err;
587 
588 	err = of_phy_register_fixed_link(dn);
589 	if (err) {
590 		dev_err(ds->dev,
591 			"failed to register the fixed PHY of port %d\n",
592 			port);
593 		return err;
594 	}
595 
596 	phydev = of_phy_find_device(dn);
597 
598 	err = of_get_phy_mode(dn, &mode);
599 	if (err)
600 		mode = PHY_INTERFACE_MODE_NA;
601 	phydev->interface = mode;
602 
603 	genphy_read_status(phydev);
604 
605 	if (ds->ops->adjust_link)
606 		ds->ops->adjust_link(ds, port, phydev);
607 
608 	put_device(&phydev->mdio.dev);
609 
610 	return 0;
611 }
612 
613 static int dsa_port_phylink_register(struct dsa_port *dp)
614 {
615 	struct dsa_switch *ds = dp->ds;
616 	struct device_node *port_dn = dp->dn;
617 	phy_interface_t mode;
618 	int err;
619 
620 	err = of_get_phy_mode(port_dn, &mode);
621 	if (err)
622 		mode = PHY_INTERFACE_MODE_NA;
623 
624 	dp->pl_config.dev = ds->dev;
625 	dp->pl_config.type = PHYLINK_DEV;
626 	dp->pl_config.pcs_poll = ds->pcs_poll;
627 
628 	dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
629 				mode, &dsa_port_phylink_mac_ops);
630 	if (IS_ERR(dp->pl)) {
631 		pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
632 		return PTR_ERR(dp->pl);
633 	}
634 
635 	err = phylink_of_phy_connect(dp->pl, port_dn, 0);
636 	if (err && err != -ENODEV) {
637 		pr_err("could not attach to PHY: %d\n", err);
638 		goto err_phy_connect;
639 	}
640 
641 	return 0;
642 
643 err_phy_connect:
644 	phylink_destroy(dp->pl);
645 	return err;
646 }
647 
648 int dsa_port_link_register_of(struct dsa_port *dp)
649 {
650 	struct dsa_switch *ds = dp->ds;
651 	struct device_node *phy_np;
652 
653 	if (!ds->ops->adjust_link) {
654 		phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
655 		if (of_phy_is_fixed_link(dp->dn) || phy_np)
656 			return dsa_port_phylink_register(dp);
657 		return 0;
658 	}
659 
660 	dev_warn(ds->dev,
661 		 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
662 
663 	if (of_phy_is_fixed_link(dp->dn))
664 		return dsa_port_fixed_link_register_of(dp);
665 	else
666 		return dsa_port_setup_phy_of(dp, true);
667 }
668 
669 void dsa_port_link_unregister_of(struct dsa_port *dp)
670 {
671 	struct dsa_switch *ds = dp->ds;
672 
673 	if (!ds->ops->adjust_link && dp->pl) {
674 		rtnl_lock();
675 		phylink_disconnect_phy(dp->pl);
676 		rtnl_unlock();
677 		phylink_destroy(dp->pl);
678 		dp->pl = NULL;
679 		return;
680 	}
681 
682 	if (of_phy_is_fixed_link(dp->dn))
683 		of_phy_deregister_fixed_link(dp->dn);
684 	else
685 		dsa_port_setup_phy_of(dp, false);
686 }
687 
688 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
689 {
690 	struct phy_device *phydev;
691 	int ret = -EOPNOTSUPP;
692 
693 	if (of_phy_is_fixed_link(dp->dn))
694 		return ret;
695 
696 	phydev = dsa_port_get_phy_device(dp);
697 	if (IS_ERR_OR_NULL(phydev))
698 		return ret;
699 
700 	ret = phy_ethtool_get_strings(phydev, data);
701 	put_device(&phydev->mdio.dev);
702 
703 	return ret;
704 }
705 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
706 
707 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
708 {
709 	struct phy_device *phydev;
710 	int ret = -EOPNOTSUPP;
711 
712 	if (of_phy_is_fixed_link(dp->dn))
713 		return ret;
714 
715 	phydev = dsa_port_get_phy_device(dp);
716 	if (IS_ERR_OR_NULL(phydev))
717 		return ret;
718 
719 	ret = phy_ethtool_get_stats(phydev, NULL, data);
720 	put_device(&phydev->mdio.dev);
721 
722 	return ret;
723 }
724 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
725 
726 int dsa_port_get_phy_sset_count(struct dsa_port *dp)
727 {
728 	struct phy_device *phydev;
729 	int ret = -EOPNOTSUPP;
730 
731 	if (of_phy_is_fixed_link(dp->dn))
732 		return ret;
733 
734 	phydev = dsa_port_get_phy_device(dp);
735 	if (IS_ERR_OR_NULL(phydev))
736 		return ret;
737 
738 	ret = phy_ethtool_get_sset_count(phydev);
739 	put_device(&phydev->mdio.dev);
740 
741 	return ret;
742 }
743 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);
744