Debian Codegraph @

drivers/net/phy/phy_device.c

raw
1 // SPDX-License-Identifier: GPL-2.0+
2 /* Framework for finding and configuring PHYs.
3 * Also contains generic PHY driver
4 *
5 * Author: Andy Fleming
6 *
7 * Copyright (c) 2004 Freescale Semiconductor, Inc.
8 */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include <linux/acpi.h>
13 #include <linux/bitmap.h>
14 #include <linux/delay.h>
15 #include <linux/errno.h>
16 #include <linux/etherdevice.h>
17 #include <linux/ethtool.h>
18 #include <linux/init.h>
19 #include <linux/interrupt.h>
20 #include <linux/io.h>
21 #include <linux/kernel.h>
22 #include <linux/list.h>
23 #include <linux/mdio.h>
24 #include <linux/mii.h>
25 #include <linux/mm.h>
26 #include <linux/module.h>
27 #include <linux/of.h>
28 #include <linux/netdevice.h>
29 #include <linux/phy.h>
30 #include <linux/phylib_stubs.h>
31 #include <linux/phy_led_triggers.h>
32 #include <linux/phy_link_topology.h>
33 #include <linux/phy_port.h>
34 #include <linux/pse-pd/pse.h>
35 #include <linux/property.h>
36 #include <linux/ptp_clock_kernel.h>
37 #include <linux/rtnetlink.h>
38 #include <linux/sfp.h>
39 #include <linux/skbuff.h>
40 #include <linux/slab.h>
41 #include <linux/string.h>
42 #include <linux/uaccess.h>
43 #include <linux/unistd.h>
44
45 #include "phylib-internal.h"
46 #include "phy-caps.h"
47
48 MODULE_DESCRIPTION("PHY library");
49 MODULE_AUTHOR("Andy Fleming");
50 MODULE_LICENSE("GPL");
51
52 struct phy_fixup {
53 struct list_head list;
54 char bus_id[MII_BUS_ID_SIZE + 3];
55 u32 phy_uid;
56 u32 phy_uid_mask;
57 int (*run)(struct phy_device *phydev);
58 };
59
60 static struct phy_driver genphy_c45_driver = {
61 .phy_id = 0xffffffff,
62 .phy_id_mask = 0xffffffff,
63 .name = "Generic Clause 45 PHY",
64 .read_status = genphy_c45_read_status,
65 };
66
67 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
68 EXPORT_SYMBOL_GPL(phy_basic_features);
69
70 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
71 EXPORT_SYMBOL_GPL(phy_basic_t1_features);
72
73 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1s_p2mp_features) __ro_after_init;
74 EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features);
75
76 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
77 EXPORT_SYMBOL_GPL(phy_gbit_features);
78
79 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
80 EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
81
82 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
83 EXPORT_SYMBOL_GPL(phy_10gbit_features);
84
85 const int phy_basic_ports_array[3] = {
86 ETHTOOL_LINK_MODE_Autoneg_BIT,
87 ETHTOOL_LINK_MODE_TP_BIT,
88 ETHTOOL_LINK_MODE_MII_BIT,
89 };
90 EXPORT_SYMBOL_GPL(phy_basic_ports_array);
91
92 static const int phy_all_ports_features_array[7] __initconst = {
93 ETHTOOL_LINK_MODE_Autoneg_BIT,
94 ETHTOOL_LINK_MODE_TP_BIT,
95 ETHTOOL_LINK_MODE_MII_BIT,
96 ETHTOOL_LINK_MODE_FIBRE_BIT,
97 ETHTOOL_LINK_MODE_AUI_BIT,
98 ETHTOOL_LINK_MODE_BNC_BIT,
99 ETHTOOL_LINK_MODE_Backplane_BIT,
100 };
101
102 static const int phy_10_100_features_array[4] __initconst = {
103 ETHTOOL_LINK_MODE_10baseT_Half_BIT,
104 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
105 ETHTOOL_LINK_MODE_100baseT_Half_BIT,
106 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
107 };
108
109 static const int phy_basic_t1_features_array[3] __initconst = {
110 ETHTOOL_LINK_MODE_TP_BIT,
111 ETHTOOL_LINK_MODE_10baseT1L_Full_BIT,
112 ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
113 };
114
115 static const int phy_basic_t1s_p2mp_features_array[2] __initconst = {
116 ETHTOOL_LINK_MODE_TP_BIT,
117 ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT,
118 };
119
120 static const int phy_gbit_features_array[2] __initconst = {
121 ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
122 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
123 };
124
125 static const int phy_eee_cap1_features_array[] __initconst = {
126 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
127 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
128 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
129 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
130 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
131 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
132 };
133
134 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap1_features) __ro_after_init;
135 EXPORT_SYMBOL_GPL(phy_eee_cap1_features);
136
137 static const int phy_eee_cap2_features_array[] __initconst = {
138 ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
139 ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
140 };
141
142 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap2_features) __ro_after_init;
143 EXPORT_SYMBOL_GPL(phy_eee_cap2_features);
144
145 static void __init features_init(void)
146 {
147 /* 10/100 half/full*/
148 linkmode_set_bit_array(phy_basic_ports_array,
149 ARRAY_SIZE(phy_basic_ports_array),
150 phy_basic_features);
151 linkmode_set_bit_array(phy_10_100_features_array,
152 ARRAY_SIZE(phy_10_100_features_array),
153 phy_basic_features);
154
155 /* 100 full, TP */
156 linkmode_set_bit_array(phy_basic_t1_features_array,
157 ARRAY_SIZE(phy_basic_t1_features_array),
158 phy_basic_t1_features);
159
160 /* 10 half, P2MP, TP */
161 linkmode_set_bit_array(phy_basic_t1s_p2mp_features_array,
162 ARRAY_SIZE(phy_basic_t1s_p2mp_features_array),
163 phy_basic_t1s_p2mp_features);
164
165 /* 10/100 half/full + 1000 half/full */
166 linkmode_set_bit_array(phy_basic_ports_array,
167 ARRAY_SIZE(phy_basic_ports_array),
168 phy_gbit_features);
169 linkmode_set_bit_array(phy_10_100_features_array,
170 ARRAY_SIZE(phy_10_100_features_array),
171 phy_gbit_features);
172 linkmode_set_bit_array(phy_gbit_features_array,
173 ARRAY_SIZE(phy_gbit_features_array),
174 phy_gbit_features);
175
176 /* 10/100 half/full + 1000 half/full + fibre*/
177 linkmode_set_bit_array(phy_basic_ports_array,
178 ARRAY_SIZE(phy_basic_ports_array),
179 phy_gbit_fibre_features);
180 linkmode_set_bit_array(phy_10_100_features_array,
181 ARRAY_SIZE(phy_10_100_features_array),
182 phy_gbit_fibre_features);
183 linkmode_set_bit_array(phy_gbit_features_array,
184 ARRAY_SIZE(phy_gbit_features_array),
185 phy_gbit_fibre_features);
186 linkmode_set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, phy_gbit_fibre_features);
187
188 /* 10/100 half/full + 1000 half/full + 10G full*/
189 linkmode_set_bit_array(phy_all_ports_features_array,
190 ARRAY_SIZE(phy_all_ports_features_array),
191 phy_10gbit_features);
192 linkmode_set_bit_array(phy_10_100_features_array,
193 ARRAY_SIZE(phy_10_100_features_array),
194 phy_10gbit_features);
195 linkmode_set_bit_array(phy_gbit_features_array,
196 ARRAY_SIZE(phy_gbit_features_array),
197 phy_10gbit_features);
198 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
199 phy_10gbit_features);
200
201 linkmode_set_bit_array(phy_eee_cap1_features_array,
202 ARRAY_SIZE(phy_eee_cap1_features_array),
203 phy_eee_cap1_features);
204 linkmode_set_bit_array(phy_eee_cap2_features_array,
205 ARRAY_SIZE(phy_eee_cap2_features_array),
206 phy_eee_cap2_features);
207
208 }
209
210 void phy_device_free(struct phy_device *phydev)
211 {
212 put_device(&phydev->mdio.dev);
213 }
214 EXPORT_SYMBOL(phy_device_free);
215
216 static void phy_mdio_device_free(struct mdio_device *mdiodev)
217 {
218 struct phy_device *phydev;
219
220 phydev = container_of(mdiodev, struct phy_device, mdio);
221 phy_device_free(phydev);
222 }
223
224 static void phy_device_release(struct device *dev)
225 {
226 fwnode_handle_put(dev->fwnode);
227 kfree(to_phy_device(dev));
228 }
229
230 static void phy_mdio_device_remove(struct mdio_device *mdiodev)
231 {
232 struct phy_device *phydev;
233
234 phydev = container_of(mdiodev, struct phy_device, mdio);
235 phy_device_remove(phydev);
236 }
237
238 static struct phy_driver genphy_driver;
239
240 static LIST_HEAD(phy_fixup_list);
241 static DEFINE_MUTEX(phy_fixup_lock);
242
243 static bool phy_drv_wol_enabled(struct phy_device *phydev)
244 {
245 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
246
247 phy_ethtool_get_wol(phydev, &wol);
248
249 return wol.wolopts != 0;
250 }
251
252 bool phy_may_wakeup(struct phy_device *phydev)
253 {
254 /* If the PHY is using driver-model based wakeup, use that state. */
255 if (phy_can_wakeup(phydev))
256 return device_may_wakeup(&phydev->mdio.dev);
257
258 return phy_drv_wol_enabled(phydev);
259 }
260 EXPORT_SYMBOL_GPL(phy_may_wakeup);
261
262 static void phy_link_change(struct phy_device *phydev, bool up)
263 {
264 struct net_device *netdev = phydev->attached_dev;
265
266 if (up)
267 netif_carrier_on(netdev);
268 else
269 netif_carrier_off(netdev);
270 phydev->adjust_link(netdev);
271 if (phydev->mii_ts && phydev->mii_ts->link_state)
272 phydev->mii_ts->link_state(phydev->mii_ts, phydev);
273 }
274
275 /**
276 * phy_uses_state_machine - test whether consumer driver uses PAL state machine
277 * @phydev: the target PHY device structure
278 *
279 * Ultimately, this aims to indirectly determine whether the PHY is attached
280 * to a consumer which uses the state machine by calling phy_start() and
281 * phy_stop().
282 *
283 * When the PHY driver consumer uses phylib, it must have previously called
284 * phy_connect_direct() or one of its derivatives, so that phy_prepare_link()
285 * has set up a hook for monitoring state changes.
286 *
287 * When the PHY driver is used by the MAC driver consumer through phylink (the
288 * only other provider of a phy_link_change() method), using the PHY state
289 * machine is not optional.
290 *
291 * Return: true if consumer calls phy_start() and phy_stop(), false otherwise.
292 */
293 static bool phy_uses_state_machine(struct phy_device *phydev)
294 {
295 if (phydev->phy_link_change == phy_link_change)
296 return phydev->attached_dev && phydev->adjust_link;
297
298 return !!phydev->phy_link_change;
299 }
300
301 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
302 {
303 struct device_driver *drv = phydev->mdio.dev.driver;
304 struct phy_driver *phydrv = to_phy_driver(drv);
305 struct net_device *netdev = phydev->attached_dev;
306
307 if (!drv || !phydrv->suspend)
308 return false;
309
310 /* If the PHY on the mido bus is not attached but has WOL enabled
311 * we cannot suspend the PHY.
312 */
313 if (!netdev && phy_may_wakeup(phydev))
314 return false;
315
316 /* PHY not attached? May suspend if the PHY has not already been
317 * suspended as part of a prior call to phy_disconnect() ->
318 * phy_detach() -> phy_suspend() because the parent netdev might be the
319 * MDIO bus driver and clock gated at this point.
320 */
321 if (!netdev)
322 goto out;
323
324 if (netdev->ethtool->wol_enabled)
325 return false;
326
327 /* As long as not all affected network drivers support the
328 * wol_enabled flag, let's check for hints that WoL is enabled.
329 * Don't suspend PHY if the attached netdev parent may wake up.
330 * The parent may point to a PCI device, as in tg3 driver.
331 */
332 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
333 return false;
334
335 /* Also don't suspend PHY if the netdev itself may wakeup. This
336 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
337 * e.g. SoC devices.
338 */
339 if (device_may_wakeup(&netdev->dev))
340 return false;
341
342 out:
343 return !phydev->suspended;
344 }
345
346 static __maybe_unused int mdio_bus_phy_suspend(struct device *dev)
347 {
348 struct phy_device *phydev = to_phy_device(dev);
349
350 if (phydev->mac_managed_pm)
351 return 0;
352
353 /* Wakeup interrupts may occur during the system sleep transition when
354 * the PHY is inaccessible. Set flag to postpone handling until the PHY
355 * has resumed. Wait for concurrent interrupt handler to complete.
356 */
357 if (phy_interrupt_is_valid(phydev)) {
358 phydev->irq_suspended = 1;
359 synchronize_irq(phydev->irq);
360 }
361
362 /* We must stop the state machine manually, otherwise it stops out of
363 * control, possibly with the phydev->lock held. Upon resume, netdev
364 * may call phy routines that try to grab the same lock, and that may
365 * lead to a deadlock.
366 */
367 if (phy_uses_state_machine(phydev))
368 phy_stop_machine(phydev);
369
370 if (!mdio_bus_phy_may_suspend(phydev))
371 return 0;
372
373 phydev->suspended_by_mdio_bus = 1;
374
375 return phy_suspend(phydev);
376 }
377
378 static __maybe_unused int mdio_bus_phy_resume(struct device *dev)
379 {
380 struct phy_device *phydev = to_phy_device(dev);
381 int ret;
382
383 if (phydev->mac_managed_pm)
384 return 0;
385
386 if (!phydev->suspended_by_mdio_bus)
387 goto no_resume;
388
389 phydev->suspended_by_mdio_bus = 0;
390
391 /* If we managed to get here with the PHY state machine in a state
392 * neither PHY_HALTED, PHY_READY nor PHY_UP, this is an indication
393 * that something went wrong and we should most likely be using
394 * MAC managed PM, but we are not.
395 */
396 WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY &&
397 phydev->state != PHY_UP);
398
399 ret = phy_init_hw(phydev);
400 if (ret < 0)
401 return ret;
402
403 ret = phy_resume(phydev);
404 if (ret < 0)
405 return ret;
406 no_resume:
407 if (phy_interrupt_is_valid(phydev)) {
408 phydev->irq_suspended = 0;
409 synchronize_irq(phydev->irq);
410
411 /* Rerun interrupts which were postponed by phy_interrupt()
412 * because they occurred during the system sleep transition.
413 */
414 if (phydev->irq_rerun) {
415 phydev->irq_rerun = 0;
416 enable_irq(phydev->irq);
417 irq_wake_thread(phydev->irq, phydev);
418 }
419 }
420
421 if (phy_uses_state_machine(phydev))
422 phy_start_machine(phydev);
423
424 return 0;
425 }
426
427 static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend,
428 mdio_bus_phy_resume);
429
430 /**
431 * phy_register_fixup - creates a new phy_fixup and adds it to the list
432 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or NULL)
433 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
434 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
435 * comparison (or 0 to disable id-based matching)
436 * @run: The actual code to be run when a matching PHY is found
437 */
438 static int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
439 int (*run)(struct phy_device *))
440 {
441 struct phy_fixup *fixup = kzalloc_obj(*fixup);
442
443 if (!fixup)
444 return -ENOMEM;
445
446 if (bus_id)
447 strscpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
448 fixup->phy_uid = phy_uid;
449 fixup->phy_uid_mask = phy_uid_mask;
450 fixup->run = run;
451
452 mutex_lock(&phy_fixup_lock);
453 list_add_tail(&fixup->list, &phy_fixup_list);
454 mutex_unlock(&phy_fixup_lock);
455
456 return 0;
457 }
458
459 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
460 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
461 int (*run)(struct phy_device *))
462 {
463 return phy_register_fixup(NULL, phy_uid, phy_uid_mask, run);
464 }
465 EXPORT_SYMBOL(phy_register_fixup_for_uid);
466
467 /* Registers a fixup to be run on the PHY with id string bus_id */
468 int phy_register_fixup_for_id(const char *bus_id,
469 int (*run)(struct phy_device *))
470 {
471 return phy_register_fixup(bus_id, 0, 0, run);
472 }
473 EXPORT_SYMBOL(phy_register_fixup_for_id);
474
475 static bool phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
476 {
477 if (!strcmp(fixup->bus_id, phydev_name(phydev)))
478 return true;
479
480 if (fixup->phy_uid_mask &&
481 phy_id_compare(phydev->phy_id, fixup->phy_uid, fixup->phy_uid_mask))
482 return true;
483
484 return false;
485 }
486
487 /* Runs any matching fixups for this phydev */
488 static int phy_scan_fixups(struct phy_device *phydev)
489 {
490 struct phy_fixup *fixup;
491
492 mutex_lock(&phy_fixup_lock);
493 list_for_each_entry(fixup, &phy_fixup_list, list) {
494 if (phy_needs_fixup(phydev, fixup)) {
495 int err = fixup->run(phydev);
496
497 if (err < 0) {
498 mutex_unlock(&phy_fixup_lock);
499 return err;
500 }
501 phydev->has_fixups = true;
502 }
503 }
504 mutex_unlock(&phy_fixup_lock);
505
506 return 0;
507 }
508
509 /**
510 * genphy_match_phy_device - match a PHY device with a PHY driver
511 * @phydev: target phy_device struct
512 * @phydrv: target phy_driver struct
513 *
514 * Description: Checks whether the given PHY device matches the specified
515 * PHY driver. For Clause 45 PHYs, iterates over the available device
516 * identifiers and compares them against the driver's expected PHY ID,
517 * applying the provided mask. For Clause 22 PHYs, a direct ID comparison
518 * is performed.
519 *
520 * Return: 1 if the PHY device matches the driver, 0 otherwise.
521 */
522 int genphy_match_phy_device(struct phy_device *phydev,
523 const struct phy_driver *phydrv)
524 {
525 if (phydev->is_c45) {
526 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
527 int i;
528
529 for (i = 1; i < num_ids; i++) {
530 if (phydev->c45_ids.device_ids[i] == 0xffffffff)
531 continue;
532
533 if (phy_id_compare(phydev->c45_ids.device_ids[i],
534 phydrv->phy_id, phydrv->phy_id_mask))
535 return 1;
536 }
537
538 return 0;
539 }
540
541 return phy_id_compare(phydev->phy_id, phydrv->phy_id,
542 phydrv->phy_id_mask);
543 }
544 EXPORT_SYMBOL_GPL(genphy_match_phy_device);
545
546 static int phy_bus_match(struct device *dev, const struct device_driver *drv)
547 {
548 struct phy_device *phydev = to_phy_device(dev);
549 const struct phy_driver *phydrv = to_phy_driver(drv);
550
551 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
552 return 0;
553
554 if (phydrv->match_phy_device)
555 return phydrv->match_phy_device(phydev, phydrv);
556
557 return genphy_match_phy_device(phydev, phydrv);
558 }
559
560 static ssize_t
561 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
562 {
563 struct phy_device *phydev = to_phy_device(dev);
564
565 return sysfs_emit(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
566 }
567 static DEVICE_ATTR_RO(phy_id);
568
569 static ssize_t
570 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
571 {
572 struct phy_device *phydev = to_phy_device(dev);
573 const char *mode = NULL;
574
575 if (phydev->is_internal)
576 mode = "internal";
577 else
578 mode = phy_modes(phydev->interface);
579
580 return sysfs_emit(buf, "%s\n", mode);
581 }
582 static DEVICE_ATTR_RO(phy_interface);
583
584 static ssize_t
585 phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
586 char *buf)
587 {
588 struct phy_device *phydev = to_phy_device(dev);
589
590 return sysfs_emit(buf, "%d\n", phydev->has_fixups);
591 }
592 static DEVICE_ATTR_RO(phy_has_fixups);
593
594 static ssize_t phy_dev_flags_show(struct device *dev,
595 struct device_attribute *attr,
596 char *buf)
597 {
598 struct phy_device *phydev = to_phy_device(dev);
599
600 return sysfs_emit(buf, "0x%08x\n", phydev->dev_flags);
601 }
602 static DEVICE_ATTR_RO(phy_dev_flags);
603
604 static struct attribute *phy_dev_attrs[] = {
605 &dev_attr_phy_id.attr,
606 &dev_attr_phy_interface.attr,
607 &dev_attr_phy_has_fixups.attr,
608 &dev_attr_phy_dev_flags.attr,
609 NULL,
610 };
611
612 static const struct attribute_group phy_dev_group = {
613 .attrs = phy_dev_attrs,
614 };
615
616 #define MMD_DEVICE_ID_ATTR(n) \
617 static ssize_t mmd##n##_device_id_show(struct device *dev, \
618 struct device_attribute *attr, char *buf) \
619 { \
620 struct phy_device *phydev = to_phy_device(dev); \
621 return sysfs_emit(buf, "0x%.8lx\n", \
622 (unsigned long)phydev->c45_ids.device_ids[n]); \
623 } \
624 static DEVICE_ATTR_RO(mmd##n##_device_id)
625
626 MMD_DEVICE_ID_ATTR(1);
627 MMD_DEVICE_ID_ATTR(2);
628 MMD_DEVICE_ID_ATTR(3);
629 MMD_DEVICE_ID_ATTR(4);
630 MMD_DEVICE_ID_ATTR(5);
631 MMD_DEVICE_ID_ATTR(6);
632 MMD_DEVICE_ID_ATTR(7);
633 MMD_DEVICE_ID_ATTR(8);
634 MMD_DEVICE_ID_ATTR(9);
635 MMD_DEVICE_ID_ATTR(10);
636 MMD_DEVICE_ID_ATTR(11);
637 MMD_DEVICE_ID_ATTR(12);
638 MMD_DEVICE_ID_ATTR(13);
639 MMD_DEVICE_ID_ATTR(14);
640 MMD_DEVICE_ID_ATTR(15);
641 MMD_DEVICE_ID_ATTR(16);
642 MMD_DEVICE_ID_ATTR(17);
643 MMD_DEVICE_ID_ATTR(18);
644 MMD_DEVICE_ID_ATTR(19);
645 MMD_DEVICE_ID_ATTR(20);
646 MMD_DEVICE_ID_ATTR(21);
647 MMD_DEVICE_ID_ATTR(22);
648 MMD_DEVICE_ID_ATTR(23);
649 MMD_DEVICE_ID_ATTR(24);
650 MMD_DEVICE_ID_ATTR(25);
651 MMD_DEVICE_ID_ATTR(26);
652 MMD_DEVICE_ID_ATTR(27);
653 MMD_DEVICE_ID_ATTR(28);
654 MMD_DEVICE_ID_ATTR(29);
655 MMD_DEVICE_ID_ATTR(30);
656 MMD_DEVICE_ID_ATTR(31);
657
658 static struct attribute *phy_mmd_attrs[] = {
659 &dev_attr_mmd1_device_id.attr,
660 &dev_attr_mmd2_device_id.attr,
661 &dev_attr_mmd3_device_id.attr,
662 &dev_attr_mmd4_device_id.attr,
663 &dev_attr_mmd5_device_id.attr,
664 &dev_attr_mmd6_device_id.attr,
665 &dev_attr_mmd7_device_id.attr,
666 &dev_attr_mmd8_device_id.attr,
667 &dev_attr_mmd9_device_id.attr,
668 &dev_attr_mmd10_device_id.attr,
669 &dev_attr_mmd11_device_id.attr,
670 &dev_attr_mmd12_device_id.attr,
671 &dev_attr_mmd13_device_id.attr,
672 &dev_attr_mmd14_device_id.attr,
673 &dev_attr_mmd15_device_id.attr,
674 &dev_attr_mmd16_device_id.attr,
675 &dev_attr_mmd17_device_id.attr,
676 &dev_attr_mmd18_device_id.attr,
677 &dev_attr_mmd19_device_id.attr,
678 &dev_attr_mmd20_device_id.attr,
679 &dev_attr_mmd21_device_id.attr,
680 &dev_attr_mmd22_device_id.attr,
681 &dev_attr_mmd23_device_id.attr,
682 &dev_attr_mmd24_device_id.attr,
683 &dev_attr_mmd25_device_id.attr,
684 &dev_attr_mmd26_device_id.attr,
685 &dev_attr_mmd27_device_id.attr,
686 &dev_attr_mmd28_device_id.attr,
687 &dev_attr_mmd29_device_id.attr,
688 &dev_attr_mmd30_device_id.attr,
689 &dev_attr_mmd31_device_id.attr,
690 NULL
691 };
692
693 static umode_t phy_mmd_is_visible(struct kobject *kobj,
694 struct attribute *attr, int index)
695 {
696 struct device *dev = kobj_to_dev(kobj);
697 struct phy_device *phydev = to_phy_device(dev);
698 const int i = index + 1;
699
700 if (!phydev->is_c45)
701 return 0;
702 if (i >= ARRAY_SIZE(phydev->c45_ids.device_ids) ||
703 phydev->c45_ids.device_ids[i] == 0xffffffff)
704 return 0;
705
706 return attr->mode;
707 }
708
709 static const struct attribute_group phy_mmd_group = {
710 .name = "c45_phy_ids",
711 .attrs = phy_mmd_attrs,
712 .is_visible = phy_mmd_is_visible,
713 };
714
715 static const struct attribute_group *phy_device_groups[] = {
716 &phy_dev_group,
717 &phy_mmd_group,
718 NULL,
719 };
720
721 static const struct device_type mdio_bus_phy_type = {
722 .name = "PHY",
723 .groups = phy_device_groups,
724 .release = phy_device_release,
725 .pm = pm_ptr(&mdio_bus_phy_pm_ops),
726 };
727
728 static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
729 {
730 int ret;
731
732 ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
733 MDIO_ID_ARGS(phy_id));
734 /* We only check for failures in executing the usermode binary,
735 * not whether a PHY driver module exists for the PHY ID.
736 * Accept -ENOENT because this may occur in case no initramfs exists,
737 * then modprobe isn't available.
738 */
739 if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
740 phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",
741 ret, (unsigned long)phy_id);
742 return ret;
743 }
744
745 return 0;
746 }
747
748 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
749 bool is_c45,
750 struct phy_c45_device_ids *c45_ids)
751 {
752 struct phy_device *dev;
753 struct mdio_device *mdiodev;
754 int ret = 0;
755
756 /* We allocate the device, and initialize the default values */
757 dev = kzalloc_obj(*dev);
758 if (!dev)
759 return ERR_PTR(-ENOMEM);
760
761 mdiodev = &dev->mdio;
762 mdiodev->dev.parent = &bus->dev;
763 mdiodev->dev.bus = &mdio_bus_type;
764 mdiodev->dev.type = &mdio_bus_phy_type;
765 mdiodev->bus = bus;
766 mdiodev->bus_match = phy_bus_match;
767 mdiodev->addr = addr;
768 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
769 mdiodev->device_free = phy_mdio_device_free;
770 mdiodev->device_remove = phy_mdio_device_remove;
771 mdiodev->reset_state = -1;
772
773 dev->speed = SPEED_UNKNOWN;
774 dev->duplex = DUPLEX_UNKNOWN;
775 dev->pause = false;
776 dev->asym_pause = false;
777 dev->link = 0;
778 dev->port = PORT_TP;
779 dev->interface = PHY_INTERFACE_MODE_GMII;
780
781 dev->autoneg = AUTONEG_ENABLE;
782
783 dev->pma_extable = -ENODATA;
784 dev->is_c45 = is_c45;
785 dev->phy_id = phy_id;
786 if (c45_ids)
787 dev->c45_ids = *c45_ids;
788 dev->irq = bus->irq[addr];
789
790 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
791 device_initialize(&mdiodev->dev);
792
793 dev->state = PHY_DOWN;
794 INIT_LIST_HEAD(&dev->leds);
795 INIT_LIST_HEAD(&dev->ports);
796
797 /* The driver's probe function must change that to the real number
798 * of ports possible on the PHY. We assume by default we are dealing
799 * with a single-port PHY
800 */
801 dev->max_n_ports = 1;
802
803 mutex_init(&dev->lock);
804 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
805
806 /* Request the appropriate module unconditionally; don't
807 * bother trying to do so only if it isn't already loaded,
808 * because that gets complicated. A hotplug event would have
809 * done an unconditional modprobe anyway.
810 * We don't do normal hotplug because it won't work for MDIO
811 * -- because it relies on the device staying around for long
812 * enough for the driver to get loaded. With MDIO, the NIC
813 * driver will get bored and give up as soon as it finds that
814 * there's no driver _already_ loaded.
815 */
816 if (is_c45 && c45_ids) {
817 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
818 int i;
819
820 for (i = 1; i < num_ids; i++) {
821 if (c45_ids->device_ids[i] == 0xffffffff)
822 continue;
823
824 ret = phy_request_driver_module(dev,
825 c45_ids->device_ids[i]);
826 if (ret)
827 break;
828 }
829 } else {
830 ret = phy_request_driver_module(dev, phy_id);
831 }
832
833 if (ret) {
834 put_device(&mdiodev->dev);
835 dev = ERR_PTR(ret);
836 }
837
838 return dev;
839 }
840 EXPORT_SYMBOL(phy_device_create);
841
842 /* phy_c45_probe_present - checks to see if a MMD is present in the package
843 * @bus: the target MII bus
844 * @prtad: PHY package address on the MII bus
845 * @devad: PHY device (MMD) address
846 *
847 * Read the MDIO_STAT2 register, and check whether a device is responding
848 * at this address.
849 *
850 * Returns: negative error number on bus access error, zero if no device
851 * is responding, or positive if a device is present.
852 */
853 static int phy_c45_probe_present(struct mii_bus *bus, int prtad, int devad)
854 {
855 int stat2;
856
857 stat2 = mdiobus_c45_read(bus, prtad, devad, MDIO_STAT2);
858 if (stat2 < 0)
859 return stat2;
860
861 return (stat2 & MDIO_STAT2_DEVPRST) == MDIO_STAT2_DEVPRST_VAL;
862 }
863
864 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
865 * @bus: the target MII bus
866 * @addr: PHY address on the MII bus
867 * @dev_addr: MMD address in the PHY.
868 * @devices_in_package: where to store the devices in package information.
869 *
870 * Description: reads devices in package registers of a MMD at @dev_addr
871 * from PHY at @addr on @bus.
872 *
873 * Returns: 0 on success, -EIO on failure.
874 */
875 static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
876 u32 *devices_in_package)
877 {
878 int phy_reg;
879
880 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS2);
881 if (phy_reg < 0)
882 return -EIO;
883 *devices_in_package = phy_reg << 16;
884
885 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS1);
886 if (phy_reg < 0)
887 return -EIO;
888 *devices_in_package |= phy_reg;
889
890 return 0;
891 }
892
893 /**
894 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
895 * @bus: the target MII bus
896 * @addr: PHY address on the MII bus
897 * @c45_ids: where to store the c45 ID information.
898 *
899 * Read the PHY "devices in package". If this appears to be valid, read
900 * the PHY identifiers for each device. Return the "devices in package"
901 * and identifiers in @c45_ids.
902 *
903 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if
904 * the "devices in package" is invalid or no device responds.
905 */
906 static int get_phy_c45_ids(struct mii_bus *bus, int addr,
907 struct phy_c45_device_ids *c45_ids)
908 {
909 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
910 u32 devs_in_pkg = 0;
911 int i, ret, phy_reg;
912
913 /* Find first non-zero Devices In package. Device zero is reserved
914 * for 802.3 c45 complied PHYs, so don't probe it at first.
915 */
916 for (i = 1; i < MDIO_MMD_NUM && (devs_in_pkg == 0 ||
917 (devs_in_pkg & 0x1fffffff) == 0x1fffffff); i++) {
918 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {
919 /* Check that there is a device present at this
920 * address before reading the devices-in-package
921 * register to avoid reading garbage from the PHY.
922 * Some PHYs (88x3310) vendor space is not IEEE802.3
923 * compliant.
924 */
925 ret = phy_c45_probe_present(bus, addr, i);
926 if (ret < 0)
927 /* returning -ENODEV doesn't stop bus
928 * scanning
929 */
930 return (ret == -EIO ||
931 ret == -ENODEV) ? -ENODEV : -EIO;
932
933 if (!ret)
934 continue;
935 }
936 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, &devs_in_pkg);
937 if (phy_reg < 0)
938 return -EIO;
939 }
940
941 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff) {
942 /* If mostly Fs, there is no device there, then let's probe
943 * MMD 0, as some 10G PHYs have zero Devices In package,
944 * e.g. Cortina CS4315/CS4340 PHY.
945 */
946 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, &devs_in_pkg);
947 if (phy_reg < 0)
948 return -EIO;
949
950 /* no device there, let's get out of here */
951 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff)
952 return -ENODEV;
953 }
954
955 /* Now probe Device Identifiers for each device present. */
956 for (i = 1; i < num_ids; i++) {
957 if (!(devs_in_pkg & (1 << i)))
958 continue;
959
960 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {
961 /* Probe the "Device Present" bits for the vendor MMDs
962 * to ignore these if they do not contain IEEE 802.3
963 * registers.
964 */
965 ret = phy_c45_probe_present(bus, addr, i);
966 if (ret < 0)
967 return ret;
968
969 if (!ret)
970 continue;
971 }
972
973 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID1);
974 if (phy_reg < 0)
975 return -EIO;
976 c45_ids->device_ids[i] = phy_reg << 16;
977
978 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID2);
979 if (phy_reg < 0)
980 return -EIO;
981 c45_ids->device_ids[i] |= phy_reg;
982 }
983
984 c45_ids->devices_in_package = devs_in_pkg;
985 /* Bit 0 doesn't represent a device, it indicates c22 regs presence */
986 c45_ids->mmds_present = devs_in_pkg & ~BIT(0);
987
988 return 0;
989 }
990
991 /**
992 * get_phy_c22_id - reads the specified addr for its clause 22 ID.
993 * @bus: the target MII bus
994 * @addr: PHY address on the MII bus
995 * @phy_id: where to store the ID retrieved.
996 *
997 * Read the 802.3 clause 22 PHY ID from the PHY at @addr on the @bus,
998 * placing it in @phy_id. Return zero on successful read and the ID is
999 * valid, %-EIO on bus access error, or %-ENODEV if no device responds
1000 * or invalid ID.
1001 */
1002 static int get_phy_c22_id(struct mii_bus *bus, int addr, u32 *phy_id)
1003 {
1004 int phy_reg;
1005
1006 /* Grab the bits from PHYIR1, and put them in the upper half */
1007 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
1008 if (phy_reg < 0) {
1009 /* returning -ENODEV doesn't stop bus scanning */
1010 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
1011 }
1012
1013 *phy_id = phy_reg << 16;
1014
1015 /* Grab the bits from PHYIR2, and put them in the lower half */
1016 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
1017 if (phy_reg < 0) {
1018 /* returning -ENODEV doesn't stop bus scanning */
1019 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
1020 }
1021
1022 *phy_id |= phy_reg;
1023
1024 /* If the phy_id is mostly Fs, there is no device there */
1025 if ((*phy_id & 0x1fffffff) == 0x1fffffff)
1026 return -ENODEV;
1027
1028 return 0;
1029 }
1030
1031 /* Extract the phy ID from the compatible string of the form
1032 * ethernet-phy-idAAAA.BBBB.
1033 */
1034 int fwnode_get_phy_id(struct fwnode_handle *fwnode, u32 *phy_id)
1035 {
1036 unsigned int upper, lower;
1037 const char *cp;
1038 int ret;
1039
1040 ret = fwnode_property_read_string(fwnode, "compatible", &cp);
1041 if (ret)
1042 return ret;
1043
1044 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) != 2)
1045 return -EINVAL;
1046
1047 *phy_id = ((upper & GENMASK(15, 0)) << 16) | (lower & GENMASK(15, 0));
1048 return 0;
1049 }
1050 EXPORT_SYMBOL(fwnode_get_phy_id);
1051
1052 /**
1053 * get_phy_device - reads the specified PHY device and returns its @phy_device
1054 * struct
1055 * @bus: the target MII bus
1056 * @addr: PHY address on the MII bus
1057 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
1058 *
1059 * Probe for a PHY at @addr on @bus.
1060 *
1061 * When probing for a clause 22 PHY, then read the ID registers. If we find
1062 * a valid ID, allocate and return a &struct phy_device.
1063 *
1064 * When probing for a clause 45 PHY, read the "devices in package" registers.
1065 * If the "devices in package" appears valid, read the ID registers for each
1066 * MMD, allocate and return a &struct phy_device.
1067 *
1068 * Returns an allocated &struct phy_device on success, %-ENODEV if there is
1069 * no PHY present, or %-EIO on bus access error.
1070 */
1071 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
1072 {
1073 struct phy_c45_device_ids c45_ids;
1074 u32 phy_id = 0;
1075 int r;
1076
1077 c45_ids.devices_in_package = 0;
1078 c45_ids.mmds_present = 0;
1079 memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));
1080
1081 if (is_c45)
1082 r = get_phy_c45_ids(bus, addr, &c45_ids);
1083 else
1084 r = get_phy_c22_id(bus, addr, &phy_id);
1085
1086 if (r)
1087 return ERR_PTR(r);
1088
1089 /* PHY device such as the Marvell Alaska 88E2110 will return a PHY ID
1090 * of 0 when probed using get_phy_c22_id() with no error. Proceed to
1091 * probe with C45 to see if we're able to get a valid PHY ID in the C45
1092 * space, if successful, create the C45 PHY device.
1093 */
1094 if (!is_c45 && phy_id == 0 && bus->read_c45) {
1095 r = get_phy_c45_ids(bus, addr, &c45_ids);
1096 if (!r)
1097 return phy_device_create(bus, addr, phy_id,
1098 true, &c45_ids);
1099 }
1100
1101 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
1102 }
1103 EXPORT_SYMBOL(get_phy_device);
1104
1105 /**
1106 * phy_device_register - Register the phy device on the MDIO bus
1107 * @phydev: phy_device structure to be added to the MDIO bus
1108 */
1109 int phy_device_register(struct phy_device *phydev)
1110 {
1111 int err;
1112
1113 err = mdiobus_register_device(&phydev->mdio);
1114 if (err)
1115 return err;
1116
1117 /* Deassert the reset signal */
1118 phy_device_reset(phydev, 0);
1119
1120 /* Run all of the fixups for this PHY */
1121 err = phy_scan_fixups(phydev);
1122 if (err) {
1123 phydev_err(phydev, "failed to initialize\n");
1124 goto out;
1125 }
1126
1127 err = device_add(&phydev->mdio.dev);
1128 if (err) {
1129 phydev_err(phydev, "failed to add\n");
1130 goto out;
1131 }
1132
1133 return 0;
1134
1135 out:
1136 /* Assert the reset signal */
1137 phy_device_reset(phydev, 1);
1138
1139 mdiobus_unregister_device(&phydev->mdio);
1140 return err;
1141 }
1142 EXPORT_SYMBOL(phy_device_register);
1143
1144 /**
1145 * phy_device_remove - Remove a previously registered phy device from the MDIO bus
1146 * @phydev: phy_device structure to remove
1147 *
1148 * This doesn't free the phy_device itself, it merely reverses the effects
1149 * of phy_device_register(). Use phy_device_free() to free the device
1150 * after calling this function.
1151 */
1152 void phy_device_remove(struct phy_device *phydev)
1153 {
1154 unregister_mii_timestamper(phydev->mii_ts);
1155 pse_control_put(phydev->psec);
1156
1157 device_del(&phydev->mdio.dev);
1158
1159 /* Assert the reset signal */
1160 phy_device_reset(phydev, 1);
1161
1162 mdiobus_unregister_device(&phydev->mdio);
1163 }
1164 EXPORT_SYMBOL(phy_device_remove);
1165
1166 /**
1167 * phy_get_c45_ids - Read 802.3-c45 IDs for phy device.
1168 * @phydev: phy_device structure to read 802.3-c45 IDs
1169 *
1170 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if
1171 * the "devices in package" is invalid.
1172 */
1173 int phy_get_c45_ids(struct phy_device *phydev)
1174 {
1175 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr,
1176 &phydev->c45_ids);
1177 }
1178 EXPORT_SYMBOL(phy_get_c45_ids);
1179
1180 /**
1181 * phy_find_next - finds the next PHY device on the bus
1182 * @bus: the target MII bus
1183 * @pos: cursor
1184 *
1185 * Return: next phy_device on the bus, or NULL
1186 */
1187 struct phy_device *phy_find_next(struct mii_bus *bus, struct phy_device *pos)
1188 {
1189 for (int addr = pos ? pos->mdio.addr + 1 : 0;
1190 addr < PHY_MAX_ADDR; addr++) {
1191 struct phy_device *phydev = mdiobus_get_phy(bus, addr);
1192
1193 if (phydev)
1194 return phydev;
1195 }
1196 return NULL;
1197 }
1198 EXPORT_SYMBOL_GPL(phy_find_next);
1199
1200 /**
1201 * phy_prepare_link - prepares the PHY layer to monitor link status
1202 * @phydev: target phy_device struct
1203 * @handler: callback function for link status change notifications
1204 *
1205 * Description: Tells the PHY infrastructure to handle the
1206 * gory details on monitoring link status (whether through
1207 * polling or an interrupt), and to call back to the
1208 * connected device driver when the link status changes.
1209 * If you want to monitor your own link state, don't call
1210 * this function.
1211 */
1212 static void phy_prepare_link(struct phy_device *phydev,
1213 void (*handler)(struct net_device *))
1214 {
1215 phydev->adjust_link = handler;
1216 }
1217
1218 /**
1219 * phy_connect_direct - connect an ethernet device to a specific phy_device
1220 * @dev: the network device to connect
1221 * @phydev: the pointer to the phy device
1222 * @handler: callback function for state change notifications
1223 * @interface: PHY device's interface
1224 */
1225 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
1226 void (*handler)(struct net_device *),
1227 phy_interface_t interface)
1228 {
1229 int rc;
1230
1231 if (!dev)
1232 return -EINVAL;
1233
1234 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1235 if (rc)
1236 return rc;
1237
1238 phy_prepare_link(phydev, handler);
1239 if (phy_interrupt_is_valid(phydev))
1240 phy_request_interrupt(phydev);
1241
1242 return 0;
1243 }
1244 EXPORT_SYMBOL(phy_connect_direct);
1245
1246 /**
1247 * phy_connect - connect an ethernet device to a PHY device
1248 * @dev: the network device to connect
1249 * @bus_id: the id string of the PHY device to connect
1250 * @handler: callback function for state change notifications
1251 * @interface: PHY device's interface
1252 *
1253 * Description: Convenience function for connecting ethernet
1254 * devices to PHY devices. The default behavior is for
1255 * the PHY infrastructure to handle everything, and only notify
1256 * the connected driver when the link status changes. If you
1257 * don't want, or can't use the provided functionality, you may
1258 * choose to call only the subset of functions which provide
1259 * the desired functionality.
1260 */
1261 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
1262 void (*handler)(struct net_device *),
1263 phy_interface_t interface)
1264 {
1265 struct phy_device *phydev;
1266 struct device *d;
1267 int rc;
1268
1269 /* Search the list of PHY devices on the mdio bus for the
1270 * PHY with the requested name
1271 */
1272 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1273 if (!d) {
1274 pr_err("PHY %s not found\n", bus_id);
1275 return ERR_PTR(-ENODEV);
1276 }
1277 phydev = to_phy_device(d);
1278
1279 rc = phy_connect_direct(dev, phydev, handler, interface);
1280 put_device(d);
1281 if (rc)
1282 return ERR_PTR(rc);
1283
1284 return phydev;
1285 }
1286 EXPORT_SYMBOL(phy_connect);
1287
1288 /**
1289 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
1290 * device
1291 * @phydev: target phy_device struct
1292 */
1293 void phy_disconnect(struct phy_device *phydev)
1294 {
1295 if (phy_is_started(phydev))
1296 phy_stop(phydev);
1297
1298 if (phy_interrupt_is_valid(phydev))
1299 phy_free_interrupt(phydev);
1300
1301 phydev->adjust_link = NULL;
1302
1303 phy_detach(phydev);
1304 }
1305 EXPORT_SYMBOL(phy_disconnect);
1306
1307 /**
1308 * phy_poll_reset - Safely wait until a PHY reset has properly completed
1309 * @phydev: The PHY device to poll
1310 *
1311 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
1312 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
1313 * register must be polled until the BMCR_RESET bit clears.
1314 *
1315 * Furthermore, any attempts to write to PHY registers may have no effect
1316 * or even generate MDIO bus errors until this is complete.
1317 *
1318 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
1319 * standard and do not fully reset after the BMCR_RESET bit is set, and may
1320 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
1321 * effort to support such broken PHYs, this function is separate from the
1322 * standard phy_init_hw() which will zero all the other bits in the BMCR
1323 * and reapply all driver-specific and board-specific fixups.
1324 */
1325 static int phy_poll_reset(struct phy_device *phydev)
1326 {
1327 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
1328 int ret, val;
1329
1330 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
1331 50000, 600000, true);
1332 if (ret)
1333 return ret;
1334 /* Some chips (smsc911x) may still need up to another 1ms after the
1335 * BMCR_RESET bit is cleared before they are usable.
1336 */
1337 msleep(1);
1338 return 0;
1339 }
1340
1341 int phy_init_hw(struct phy_device *phydev)
1342 {
1343 int ret = 0;
1344
1345 /* Deassert the reset signal */
1346 phy_device_reset(phydev, 0);
1347
1348 if (!phydev->drv)
1349 return 0;
1350
1351 if (phydev->drv->soft_reset) {
1352 ret = phydev->drv->soft_reset(phydev);
1353 if (ret < 0)
1354 return ret;
1355
1356 /* see comment in genphy_soft_reset for an explanation */
1357 phydev->suspended = 0;
1358 }
1359
1360 ret = phy_scan_fixups(phydev);
1361 if (ret < 0)
1362 return ret;
1363
1364 phy_interface_zero(phydev->possible_interfaces);
1365
1366 if (phydev->drv->config_init) {
1367 ret = phydev->drv->config_init(phydev);
1368 if (ret < 0)
1369 return ret;
1370 }
1371
1372 if (phydev->drv->config_intr) {
1373 ret = phydev->drv->config_intr(phydev);
1374 if (ret < 0)
1375 return ret;
1376 }
1377
1378 return 0;
1379 }
1380 EXPORT_SYMBOL(phy_init_hw);
1381
1382 void phy_attached_info(struct phy_device *phydev)
1383 {
1384 phy_attached_print(phydev, NULL);
1385 }
1386 EXPORT_SYMBOL(phy_attached_info);
1387
1388 #define ATTACHED_FMT "attached PHY driver %s(mii_bus:phy_addr=%s, irq=%s)"
1389 char *phy_attached_info_irq(struct phy_device *phydev)
1390 {
1391 char *irq_str;
1392 char irq_num[8];
1393
1394 switch(phydev->irq) {
1395 case PHY_POLL:
1396 irq_str = "POLL";
1397 break;
1398 case PHY_MAC_INTERRUPT:
1399 irq_str = "MAC";
1400 break;
1401 default:
1402 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1403 irq_str = irq_num;
1404 break;
1405 }
1406
1407 return kasprintf(GFP_KERNEL, "%s", irq_str);
1408 }
1409 EXPORT_SYMBOL(phy_attached_info_irq);
1410
1411 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1412 {
1413 const char *unbound = phydev->drv ? "" : "[unbound] ";
1414 char *irq_str = phy_attached_info_irq(phydev);
1415
1416 if (!fmt) {
1417 phydev_info(phydev, ATTACHED_FMT "\n", unbound,
1418 phydev_name(phydev), irq_str);
1419 } else {
1420 va_list ap;
1421
1422 phydev_info(phydev, ATTACHED_FMT, unbound,
1423 phydev_name(phydev), irq_str);
1424
1425 va_start(ap, fmt);
1426 vprintk(fmt, ap);
1427 va_end(ap);
1428 }
1429 kfree(irq_str);
1430 }
1431 EXPORT_SYMBOL(phy_attached_print);
1432
1433 static void phy_sysfs_create_links(struct phy_device *phydev)
1434 {
1435 struct net_device *dev = phydev->attached_dev;
1436 int err;
1437
1438 if (!dev)
1439 return;
1440
1441 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1442 "attached_dev");
1443 if (err)
1444 return;
1445
1446 err = sysfs_create_link_nowarn(&dev->dev.kobj,
1447 &phydev->mdio.dev.kobj,
1448 "phydev");
1449 if (err) {
1450 dev_err(&dev->dev, "could not add device link to %s err %d\n",
1451 kobject_name(&phydev->mdio.dev.kobj),
1452 err);
1453 /* non-fatal - some net drivers can use one netdevice
1454 * with more then one phy
1455 */
1456 }
1457
1458 phydev->sysfs_links = true;
1459 }
1460
1461 static ssize_t
1462 phy_standalone_show(struct device *dev, struct device_attribute *attr,
1463 char *buf)
1464 {
1465 struct phy_device *phydev = to_phy_device(dev);
1466
1467 return sysfs_emit(buf, "%d\n", !phydev->attached_dev);
1468 }
1469 static DEVICE_ATTR_RO(phy_standalone);
1470
1471 /**
1472 * phy_sfp_connect_phy - Connect the SFP module's PHY to the upstream PHY
1473 * @upstream: pointer to the upstream phy device
1474 * @phy: pointer to the SFP module's phy device
1475 *
1476 * This helper allows keeping track of PHY devices on the link. It adds the
1477 * SFP module's phy to the phy namespace of the upstream phy
1478 *
1479 * Return: 0 on success, otherwise a negative error code.
1480 */
1481 static int phy_sfp_connect_phy(void *upstream, struct phy_device *phy)
1482 {
1483 struct phy_device *phydev = upstream;
1484 struct net_device *dev = phydev->attached_dev;
1485
1486 if (dev)
1487 return phy_link_topo_add_phy(dev, phy, PHY_UPSTREAM_PHY, phydev);
1488
1489 return 0;
1490 }
1491
1492 /**
1493 * phy_sfp_disconnect_phy - Disconnect the SFP module's PHY from the upstream PHY
1494 * @upstream: pointer to the upstream phy device
1495 * @phy: pointer to the SFP module's phy device
1496 *
1497 * This helper allows keeping track of PHY devices on the link. It removes the
1498 * SFP module's phy to the phy namespace of the upstream phy. As the module phy
1499 * will be destroyed, re-inserting the same module will add a new phy with a
1500 * new index.
1501 */
1502 static void phy_sfp_disconnect_phy(void *upstream, struct phy_device *phy)
1503 {
1504 struct phy_device *phydev = upstream;
1505 struct net_device *dev = phydev->attached_dev;
1506
1507 if (dev)
1508 phy_link_topo_del_phy(dev, phy);
1509 }
1510
1511 /**
1512 * phy_sfp_attach - attach the SFP bus to the PHY upstream network device
1513 * @upstream: pointer to the phy device
1514 * @bus: sfp bus representing cage being attached
1515 *
1516 * This is used to fill in the sfp_upstream_ops .attach member.
1517 */
1518 static void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
1519 {
1520 struct phy_device *phydev = upstream;
1521
1522 if (phydev->attached_dev)
1523 phydev->attached_dev->sfp_bus = bus;
1524 phydev->sfp_bus_attached = true;
1525 }
1526
1527 /**
1528 * phy_sfp_detach - detach the SFP bus from the PHY upstream network device
1529 * @upstream: pointer to the phy device
1530 * @bus: sfp bus representing cage being attached
1531 *
1532 * This is used to fill in the sfp_upstream_ops .detach member.
1533 */
1534 static void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
1535 {
1536 struct phy_device *phydev = upstream;
1537
1538 if (phydev->attached_dev)
1539 phydev->attached_dev->sfp_bus = NULL;
1540 phydev->sfp_bus_attached = false;
1541 }
1542
1543 static int phy_sfp_module_insert(void *upstream, const struct sfp_eeprom_id *id)
1544 {
1545 __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support);
1546 struct phy_device *phydev = upstream;
1547 const struct sfp_module_caps *caps;
1548 struct phy_port *port;
1549
1550 phy_interface_t iface;
1551
1552 linkmode_zero(sfp_support);
1553
1554 port = phy_get_sfp_port(phydev);
1555 if (!port)
1556 return -EINVAL;
1557
1558 caps = sfp_get_module_caps(phydev->sfp_bus);
1559
1560 linkmode_and(sfp_support, port->supported, caps->link_modes);
1561 if (linkmode_empty(sfp_support)) {
1562 dev_err(&phydev->mdio.dev, "incompatible SFP module inserted, no common linkmode\n");
1563 return -EINVAL;
1564 }
1565
1566 iface = sfp_select_interface(phydev->sfp_bus, sfp_support);
1567 if (iface == PHY_INTERFACE_MODE_NA) {
1568 dev_err(&phydev->mdio.dev, "PHY %s does not support the SFP module's requested MII interfaces\n",
1569 phydev_name(phydev));
1570 return -EINVAL;
1571 }
1572
1573 if (phydev->n_ports == 1)
1574 phydev->port = caps->port;
1575
1576 if (port->ops && port->ops->configure_mii)
1577 return port->ops->configure_mii(port, true, iface);
1578
1579 return 0;
1580 }
1581
1582 static void phy_sfp_module_remove(void *upstream)
1583 {
1584 struct phy_device *phydev = upstream;
1585 struct phy_port *port = phy_get_sfp_port(phydev);
1586
1587 if (port && port->ops && port->ops->configure_mii)
1588 port->ops->configure_mii(port, false, PHY_INTERFACE_MODE_NA);
1589
1590 if (phydev->n_ports == 1)
1591 phydev->port = PORT_NONE;
1592 }
1593
1594 static void phy_sfp_link_up(void *upstream)
1595 {
1596 struct phy_device *phydev = upstream;
1597 struct phy_port *port = phy_get_sfp_port(phydev);
1598
1599 if (port && port->ops && port->ops->link_up)
1600 port->ops->link_up(port);
1601 }
1602
1603 static void phy_sfp_link_down(void *upstream)
1604 {
1605 struct phy_device *phydev = upstream;
1606 struct phy_port *port = phy_get_sfp_port(phydev);
1607
1608 if (port && port->ops && port->ops->link_down)
1609 port->ops->link_down(port);
1610 }
1611
1612 static const struct sfp_upstream_ops sfp_phydev_ops = {
1613 .attach = phy_sfp_attach,
1614 .detach = phy_sfp_detach,
1615 .module_insert = phy_sfp_module_insert,
1616 .module_remove = phy_sfp_module_remove,
1617 .link_up = phy_sfp_link_up,
1618 .link_down = phy_sfp_link_down,
1619 .connect_phy = phy_sfp_connect_phy,
1620 .disconnect_phy = phy_sfp_disconnect_phy,
1621 };
1622
1623 static int phy_add_port(struct phy_device *phydev, struct phy_port *port)
1624 {
1625 int ret = 0;
1626
1627 if (phydev->n_ports == phydev->max_n_ports)
1628 return -EBUSY;
1629
1630 /* We set all ports as active by default, PHY drivers may deactivate
1631 * them (when unused)
1632 */
1633 port->active = true;
1634
1635 if (port->is_mii) {
1636 if (phydev->drv && phydev->drv->attach_mii_port)
1637 ret = phydev->drv->attach_mii_port(phydev, port);
1638 } else {
1639 if (phydev->drv && phydev->drv->attach_mdi_port)
1640 ret = phydev->drv->attach_mdi_port(phydev, port);
1641 }
1642
1643 if (ret)
1644 return ret;
1645
1646 /* The PHY driver might have added, removed or set medium/pairs info,
1647 * so update the port supported accordingly.
1648 */
1649 phy_port_update_supported(port);
1650
1651 list_add(&port->head, &phydev->ports);
1652
1653 phydev->n_ports++;
1654
1655 return 0;
1656 }
1657
1658 static void phy_del_port(struct phy_device *phydev, struct phy_port *port)
1659 {
1660 if (!phydev->n_ports)
1661 return;
1662
1663 list_del(&port->head);
1664
1665 phydev->n_ports--;
1666 }
1667
1668 static int phy_setup_sfp_port(struct phy_device *phydev)
1669 {
1670 struct phy_port *port = phy_port_alloc();
1671 int ret;
1672
1673 if (!port)
1674 return -ENOMEM;
1675
1676 port->parent_type = PHY_PORT_PHY;
1677 port->phy = phydev;
1678
1679 /* The PHY is a media converter, the port connected to the SFP cage
1680 * is a MII port.
1681 */
1682 port->is_mii = true;
1683 port->is_sfp = true;
1684
1685 /* The port->supported and port->interfaces list will be populated
1686 * when attaching the port to the phydev.
1687 */
1688 ret = phy_add_port(phydev, port);
1689 if (ret)
1690 phy_port_destroy(port);
1691
1692 return ret;
1693 }
1694
1695 /**
1696 * phy_sfp_probe - probe for a SFP cage attached to this PHY device
1697 * @phydev: Pointer to phy_device
1698 */
1699 static int phy_sfp_probe(struct phy_device *phydev)
1700 {
1701 struct sfp_bus *bus;
1702 int ret = 0;
1703
1704 if (phydev->mdio.dev.fwnode) {
1705 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1706 if (IS_ERR(bus))
1707 return PTR_ERR(bus);
1708
1709 phydev->sfp_bus = bus;
1710
1711 ret = sfp_bus_add_upstream(bus, phydev, &sfp_phydev_ops);
1712 sfp_bus_put(bus);
1713 }
1714
1715 if (!ret && phydev->sfp_bus)
1716 ret = phy_setup_sfp_port(phydev);
1717
1718 return ret;
1719 }
1720
1721 static bool phy_drv_supports_irq(const struct phy_driver *phydrv)
1722 {
1723 return phydrv->config_intr && phydrv->handle_interrupt;
1724 }
1725
1726 /**
1727 * phy_attach_direct - attach a network device to a given PHY device pointer
1728 * @dev: network device to attach
1729 * @phydev: Pointer to phy_device to attach
1730 * @flags: PHY device's dev_flags
1731 * @interface: PHY device's interface
1732 *
1733 * Description: Called by drivers to attach to a particular PHY
1734 * device. The phy_device is found, and properly hooked up
1735 * to the phy_driver. If no driver is attached, then a
1736 * generic driver is used. The phy_device is given a ptr to
1737 * the attaching device, and given a callback for link status
1738 * change. The phy_device is returned to the attaching driver.
1739 * This function takes a reference on the phy device.
1740 */
1741 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1742 u32 flags, phy_interface_t interface)
1743 {
1744 struct mii_bus *bus = phydev->mdio.bus;
1745 struct device *d = &phydev->mdio.dev;
1746 struct module *ndev_owner = NULL;
1747 int err;
1748
1749 /* For Ethernet device drivers that register their own MDIO bus, we
1750 * will have bus->owner match ndev_mod, so we do not want to increment
1751 * our own module->refcnt here, otherwise we would not be able to
1752 * unload later on.
1753 */
1754 if (dev)
1755 ndev_owner = dev->dev.parent->driver->owner;
1756 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1757 phydev_err(phydev, "failed to get the bus module\n");
1758 return -EIO;
1759 }
1760
1761 get_device(d);
1762
1763 /* Assume that if there is no driver, that it doesn't
1764 * exist, and we should use the genphy driver.
1765 */
1766 if (!d->driver) {
1767 if (phydev->is_c45)
1768 d->driver = &genphy_c45_driver.mdiodrv.driver;
1769 else
1770 d->driver = &genphy_driver.mdiodrv.driver;
1771
1772 phydev->is_genphy_driven = 1;
1773 }
1774
1775 if (!try_module_get(d->driver->owner)) {
1776 phydev_err(phydev, "failed to get the device driver module\n");
1777 err = -EIO;
1778 goto error_put_device;
1779 }
1780
1781 if (phydev->is_genphy_driven) {
1782 err = d->driver->probe(d);
1783 if (err >= 0)
1784 err = device_bind_driver(d);
1785
1786 if (err)
1787 goto error_module_put;
1788 }
1789
1790 if (phydev->attached_dev) {
1791 dev_err(&dev->dev, "PHY already attached\n");
1792 err = -EBUSY;
1793 goto error;
1794 }
1795
1796 phydev->phy_link_change = phy_link_change;
1797 if (dev) {
1798 phydev->attached_dev = dev;
1799 dev->phydev = phydev;
1800
1801 if (phydev->sfp_bus_attached)
1802 dev->sfp_bus = phydev->sfp_bus;
1803
1804 err = phy_link_topo_add_phy(dev, phydev, PHY_UPSTREAM_MAC, dev);
1805 if (err)
1806 goto error;
1807 }
1808
1809 /* Some Ethernet drivers try to connect to a PHY device before
1810 * calling register_netdevice() -> netdev_register_kobject() and
1811 * does the dev->dev.kobj initialization. Here we only check for
1812 * success which indicates that the network device kobject is
1813 * ready. Once we do that we still need to keep track of whether
1814 * links were successfully set up or not for phy_detach() to
1815 * remove them accordingly.
1816 */
1817 phydev->sysfs_links = false;
1818
1819 phy_sysfs_create_links(phydev);
1820
1821 if (!phydev->attached_dev) {
1822 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1823 &dev_attr_phy_standalone.attr);
1824 if (err)
1825 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1826 }
1827
1828 phydev->dev_flags |= flags;
1829
1830 phydev->interface = interface;
1831
1832 phydev->state = PHY_READY;
1833
1834 phydev->interrupts = PHY_INTERRUPT_DISABLED;
1835
1836 /* PHYs can request to use poll mode even though they have an
1837 * associated interrupt line. This could be the case if they
1838 * detect a broken interrupt handling.
1839 */
1840 if (phydev->dev_flags & PHY_F_NO_IRQ)
1841 phydev->irq = PHY_POLL;
1842
1843 if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev))
1844 phydev->irq = PHY_POLL;
1845
1846 /* Port is set to PORT_TP by default and the actual PHY driver will set
1847 * it to different value depending on the PHY configuration. If we have
1848 * the generic PHY driver we can't figure it out, thus set the old
1849 * legacy PORT_MII value.
1850 */
1851 if (phydev->is_genphy_driven)
1852 phydev->port = PORT_MII;
1853
1854 /* Initial carrier state is off as the phy is about to be
1855 * (re)initialized.
1856 */
1857 if (dev)
1858 netif_carrier_off(phydev->attached_dev);
1859
1860 /* Do initial configuration here, now that
1861 * we have certain key parameters
1862 * (dev_flags and interface)
1863 */
1864 err = phy_init_hw(phydev);
1865 if (err)
1866 goto error;
1867
1868 phy_resume(phydev);
1869
1870 /**
1871 * If the external phy used by current mac interface is managed by
1872 * another mac interface, so we should create a device link between
1873 * phy dev and mac dev.
1874 */
1875 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent)
1876 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev,
1877 DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS);
1878
1879 return err;
1880
1881 error:
1882 /* phy_detach() does all of the cleanup below */
1883 phy_detach(phydev);
1884 return err;
1885
1886 error_module_put:
1887 module_put(d->driver->owner);
1888 phydev->is_genphy_driven = 0;
1889 d->driver = NULL;
1890 error_put_device:
1891 put_device(d);
1892 if (ndev_owner != bus->owner)
1893 module_put(bus->owner);
1894 return err;
1895 }
1896 EXPORT_SYMBOL(phy_attach_direct);
1897
1898 /**
1899 * phy_attach - attach a network device to a particular PHY device
1900 * @dev: network device to attach
1901 * @bus_id: Bus ID of PHY device to attach
1902 * @interface: PHY device's interface
1903 *
1904 * Description: Same as phy_attach_direct() except that a PHY bus_id
1905 * string is passed instead of a pointer to a struct phy_device.
1906 */
1907 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1908 phy_interface_t interface)
1909 {
1910 struct phy_device *phydev;
1911 struct device *d;
1912 int rc;
1913
1914 if (!dev)
1915 return ERR_PTR(-EINVAL);
1916
1917 /* Search the list of PHY devices on the mdio bus for the
1918 * PHY with the requested name
1919 */
1920 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1921 if (!d) {
1922 pr_err("PHY %s not found\n", bus_id);
1923 return ERR_PTR(-ENODEV);
1924 }
1925 phydev = to_phy_device(d);
1926
1927 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1928 put_device(d);
1929 if (rc)
1930 return ERR_PTR(rc);
1931
1932 return phydev;
1933 }
1934 EXPORT_SYMBOL(phy_attach);
1935
1936 /**
1937 * phy_detach - detach a PHY device from its network device
1938 * @phydev: target phy_device struct
1939 *
1940 * This detaches the phy device from its network device and the phy
1941 * driver, and drops the reference count taken in phy_attach_direct().
1942 */
1943 void phy_detach(struct phy_device *phydev)
1944 {
1945 struct net_device *dev = phydev->attached_dev;
1946 struct module *ndev_owner = NULL;
1947 struct mii_bus *bus;
1948
1949 if (phydev->devlink) {
1950 device_link_del(phydev->devlink);
1951 phydev->devlink = NULL;
1952 }
1953
1954 if (phydev->sysfs_links) {
1955 if (dev)
1956 sysfs_remove_link(&dev->dev.kobj, "phydev");
1957 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1958 }
1959
1960 if (!phydev->attached_dev)
1961 sysfs_remove_file(&phydev->mdio.dev.kobj,
1962 &dev_attr_phy_standalone.attr);
1963
1964 phy_suspend(phydev);
1965 if (dev) {
1966 struct hwtstamp_provider *hwprov;
1967
1968 hwprov = rtnl_dereference(dev->hwprov);
1969 /* Disable timestamp if it is the one selected */
1970 if (hwprov && hwprov->phydev == phydev) {
1971 rcu_assign_pointer(dev->hwprov, NULL);
1972 kfree_rcu(hwprov, rcu_head);
1973 }
1974
1975 phydev->attached_dev->phydev = NULL;
1976 phydev->attached_dev = NULL;
1977 phy_link_topo_del_phy(dev, phydev);
1978 }
1979
1980 phydev->phy_link_change = NULL;
1981 phydev->phylink = NULL;
1982
1983 if (phydev->mdio.dev.driver)
1984 module_put(phydev->mdio.dev.driver->owner);
1985
1986 /* If the device had no specific driver before (i.e. - it
1987 * was using the generic driver), we unbind the device
1988 * from the generic driver so that there's a chance a
1989 * real driver could be loaded
1990 */
1991 if (phydev->is_genphy_driven) {
1992 device_release_driver(&phydev->mdio.dev);
1993 phydev->is_genphy_driven = 0;
1994 }
1995
1996 /* Assert the reset signal */
1997 phy_device_reset(phydev, 1);
1998
1999 /*
2000 * The phydev might go away on the put_device() below, so avoid
2001 * a use-after-free bug by reading the underlying bus first.
2002 */
2003 bus = phydev->mdio.bus;
2004
2005 put_device(&phydev->mdio.dev);
2006 if (dev)
2007 ndev_owner = dev->dev.parent->driver->owner;
2008 if (ndev_owner != bus->owner)
2009 module_put(bus->owner);
2010 }
2011 EXPORT_SYMBOL(phy_detach);
2012
2013 int phy_suspend(struct phy_device *phydev)
2014 {
2015 struct net_device *netdev = phydev->attached_dev;
2016 const struct phy_driver *phydrv = phydev->drv;
2017 int ret;
2018
2019 if (phydev->suspended || !phydrv)
2020 return 0;
2021
2022 phydev->wol_enabled = phy_may_wakeup(phydev) ||
2023 (netdev && netdev->ethtool->wol_enabled);
2024 /* If the device has WOL enabled, we cannot suspend the PHY */
2025 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND))
2026 return -EBUSY;
2027
2028 if (!phydrv->suspend)
2029 return 0;
2030
2031 ret = phydrv->suspend(phydev);
2032 if (!ret)
2033 phydev->suspended = true;
2034
2035 return ret;
2036 }
2037 EXPORT_SYMBOL(phy_suspend);
2038
2039 int __phy_resume(struct phy_device *phydev)
2040 {
2041 const struct phy_driver *phydrv = phydev->drv;
2042 int ret;
2043
2044 lockdep_assert_held(&phydev->lock);
2045
2046 if (!phydrv || !phydrv->resume)
2047 return 0;
2048
2049 ret = phydrv->resume(phydev);
2050 if (!ret)
2051 phydev->suspended = false;
2052
2053 return ret;
2054 }
2055 EXPORT_SYMBOL(__phy_resume);
2056
2057 int phy_resume(struct phy_device *phydev)
2058 {
2059 int ret;
2060
2061 mutex_lock(&phydev->lock);
2062 ret = __phy_resume(phydev);
2063 mutex_unlock(&phydev->lock);
2064
2065 return ret;
2066 }
2067 EXPORT_SYMBOL(phy_resume);
2068
2069 /**
2070 * phy_reset_after_clk_enable - perform a PHY reset if needed
2071 * @phydev: target phy_device struct
2072 *
2073 * Description: Some PHYs are known to need a reset after their refclk was
2074 * enabled. This function evaluates the flags and perform the reset if it's
2075 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
2076 * was reset.
2077 */
2078 int phy_reset_after_clk_enable(struct phy_device *phydev)
2079 {
2080 if (!phydev || !phydev->drv)
2081 return -ENODEV;
2082
2083 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
2084 phy_device_reset(phydev, 1);
2085 phy_device_reset(phydev, 0);
2086 return 1;
2087 }
2088
2089 return 0;
2090 }
2091 EXPORT_SYMBOL(phy_reset_after_clk_enable);
2092
2093 /* Generic PHY support and helper functions */
2094
2095 /**
2096 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
2097 * @phydev: target phy_device struct
2098 * @advert: auto-negotiation parameters to advertise
2099 *
2100 * Description: Writes MII_ADVERTISE with the appropriate values,
2101 * after sanitizing the values to make sure we only advertise
2102 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
2103 * hasn't changed, and > 0 if it has changed.
2104 */
2105 static int genphy_config_advert(struct phy_device *phydev,
2106 const unsigned long *advert)
2107 {
2108 int err, bmsr, changed = 0;
2109 u32 adv;
2110
2111 adv = linkmode_adv_to_mii_adv_t(advert);
2112
2113 /* Setup standard advertisement */
2114 err = phy_modify_changed(phydev, MII_ADVERTISE,
2115 ADVERTISE_ALL | ADVERTISE_100BASE4 |
2116 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
2117 adv);
2118 if (err < 0)
2119 return err;
2120 if (err > 0)
2121 changed = 1;
2122
2123 bmsr = phy_read(phydev, MII_BMSR);
2124 if (bmsr < 0)
2125 return bmsr;
2126
2127 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
2128 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
2129 * logical 1.
2130 */
2131 if (!(bmsr & BMSR_ESTATEN))
2132 return changed;
2133
2134 adv = linkmode_adv_to_mii_ctrl1000_t(advert);
2135
2136 err = phy_modify_changed(phydev, MII_CTRL1000,
2137 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
2138 adv);
2139 if (err < 0)
2140 return err;
2141 if (err > 0)
2142 changed = 1;
2143
2144 return changed;
2145 }
2146
2147 /**
2148 * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
2149 * @phydev: target phy_device struct
2150 *
2151 * Description: Writes MII_ADVERTISE with the appropriate values,
2152 * after sanitizing the values to make sure we only advertise
2153 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
2154 * hasn't changed, and > 0 if it has changed. This function is intended
2155 * for Clause 37 1000Base-X mode.
2156 */
2157 static int genphy_c37_config_advert(struct phy_device *phydev)
2158 {
2159 u16 adv = 0;
2160
2161 /* Only allow advertising what this PHY supports */
2162 linkmode_and(phydev->advertising, phydev->advertising,
2163 phydev->supported);
2164
2165 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2166 phydev->advertising))
2167 adv |= ADVERTISE_1000XFULL;
2168 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2169 phydev->advertising))
2170 adv |= ADVERTISE_1000XPAUSE;
2171 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2172 phydev->advertising))
2173 adv |= ADVERTISE_1000XPSE_ASYM;
2174
2175 return phy_modify_changed(phydev, MII_ADVERTISE,
2176 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
2177 ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
2178 adv);
2179 }
2180
2181 /**
2182 * genphy_setup_forced - configures/forces speed/duplex from @phydev
2183 * @phydev: target phy_device struct
2184 *
2185 * Description: Configures MII_BMCR to force speed/duplex
2186 * to the values in phydev. Assumes that the values are valid.
2187 * Please see phy_sanitize_settings().
2188 */
2189 int genphy_setup_forced(struct phy_device *phydev)
2190 {
2191 u16 ctl;
2192
2193 phydev->pause = false;
2194 phydev->asym_pause = false;
2195
2196 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2197
2198 return phy_modify(phydev, MII_BMCR,
2199 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
2200 }
2201 EXPORT_SYMBOL(genphy_setup_forced);
2202
2203 static int genphy_setup_master_slave(struct phy_device *phydev)
2204 {
2205 u16 ctl = 0;
2206
2207 if (!phydev->is_gigabit_capable)
2208 return 0;
2209
2210 switch (phydev->master_slave_set) {
2211 case MASTER_SLAVE_CFG_MASTER_PREFERRED:
2212 ctl |= CTL1000_PREFER_MASTER;
2213 break;
2214 case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
2215 break;
2216 case MASTER_SLAVE_CFG_MASTER_FORCE:
2217 ctl |= CTL1000_AS_MASTER;
2218 fallthrough;
2219 case MASTER_SLAVE_CFG_SLAVE_FORCE:
2220 ctl |= CTL1000_ENABLE_MASTER;
2221 break;
2222 case MASTER_SLAVE_CFG_UNKNOWN:
2223 case MASTER_SLAVE_CFG_UNSUPPORTED:
2224 return 0;
2225 default:
2226 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
2227 return -EOPNOTSUPP;
2228 }
2229
2230 return phy_modify_changed(phydev, MII_CTRL1000,
2231 (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
2232 CTL1000_PREFER_MASTER), ctl);
2233 }
2234
2235 int genphy_read_master_slave(struct phy_device *phydev)
2236 {
2237 int cfg, state;
2238 int val;
2239
2240 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2241 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2242
2243 val = phy_read(phydev, MII_CTRL1000);
2244 if (val < 0)
2245 return val;
2246
2247 if (val & CTL1000_ENABLE_MASTER) {
2248 if (val & CTL1000_AS_MASTER)
2249 cfg = MASTER_SLAVE_CFG_MASTER_FORCE;
2250 else
2251 cfg = MASTER_SLAVE_CFG_SLAVE_FORCE;
2252 } else {
2253 if (val & CTL1000_PREFER_MASTER)
2254 cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED;
2255 else
2256 cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED;
2257 }
2258
2259 val = phy_read(phydev, MII_STAT1000);
2260 if (val < 0)
2261 return val;
2262
2263 if (val & LPA_1000MSFAIL) {
2264 state = MASTER_SLAVE_STATE_ERR;
2265 } else if (phydev->link) {
2266 /* this bits are valid only for active link */
2267 if (val & LPA_1000MSRES)
2268 state = MASTER_SLAVE_STATE_MASTER;
2269 else
2270 state = MASTER_SLAVE_STATE_SLAVE;
2271 } else {
2272 state = MASTER_SLAVE_STATE_UNKNOWN;
2273 }
2274
2275 phydev->master_slave_get = cfg;
2276 phydev->master_slave_state = state;
2277
2278 return 0;
2279 }
2280 EXPORT_SYMBOL(genphy_read_master_slave);
2281
2282 /**
2283 * genphy_restart_aneg - Enable and Restart Autonegotiation
2284 * @phydev: target phy_device struct
2285 */
2286 int genphy_restart_aneg(struct phy_device *phydev)
2287 {
2288 /* Don't isolate the PHY if we're negotiating */
2289 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2290 BMCR_ANENABLE | BMCR_ANRESTART);
2291 }
2292 EXPORT_SYMBOL(genphy_restart_aneg);
2293
2294 /**
2295 * genphy_check_and_restart_aneg - Enable and restart auto-negotiation
2296 * @phydev: target phy_device struct
2297 * @restart: whether aneg restart is requested
2298 *
2299 * Check, and restart auto-negotiation if needed.
2300 */
2301 int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2302 {
2303 int ret;
2304
2305 if (!restart) {
2306 /* Advertisement hasn't changed, but maybe aneg was never on to
2307 * begin with? Or maybe phy was isolated?
2308 */
2309 ret = phy_read(phydev, MII_BMCR);
2310 if (ret < 0)
2311 return ret;
2312
2313 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
2314 restart = true;
2315 }
2316
2317 if (restart)
2318 return genphy_restart_aneg(phydev);
2319
2320 return 0;
2321 }
2322 EXPORT_SYMBOL(genphy_check_and_restart_aneg);
2323
2324 /**
2325 * __genphy_config_aneg - restart auto-negotiation or write BMCR
2326 * @phydev: target phy_device struct
2327 * @changed: whether autoneg is requested
2328 *
2329 * Description: If auto-negotiation is enabled, we configure the
2330 * advertising, and then restart auto-negotiation. If it is not
2331 * enabled, then we write the BMCR.
2332 */
2333 int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2334 {
2335 __ETHTOOL_DECLARE_LINK_MODE_MASK(fixed_advert);
2336 const struct link_capabilities *c;
2337 unsigned long *advert;
2338 int err;
2339
2340 err = genphy_c45_an_config_eee_aneg(phydev);
2341 if (err < 0)
2342 return err;
2343 else if (err)
2344 changed = true;
2345
2346 err = genphy_setup_master_slave(phydev);
2347 if (err < 0)
2348 return err;
2349 else if (err)
2350 changed = true;
2351
2352 if (phydev->autoneg == AUTONEG_ENABLE) {
2353 /* Only allow advertising what this PHY supports */
2354 linkmode_and(phydev->advertising, phydev->advertising,
2355 phydev->supported);
2356 advert = phydev->advertising;
2357 } else if (phydev->speed < SPEED_1000) {
2358 return genphy_setup_forced(phydev);
2359 } else {
2360 linkmode_zero(fixed_advert);
2361
2362 c = phy_caps_lookup(phydev->speed, phydev->duplex,
2363 phydev->supported, true);
2364 if (c)
2365 linkmode_and(fixed_advert, phydev->supported,
2366 c->linkmodes);
2367
2368 advert = fixed_advert;
2369 }
2370
2371 err = genphy_config_advert(phydev, advert);
2372 if (err < 0) /* error */
2373 return err;
2374 else if (err)
2375 changed = true;
2376
2377 return genphy_check_and_restart_aneg(phydev, changed);
2378 }
2379 EXPORT_SYMBOL(__genphy_config_aneg);
2380
2381 /**
2382 * genphy_c37_config_aneg - restart auto-negotiation or write BMCR
2383 * @phydev: target phy_device struct
2384 *
2385 * Description: If auto-negotiation is enabled, we configure the
2386 * advertising, and then restart auto-negotiation. If it is not
2387 * enabled, then we write the BMCR. This function is intended
2388 * for use with Clause 37 1000Base-X mode.
2389 */
2390 int genphy_c37_config_aneg(struct phy_device *phydev)
2391 {
2392 int err, changed;
2393
2394 if (phydev->autoneg != AUTONEG_ENABLE)
2395 return genphy_setup_forced(phydev);
2396
2397 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2398 BMCR_SPEED1000);
2399 if (err)
2400 return err;
2401
2402 changed = genphy_c37_config_advert(phydev);
2403 if (changed < 0) /* error */
2404 return changed;
2405
2406 if (!changed) {
2407 /* Advertisement hasn't changed, but maybe aneg was never on to
2408 * begin with? Or maybe phy was isolated?
2409 */
2410 int ctl = phy_read(phydev, MII_BMCR);
2411
2412 if (ctl < 0)
2413 return ctl;
2414
2415 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
2416 changed = 1; /* do restart aneg */
2417 }
2418
2419 /* Only restart aneg if we are advertising something different
2420 * than we were before.
2421 */
2422 if (changed > 0)
2423 return genphy_restart_aneg(phydev);
2424
2425 return 0;
2426 }
2427 EXPORT_SYMBOL(genphy_c37_config_aneg);
2428
2429 /**
2430 * genphy_aneg_done - return auto-negotiation status
2431 * @phydev: target phy_device struct
2432 *
2433 * Description: Reads the status register and returns 0 either if
2434 * auto-negotiation is incomplete, or if there was an error.
2435 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
2436 */
2437 int genphy_aneg_done(struct phy_device *phydev)
2438 {
2439 int retval = phy_read(phydev, MII_BMSR);
2440
2441 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
2442 }
2443 EXPORT_SYMBOL(genphy_aneg_done);
2444
2445 /**
2446 * genphy_update_link - update link status in @phydev
2447 * @phydev: target phy_device struct
2448 *
2449 * Description: Update the value in phydev->link to reflect the
2450 * current link value. In order to do this, we need to read
2451 * the status register twice, keeping the second value.
2452 */
2453 int genphy_update_link(struct phy_device *phydev)
2454 {
2455 int status = 0, bmcr;
2456
2457 bmcr = phy_read(phydev, MII_BMCR);
2458 if (bmcr < 0)
2459 return bmcr;
2460
2461 /* Autoneg is being started, therefore disregard BMSR value and
2462 * report link as down.
2463 */
2464 if (bmcr & BMCR_ANRESTART)
2465 goto done;
2466
2467 /* The link state is latched low so that momentary link
2468 * drops can be detected. Do not double-read the status
2469 * in polling mode to detect such short link drops except
2470 * if the link was already down.
2471 */
2472 if (!phy_polling_mode(phydev) || !phydev->link) {
2473 status = phy_read(phydev, MII_BMSR);
2474 if (status < 0)
2475 return status;
2476 else if (status & BMSR_LSTATUS)
2477 goto done;
2478 }
2479
2480 /* Read link and autonegotiation status */
2481 status = phy_read(phydev, MII_BMSR);
2482 if (status < 0)
2483 return status;
2484 done:
2485 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2486 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2487
2488 /* Consider the case that autoneg was started and "aneg complete"
2489 * bit has been reset, but "link up" bit not yet.
2490 */
2491 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2492 phydev->link = 0;
2493
2494 return 0;
2495 }
2496 EXPORT_SYMBOL(genphy_update_link);
2497
2498 int genphy_read_lpa(struct phy_device *phydev)
2499 {
2500 int lpa, lpagb;
2501
2502 if (phydev->autoneg == AUTONEG_ENABLE) {
2503 if (!phydev->autoneg_complete) {
2504 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2505 0);
2506 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2507 return 0;
2508 }
2509
2510 if (phydev->is_gigabit_capable) {
2511 lpagb = phy_read(phydev, MII_STAT1000);
2512 if (lpagb < 0)
2513 return lpagb;
2514
2515 if (lpagb & LPA_1000MSFAIL) {
2516 int adv = phy_read(phydev, MII_CTRL1000);
2517
2518 if (adv < 0)
2519 return adv;
2520
2521 if (adv & CTL1000_ENABLE_MASTER)
2522 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2523 else
2524 phydev_err(phydev, "Master/Slave resolution failed\n");
2525 return -ENOLINK;
2526 }
2527
2528 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2529 lpagb);
2530 }
2531
2532 lpa = phy_read(phydev, MII_LPA);
2533 if (lpa < 0)
2534 return lpa;
2535
2536 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2537 } else {
2538 linkmode_zero(phydev->lp_advertising);
2539 }
2540
2541 return 0;
2542 }
2543 EXPORT_SYMBOL(genphy_read_lpa);
2544
2545 /**
2546 * genphy_read_status_fixed - read the link parameters for !aneg mode
2547 * @phydev: target phy_device struct
2548 *
2549 * Read the current duplex and speed state for a PHY operating with
2550 * autonegotiation disabled.
2551 */
2552 int genphy_read_status_fixed(struct phy_device *phydev)
2553 {
2554 int bmcr = phy_read(phydev, MII_BMCR);
2555
2556 if (bmcr < 0)
2557 return bmcr;
2558
2559 if (bmcr & BMCR_FULLDPLX)
2560 phydev->duplex = DUPLEX_FULL;
2561 else
2562 phydev->duplex = DUPLEX_HALF;
2563
2564 if (bmcr & BMCR_SPEED1000)
2565 phydev->speed = SPEED_1000;
2566 else if (bmcr & BMCR_SPEED100)
2567 phydev->speed = SPEED_100;
2568 else
2569 phydev->speed = SPEED_10;
2570
2571 return 0;
2572 }
2573 EXPORT_SYMBOL(genphy_read_status_fixed);
2574
2575 /**
2576 * genphy_read_status - check the link status and update current link state
2577 * @phydev: target phy_device struct
2578 *
2579 * Description: Check the link, then figure out the current state
2580 * by comparing what we advertise with what the link partner
2581 * advertises. Start by checking the gigabit possibilities,
2582 * then move on to 10/100.
2583 */
2584 int genphy_read_status(struct phy_device *phydev)
2585 {
2586 int err, old_link = phydev->link;
2587
2588 /* Update the link, but return if there was an error */
2589 err = genphy_update_link(phydev);
2590 if (err)
2591 return err;
2592
2593 /* why bother the PHY if nothing can have changed */
2594 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2595 return 0;
2596
2597 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
2598 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2599 phydev->speed = SPEED_UNKNOWN;
2600 phydev->duplex = DUPLEX_UNKNOWN;
2601 phydev->pause = false;
2602 phydev->asym_pause = false;
2603
2604 if (phydev->is_gigabit_capable) {
2605 err = genphy_read_master_slave(phydev);
2606 if (err < 0)
2607 return err;
2608 }
2609
2610 err = genphy_read_lpa(phydev);
2611 if (err < 0)
2612 return err;
2613
2614 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2615 phy_resolve_aneg_linkmode(phydev);
2616 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2617 err = genphy_read_status_fixed(phydev);
2618 if (err < 0)
2619 return err;
2620 }
2621
2622 return 0;
2623 }
2624 EXPORT_SYMBOL(genphy_read_status);
2625
2626 /**
2627 * genphy_c37_read_status - check the link status and update current link state
2628 * @phydev: target phy_device struct
2629 * @changed: pointer where to store if link changed
2630 *
2631 * Description: Check the link, then figure out the current state
2632 * by comparing what we advertise with what the link partner
2633 * advertises. This function is for Clause 37 1000Base-X mode.
2634 *
2635 * If link has changed, @changed is set to true, false otherwise.
2636 */
2637 int genphy_c37_read_status(struct phy_device *phydev, bool *changed)
2638 {
2639 int lpa, err, old_link = phydev->link;
2640
2641 /* Update the link, but return if there was an error */
2642 err = genphy_update_link(phydev);
2643 if (err)
2644 return err;
2645
2646 /* why bother the PHY if nothing can have changed */
2647 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) {
2648 *changed = false;
2649 return 0;
2650 }
2651
2652 /* Signal link has changed */
2653 *changed = true;
2654 phydev->duplex = DUPLEX_UNKNOWN;
2655 phydev->pause = false;
2656 phydev->asym_pause = false;
2657
2658 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2659 lpa = phy_read(phydev, MII_LPA);
2660 if (lpa < 0)
2661 return lpa;
2662
2663 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2664 phydev->lp_advertising, lpa & LPA_LPACK);
2665 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2666 phydev->lp_advertising, lpa & LPA_1000XFULL);
2667 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2668 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2669 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2670 phydev->lp_advertising,
2671 lpa & LPA_1000XPAUSE_ASYM);
2672
2673 phy_resolve_aneg_linkmode(phydev);
2674 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2675 int bmcr = phy_read(phydev, MII_BMCR);
2676
2677 if (bmcr < 0)
2678 return bmcr;
2679
2680 if (bmcr & BMCR_FULLDPLX)
2681 phydev->duplex = DUPLEX_FULL;
2682 else
2683 phydev->duplex = DUPLEX_HALF;
2684 }
2685
2686 return 0;
2687 }
2688 EXPORT_SYMBOL(genphy_c37_read_status);
2689
2690 /**
2691 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
2692 * @phydev: target phy_device struct
2693 *
2694 * Description: Perform a software PHY reset using the standard
2695 * BMCR_RESET bit and poll for the reset bit to be cleared.
2696 *
2697 * Returns: 0 on success, < 0 on failure
2698 */
2699 int genphy_soft_reset(struct phy_device *phydev)
2700 {
2701 u16 res = BMCR_RESET;
2702 int ret;
2703
2704 if (phydev->autoneg == AUTONEG_ENABLE)
2705 res |= BMCR_ANRESTART;
2706
2707 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2708 if (ret < 0)
2709 return ret;
2710
2711 /* Clause 22 states that setting bit BMCR_RESET sets control registers
2712 * to their default value. Therefore the POWER DOWN bit is supposed to
2713 * be cleared after soft reset.
2714 */
2715 phydev->suspended = 0;
2716
2717 ret = phy_poll_reset(phydev);
2718 if (ret)
2719 return ret;
2720
2721 /* BMCR may be reset to defaults */
2722 if (phydev->autoneg == AUTONEG_DISABLE)
2723 ret = genphy_setup_forced(phydev);
2724
2725 return ret;
2726 }
2727 EXPORT_SYMBOL(genphy_soft_reset);
2728
2729 irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
2730 {
2731 /* It seems there are cases where the interrupts are handled by another
2732 * entity (ie an IRQ controller embedded inside the PHY) and do not
2733 * need any other interraction from phylib. In this case, just trigger
2734 * the state machine directly.
2735 */
2736 phy_trigger_machine(phydev);
2737
2738 return 0;
2739 }
2740 EXPORT_SYMBOL(genphy_handle_interrupt_no_ack);
2741
2742 /**
2743 * genphy_read_abilities - read PHY abilities from Clause 22 registers
2744 * @phydev: target phy_device struct
2745 *
2746 * Description: Reads the PHY's abilities and populates
2747 * phydev->supported accordingly.
2748 *
2749 * Returns: 0 on success, < 0 on failure
2750 */
2751 int genphy_read_abilities(struct phy_device *phydev)
2752 {
2753 int val;
2754
2755 linkmode_set_bit_array(phy_basic_ports_array,
2756 ARRAY_SIZE(phy_basic_ports_array),
2757 phydev->supported);
2758
2759 val = phy_read(phydev, MII_BMSR);
2760 if (val < 0)
2761 return val;
2762
2763 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2764 val & BMSR_ANEGCAPABLE);
2765
2766 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2767 val & BMSR_100FULL);
2768 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2769 val & BMSR_100HALF);
2770 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2771 val & BMSR_10FULL);
2772 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2773 val & BMSR_10HALF);
2774
2775 if (val & BMSR_ESTATEN) {
2776 val = phy_read(phydev, MII_ESTATUS);
2777 if (val < 0)
2778 return val;
2779
2780 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2781 phydev->supported, val & ESTATUS_1000_TFULL);
2782 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2783 phydev->supported, val & ESTATUS_1000_THALF);
2784 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2785 phydev->supported, val & ESTATUS_1000_XFULL);
2786 }
2787
2788 /* This is optional functionality. If not supported, we may get an error
2789 * which should be ignored.
2790 */
2791 genphy_c45_read_eee_abilities(phydev);
2792
2793 return 0;
2794 }
2795 EXPORT_SYMBOL(genphy_read_abilities);
2796
2797 /* This is used for the phy device which doesn't support the MMD extended
2798 * register access, but it does have side effect when we are trying to access
2799 * the MMD register via indirect method.
2800 */
2801 int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
2802 {
2803 return -EOPNOTSUPP;
2804 }
2805 EXPORT_SYMBOL(genphy_read_mmd_unsupported);
2806
2807 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
2808 u16 regnum, u16 val)
2809 {
2810 return -EOPNOTSUPP;
2811 }
2812 EXPORT_SYMBOL(genphy_write_mmd_unsupported);
2813
2814 int genphy_suspend(struct phy_device *phydev)
2815 {
2816 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2817 }
2818 EXPORT_SYMBOL(genphy_suspend);
2819
2820 int genphy_resume(struct phy_device *phydev)
2821 {
2822 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2823 }
2824 EXPORT_SYMBOL(genphy_resume);
2825
2826 int genphy_loopback(struct phy_device *phydev, bool enable, int speed)
2827 {
2828 if (enable) {
2829 u16 ctl = BMCR_LOOPBACK;
2830 int ret, val;
2831
2832 if (speed == SPEED_10 || speed == SPEED_100 ||
2833 speed == SPEED_1000)
2834 phydev->speed = speed;
2835 else if (speed)
2836 return -EINVAL;
2837
2838 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2839
2840 phy_modify(phydev, MII_BMCR, ~0, ctl);
2841
2842 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,
2843 val & BMSR_LSTATUS,
2844 5000, 500000, true);
2845 if (ret)
2846 return ret;
2847 } else {
2848 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
2849
2850 phy_config_aneg(phydev);
2851 }
2852
2853 return 0;
2854 }
2855 EXPORT_SYMBOL(genphy_loopback);
2856
2857 /**
2858 * phy_remove_link_mode - Remove a supported link mode
2859 * @phydev: phy_device structure to remove link mode from
2860 * @link_mode: Link mode to be removed
2861 *
2862 * Description: Some MACs don't support all link modes which the PHY
2863 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper
2864 * to remove a link mode.
2865 */
2866 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2867 {
2868 linkmode_clear_bit(link_mode, phydev->supported);
2869 phy_advertise_supported(phydev);
2870 }
2871 EXPORT_SYMBOL(phy_remove_link_mode);
2872
2873 static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2874 {
2875 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2876 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2877 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2878 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2879 }
2880
2881 /**
2882 * phy_advertise_supported - Advertise all supported modes
2883 * @phydev: target phy_device struct
2884 *
2885 * Description: Called to advertise all supported modes, doesn't touch
2886 * pause mode advertising.
2887 */
2888 void phy_advertise_supported(struct phy_device *phydev)
2889 {
2890 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2891
2892 linkmode_copy(new, phydev->supported);
2893 phy_copy_pause_bits(new, phydev->advertising);
2894 linkmode_copy(phydev->advertising, new);
2895 }
2896 EXPORT_SYMBOL(phy_advertise_supported);
2897
2898 /**
2899 * phy_advertise_eee_all - Advertise all supported EEE modes
2900 * @phydev: target phy_device struct
2901 *
2902 * Description: Per default phylib preserves the EEE advertising at the time of
2903 * phy probing, which might be a subset of the supported EEE modes. Use this
2904 * function when all supported EEE modes should be advertised. This does not
2905 * trigger auto-negotiation, so must be called before phy_start()/
2906 * phylink_start() which will start auto-negotiation.
2907 */
2908 void phy_advertise_eee_all(struct phy_device *phydev)
2909 {
2910 linkmode_andnot(phydev->advertising_eee, phydev->supported_eee,
2911 phydev->eee_disabled_modes);
2912 }
2913 EXPORT_SYMBOL_GPL(phy_advertise_eee_all);
2914
2915 /**
2916 * phy_support_eee - Set initial EEE policy configuration
2917 * @phydev: Target phy_device struct
2918 *
2919 * This function configures the initial policy for Energy Efficient Ethernet
2920 * (EEE) on the specified PHY device, influencing that EEE capabilities are
2921 * advertised before the link is established. It should be called during PHY
2922 * registration by the MAC driver and/or the PHY driver (for SmartEEE PHYs)
2923 * if MAC supports LPI or PHY is capable to compensate missing LPI functionality
2924 * of the MAC.
2925 *
2926 * The function sets default EEE policy parameters, including preparing the PHY
2927 * to advertise EEE capabilities based on hardware support.
2928 *
2929 * It also sets the expected configuration for Low Power Idle (LPI) in the MAC
2930 * driver. If the PHY framework determines that both local and remote
2931 * advertisements support EEE, and the negotiated link mode is compatible with
2932 * EEE, it will set enable_tx_lpi = true. The MAC driver is expected to act on
2933 * this setting by enabling the LPI timer if enable_tx_lpi is set.
2934 */
2935 void phy_support_eee(struct phy_device *phydev)
2936 {
2937 linkmode_andnot(phydev->advertising_eee, phydev->supported_eee,
2938 phydev->eee_disabled_modes);
2939 phydev->eee_cfg.tx_lpi_enabled = true;
2940 phydev->eee_cfg.eee_enabled = true;
2941 }
2942 EXPORT_SYMBOL(phy_support_eee);
2943
2944 /**
2945 * phy_disable_eee - Disable EEE for the PHY
2946 * @phydev: Target phy_device struct
2947 *
2948 * This function is used by MAC drivers for MAC's which don't support EEE.
2949 * It disables EEE on the PHY layer.
2950 */
2951 void phy_disable_eee(struct phy_device *phydev)
2952 {
2953 linkmode_zero(phydev->advertising_eee);
2954 phydev->eee_cfg.tx_lpi_enabled = false;
2955 phydev->eee_cfg.eee_enabled = false;
2956 /* don't let userspace re-enable EEE advertisement */
2957 linkmode_fill(phydev->eee_disabled_modes);
2958 }
2959 EXPORT_SYMBOL_GPL(phy_disable_eee);
2960
2961 /**
2962 * phy_support_sym_pause - Enable support of symmetrical pause
2963 * @phydev: target phy_device struct
2964 *
2965 * Description: Called by the MAC to indicate is supports symmetrical
2966 * Pause, but not asym pause.
2967 */
2968 void phy_support_sym_pause(struct phy_device *phydev)
2969 {
2970 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2971 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2972 }
2973 EXPORT_SYMBOL(phy_support_sym_pause);
2974
2975 /**
2976 * phy_support_asym_pause - Enable support of asym pause
2977 * @phydev: target phy_device struct
2978 *
2979 * Description: Called by the MAC to indicate is supports Asym Pause.
2980 */
2981 void phy_support_asym_pause(struct phy_device *phydev)
2982 {
2983 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2984 }
2985 EXPORT_SYMBOL(phy_support_asym_pause);
2986
2987 /**
2988 * phy_set_sym_pause - Configure symmetric Pause
2989 * @phydev: target phy_device struct
2990 * @rx: Receiver Pause is supported
2991 * @tx: Transmit Pause is supported
2992 * @autoneg: Auto neg should be used
2993 *
2994 * Description: Configure advertised Pause support depending on if
2995 * receiver pause and pause auto neg is supported. Generally called
2996 * from the set_pauseparam .ndo.
2997 */
2998 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2999 bool autoneg)
3000 {
3001 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
3002
3003 if (rx && tx && autoneg)
3004 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3005 phydev->supported);
3006
3007 linkmode_copy(phydev->advertising, phydev->supported);
3008 }
3009 EXPORT_SYMBOL(phy_set_sym_pause);
3010
3011 /**
3012 * phy_set_asym_pause - Configure Pause and Asym Pause
3013 * @phydev: target phy_device struct
3014 * @rx: Receiver Pause is supported
3015 * @tx: Transmit Pause is supported
3016 *
3017 * Description: Configure advertised Pause support depending on if
3018 * transmit and receiver pause is supported. If there has been a
3019 * change in adverting, trigger a new autoneg. Generally called from
3020 * the set_pauseparam .ndo.
3021 */
3022 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
3023 {
3024 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
3025
3026 linkmode_copy(oldadv, phydev->advertising);
3027 linkmode_set_pause(phydev->advertising, tx, rx);
3028
3029 if (!linkmode_equal(oldadv, phydev->advertising) &&
3030 phydev->autoneg)
3031 phy_start_aneg(phydev);
3032 }
3033 EXPORT_SYMBOL(phy_set_asym_pause);
3034
3035 /**
3036 * phy_validate_pause - Test if the PHY/MAC support the pause configuration
3037 * @phydev: phy_device struct
3038 * @pp: requested pause configuration
3039 *
3040 * Description: Test if the PHY/MAC combination supports the Pause
3041 * configuration the user is requesting. Returns True if it is
3042 * supported, false otherwise.
3043 */
3044 bool phy_validate_pause(struct phy_device *phydev,
3045 struct ethtool_pauseparam *pp)
3046 {
3047 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3048 phydev->supported) && pp->rx_pause)
3049 return false;
3050
3051 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3052 phydev->supported) &&
3053 pp->rx_pause != pp->tx_pause)
3054 return false;
3055
3056 return true;
3057 }
3058 EXPORT_SYMBOL(phy_validate_pause);
3059
3060 /**
3061 * phy_get_pause - resolve negotiated pause modes
3062 * @phydev: phy_device struct
3063 * @tx_pause: pointer to bool to indicate whether transmit pause should be
3064 * enabled.
3065 * @rx_pause: pointer to bool to indicate whether receive pause should be
3066 * enabled.
3067 *
3068 * Resolve and return the flow control modes according to the negotiation
3069 * result. This includes checking that we are operating in full duplex mode.
3070 * See linkmode_resolve_pause() for further details.
3071 */
3072 void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
3073 {
3074 if (phydev->duplex != DUPLEX_FULL) {
3075 *tx_pause = false;
3076 *rx_pause = false;
3077 return;
3078 }
3079
3080 return linkmode_resolve_pause(phydev->advertising,
3081 phydev->lp_advertising,
3082 tx_pause, rx_pause);
3083 }
3084 EXPORT_SYMBOL(phy_get_pause);
3085
3086 #if IS_ENABLED(CONFIG_OF_MDIO)
3087 static int phy_get_u32_property(struct device *dev, const char *name, u32 *val)
3088 {
3089 return device_property_read_u32(dev, name, val);
3090 }
3091 #else
3092 static int phy_get_u32_property(struct device *dev, const char *name, u32 *val)
3093 {
3094 return -EINVAL;
3095 }
3096 #endif
3097
3098 /**
3099 * phy_get_internal_delay - returns the index of the internal delay
3100 * @phydev: phy_device struct
3101 * @delay_values: array of delays the PHY supports
3102 * @size: the size of the delay array
3103 * @is_rx: boolean to indicate to get the rx internal delay
3104 *
3105 * Returns the index within the array of internal delay passed in.
3106 * If the device property is not present then the interface type is checked
3107 * if the interface defines use of internal delay then a 1 is returned otherwise
3108 * a 0 is returned.
3109 * The array must be in ascending order. If PHY does not have an ascending order
3110 * array then size = 0 and the value of the delay property is returned.
3111 * Return -EINVAL if the delay is invalid or cannot be found.
3112 */
3113 s32 phy_get_internal_delay(struct phy_device *phydev, const int *delay_values,
3114 int size, bool is_rx)
3115 {
3116 struct device *dev = &phydev->mdio.dev;
3117 int i, ret;
3118 u32 delay;
3119
3120 if (is_rx) {
3121 ret = phy_get_u32_property(dev, "rx-internal-delay-ps", &delay);
3122 if (ret < 0 && size == 0) {
3123 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3124 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
3125 return 1;
3126 else
3127 return 0;
3128 }
3129
3130 } else {
3131 ret = phy_get_u32_property(dev, "tx-internal-delay-ps", &delay);
3132 if (ret < 0 && size == 0) {
3133 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3134 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
3135 return 1;
3136 else
3137 return 0;
3138 }
3139 }
3140
3141 if (ret < 0)
3142 return ret;
3143
3144 if (size == 0)
3145 return delay;
3146
3147 if (delay < delay_values[0] || delay > delay_values[size - 1]) {
3148 phydev_err(phydev, "Delay %d is out of range\n", delay);
3149 return -EINVAL;
3150 }
3151
3152 if (delay == delay_values[0])
3153 return 0;
3154
3155 for (i = 1; i < size; i++) {
3156 if (delay == delay_values[i])
3157 return i;
3158
3159 /* Find an approximate index by looking up the table */
3160 if (delay > delay_values[i - 1] &&
3161 delay < delay_values[i]) {
3162 if (delay - delay_values[i - 1] <
3163 delay_values[i] - delay)
3164 return i - 1;
3165 else
3166 return i;
3167 }
3168 }
3169
3170 phydev_err(phydev, "error finding internal delay index for %d\n",
3171 delay);
3172
3173 return -EINVAL;
3174 }
3175 EXPORT_SYMBOL(phy_get_internal_delay);
3176
3177 /**
3178 * phy_get_tx_amplitude_gain - stores tx amplitude gain in @val
3179 * @phydev: phy_device struct
3180 * @dev: pointer to the devices device struct
3181 * @linkmode: linkmode for which the tx amplitude gain should be retrieved
3182 * @val: tx amplitude gain
3183 *
3184 * Returns: 0 on success, < 0 on failure
3185 */
3186 int phy_get_tx_amplitude_gain(struct phy_device *phydev, struct device *dev,
3187 enum ethtool_link_mode_bit_indices linkmode,
3188 u32 *val)
3189 {
3190 switch (linkmode) {
3191 case ETHTOOL_LINK_MODE_100baseT_Full_BIT:
3192 return phy_get_u32_property(dev,
3193 "tx-amplitude-100base-tx-percent",
3194 val);
3195 default:
3196 return -EINVAL;
3197 }
3198 }
3199 EXPORT_SYMBOL_GPL(phy_get_tx_amplitude_gain);
3200
3201 /**
3202 * phy_get_mac_termination - stores MAC termination in @val
3203 * @phydev: phy_device struct
3204 * @dev: pointer to the devices device struct
3205 * @val: MAC termination
3206 *
3207 * Returns: 0 on success, < 0 on failure
3208 */
3209 int phy_get_mac_termination(struct phy_device *phydev, struct device *dev,
3210 u32 *val)
3211 {
3212 return phy_get_u32_property(dev, "mac-termination-ohms", val);
3213 }
3214 EXPORT_SYMBOL_GPL(phy_get_mac_termination);
3215
3216 static int phy_led_set_brightness(struct led_classdev *led_cdev,
3217 enum led_brightness value)
3218 {
3219 struct phy_led *phyled = to_phy_led(led_cdev);
3220 struct phy_device *phydev = phyled->phydev;
3221 int err;
3222
3223 mutex_lock(&phydev->lock);
3224 err = phydev->drv->led_brightness_set(phydev, phyled->index, value);
3225 mutex_unlock(&phydev->lock);
3226
3227 return err;
3228 }
3229
3230 static int phy_led_blink_set(struct led_classdev *led_cdev,
3231 unsigned long *delay_on,
3232 unsigned long *delay_off)
3233 {
3234 struct phy_led *phyled = to_phy_led(led_cdev);
3235 struct phy_device *phydev = phyled->phydev;
3236 int err;
3237
3238 mutex_lock(&phydev->lock);
3239 err = phydev->drv->led_blink_set(phydev, phyled->index,
3240 delay_on, delay_off);
3241 mutex_unlock(&phydev->lock);
3242
3243 return err;
3244 }
3245
3246 static __maybe_unused struct device *
3247 phy_led_hw_control_get_device(struct led_classdev *led_cdev)
3248 {
3249 struct phy_led *phyled = to_phy_led(led_cdev);
3250 struct phy_device *phydev = phyled->phydev;
3251
3252 if (phydev->attached_dev)
3253 return &phydev->attached_dev->dev;
3254 return NULL;
3255 }
3256
3257 static int __maybe_unused
3258 phy_led_hw_control_get(struct led_classdev *led_cdev,
3259 unsigned long *rules)
3260 {
3261 struct phy_led *phyled = to_phy_led(led_cdev);
3262 struct phy_device *phydev = phyled->phydev;
3263 int err;
3264
3265 mutex_lock(&phydev->lock);
3266 err = phydev->drv->led_hw_control_get(phydev, phyled->index, rules);
3267 mutex_unlock(&phydev->lock);
3268
3269 return err;
3270 }
3271
3272 static int __maybe_unused
3273 phy_led_hw_control_set(struct led_classdev *led_cdev,
3274 unsigned long rules)
3275 {
3276 struct phy_led *phyled = to_phy_led(led_cdev);
3277 struct phy_device *phydev = phyled->phydev;
3278 int err;
3279
3280 mutex_lock(&phydev->lock);
3281 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules);
3282 mutex_unlock(&phydev->lock);
3283
3284 return err;
3285 }
3286
3287 static __maybe_unused int phy_led_hw_is_supported(struct led_classdev *led_cdev,
3288 unsigned long rules)
3289 {
3290 struct phy_led *phyled = to_phy_led(led_cdev);
3291 struct phy_device *phydev = phyled->phydev;
3292 int err;
3293
3294 mutex_lock(&phydev->lock);
3295 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules);
3296 mutex_unlock(&phydev->lock);
3297
3298 return err;
3299 }
3300
3301 static void phy_leds_unregister(struct phy_device *phydev)
3302 {
3303 struct phy_led *phyled, *tmp;
3304
3305 list_for_each_entry_safe(phyled, tmp, &phydev->leds, list) {
3306 led_classdev_unregister(&phyled->led_cdev);
3307 list_del(&phyled->list);
3308 }
3309 }
3310
3311 static int of_phy_led(struct phy_device *phydev,
3312 struct device_node *led)
3313 {
3314 struct device *dev = &phydev->mdio.dev;
3315 struct led_init_data init_data = {};
3316 struct led_classdev *cdev;
3317 unsigned long modes = 0;
3318 struct phy_led *phyled;
3319 u32 index;
3320 int err;
3321
3322 phyled = devm_kzalloc(dev, sizeof(*phyled), GFP_KERNEL);
3323 if (!phyled)
3324 return -ENOMEM;
3325
3326 cdev = &phyled->led_cdev;
3327 phyled->phydev = phydev;
3328
3329 err = of_property_read_u32(led, "reg", &index);
3330 if (err)
3331 return err;
3332 if (index > U8_MAX)
3333 return -EINVAL;
3334
3335 if (of_property_read_bool(led, "active-high"))
3336 set_bit(PHY_LED_ACTIVE_HIGH, &modes);
3337 if (of_property_read_bool(led, "active-low"))
3338 set_bit(PHY_LED_ACTIVE_LOW, &modes);
3339 if (of_property_read_bool(led, "inactive-high-impedance"))
3340 set_bit(PHY_LED_INACTIVE_HIGH_IMPEDANCE, &modes);
3341
3342 if (WARN_ON(modes & BIT(PHY_LED_ACTIVE_LOW) &&
3343 modes & BIT(PHY_LED_ACTIVE_HIGH)))
3344 return -EINVAL;
3345
3346 if (modes) {
3347 /* Return error if asked to set polarity modes but not supported */
3348 if (!phydev->drv->led_polarity_set)
3349 return -EINVAL;
3350
3351 err = phydev->drv->led_polarity_set(phydev, index, modes);
3352 if (err)
3353 return err;
3354 }
3355
3356 phyled->index = index;
3357 if (phydev->drv->led_brightness_set)
3358 cdev->brightness_set_blocking = phy_led_set_brightness;
3359 if (phydev->drv->led_blink_set)
3360 cdev->blink_set = phy_led_blink_set;
3361
3362 #ifdef CONFIG_LEDS_TRIGGERS
3363 if (phydev->drv->led_hw_is_supported &&
3364 phydev->drv->led_hw_control_set &&
3365 phydev->drv->led_hw_control_get) {
3366 cdev->hw_control_is_supported = phy_led_hw_is_supported;
3367 cdev->hw_control_set = phy_led_hw_control_set;
3368 cdev->hw_control_get = phy_led_hw_control_get;
3369 cdev->hw_control_trigger = "netdev";
3370 }
3371
3372 cdev->hw_control_get_device = phy_led_hw_control_get_device;
3373 #endif
3374 cdev->max_brightness = 1;
3375 init_data.devicename = dev_name(&phydev->mdio.dev);
3376 init_data.fwnode = of_fwnode_handle(led);
3377 init_data.devname_mandatory = true;
3378
3379 err = led_classdev_register_ext(dev, cdev, &init_data);
3380 if (err)
3381 return err;
3382
3383 list_add(&phyled->list, &phydev->leds);
3384
3385 return 0;
3386 }
3387
3388 static int of_phy_leds(struct phy_device *phydev)
3389 {
3390 struct device_node *node = phydev->mdio.dev.of_node;
3391 struct device_node *leds;
3392 int err;
3393
3394 if (!IS_ENABLED(CONFIG_OF_MDIO))
3395 return 0;
3396
3397 if (!node)
3398 return 0;
3399
3400 leds = of_get_child_by_name(node, "leds");
3401 if (!leds)
3402 return 0;
3403
3404 /* Check if the PHY driver have at least an OP to
3405 * set the LEDs.
3406 */
3407 if (!(phydev->drv->led_brightness_set ||
3408 phydev->drv->led_blink_set ||
3409 phydev->drv->led_hw_control_set)) {
3410 phydev_dbg(phydev, "ignoring leds node defined with no PHY driver support\n");
3411 goto exit;
3412 }
3413
3414 for_each_available_child_of_node_scoped(leds, led) {
3415 err = of_phy_led(phydev, led);
3416 if (err) {
3417 of_node_put(leds);
3418 phy_leds_unregister(phydev);
3419 return err;
3420 }
3421 }
3422
3423 exit:
3424 of_node_put(leds);
3425 return 0;
3426 }
3427
3428 static void phy_cleanup_ports(struct phy_device *phydev)
3429 {
3430 struct phy_port *tmp, *port;
3431
3432 list_for_each_entry_safe(port, tmp, &phydev->ports, head) {
3433 phy_del_port(phydev, port);
3434 phy_port_destroy(port);
3435 }
3436 }
3437
3438 static int phy_default_setup_single_port(struct phy_device *phydev)
3439 {
3440 struct phy_port *port = phy_port_alloc();
3441 unsigned long mode;
3442
3443 if (!port)
3444 return -ENOMEM;
3445
3446 port->parent_type = PHY_PORT_PHY;
3447 port->phy = phydev;
3448
3449 /* Let the PHY driver know that this port was never described anywhere.
3450 * This is the usual case, where we assume single-port PHY devices with
3451 * no SFP. In that case, the port supports exactly the same thing as
3452 * the PHY itself.
3453 *
3454 * However, this can also be because we have a combo-port PHY, with
3455 * only one port described in DT, through SFP for example.
3456 *
3457 * In that case, the PHY driver will be in charge of saying what we can
3458 * do on that non-represented port.
3459 */
3460 port->not_described = true;
3461 linkmode_copy(port->supported, phydev->supported);
3462 port->mediums = phy_caps_mediums_from_linkmodes(port->supported);
3463
3464 for_each_set_bit(mode, port->supported, __ETHTOOL_LINK_MODE_MASK_NBITS)
3465 port->pairs = max_t(int, port->pairs,
3466 ethtool_linkmode_n_pairs(mode));
3467
3468 phy_add_port(phydev, port);
3469
3470 return 0;
3471 }
3472
3473 static int of_phy_ports(struct phy_device *phydev)
3474 {
3475 struct device_node *node = phydev->mdio.dev.of_node;
3476 struct device_node *mdi;
3477 struct phy_port *port;
3478 int err;
3479
3480 if (!IS_ENABLED(CONFIG_OF_MDIO))
3481 return 0;
3482
3483 if (!node)
3484 return 0;
3485
3486 mdi = of_get_child_by_name(node, "mdi");
3487 if (!mdi)
3488 return 0;
3489
3490 for_each_available_child_of_node_scoped(mdi, port_node) {
3491 port = phy_of_parse_port(port_node);
3492 if (IS_ERR(port)) {
3493 err = PTR_ERR(port);
3494 goto out_err;
3495 }
3496
3497 port->parent_type = PHY_PORT_PHY;
3498 port->phy = phydev;
3499
3500 linkmode_copy(port->supported, phydev->supported);
3501
3502 err = phy_add_port(phydev, port);
3503 if (err) {
3504 phy_port_destroy(port);
3505 goto out_err;
3506 }
3507 }
3508 of_node_put(mdi);
3509
3510 return 0;
3511
3512 out_err:
3513 phy_cleanup_ports(phydev);
3514 of_node_put(mdi);
3515 return err;
3516 }
3517
3518 static int phy_setup_ports(struct phy_device *phydev)
3519 {
3520 __ETHTOOL_DECLARE_LINK_MODE_MASK(ports_supported);
3521 struct phy_port *port;
3522 int ret;
3523
3524 ret = of_phy_ports(phydev);
3525 if (ret)
3526 return ret;
3527
3528 ret = phy_sfp_probe(phydev);
3529 if (ret)
3530 goto out;
3531
3532 if (phydev->n_ports < phydev->max_n_ports) {
3533 ret = phy_default_setup_single_port(phydev);
3534 if (ret)
3535 goto out;
3536 }
3537
3538 linkmode_zero(ports_supported);
3539
3540 /* Aggregate the supported modes, which are made-up of :
3541 * - What the PHY itself supports
3542 * - What the sum of all ports support
3543 */
3544 list_for_each_entry(port, &phydev->ports, head)
3545 if (port->active)
3546 linkmode_or(ports_supported, ports_supported,
3547 port->supported);
3548
3549 if (!linkmode_empty(ports_supported))
3550 linkmode_and(phydev->supported, phydev->supported,
3551 ports_supported);
3552
3553 /* For now, the phy->port field is set as the first active port's type */
3554 list_for_each_entry(port, &phydev->ports, head)
3555 if (port->active) {
3556 phydev->port = phy_port_get_type(port);
3557 break;
3558 }
3559
3560 return 0;
3561
3562 out:
3563 phy_cleanup_ports(phydev);
3564 return ret;
3565 }
3566
3567 /**
3568 * phy_get_sfp_port() - Returns the first valid SFP port of a PHY
3569 * @phydev: pointer to the PHY device to get the SFP port from
3570 *
3571 * Returns: The first active SFP (serdes) port of a PHY device, NULL if none
3572 * exist.
3573 */
3574 struct phy_port *phy_get_sfp_port(struct phy_device *phydev)
3575 {
3576 struct phy_port *port;
3577
3578 list_for_each_entry(port, &phydev->ports, head)
3579 if (port->active && port->is_sfp)
3580 return port;
3581
3582 return NULL;
3583 }
3584 EXPORT_SYMBOL_GPL(phy_get_sfp_port);
3585
3586 /**
3587 * fwnode_mdio_find_device - Given a fwnode, find the mdio_device
3588 * @fwnode: pointer to the mdio_device's fwnode
3589 *
3590 * If successful, returns a pointer to the mdio_device with the embedded
3591 * struct device refcount incremented by one, or NULL on failure.
3592 * The caller should call put_device() on the mdio_device after its use.
3593 */
3594 struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode)
3595 {
3596 struct device *d;
3597
3598 if (!fwnode)
3599 return NULL;
3600
3601 d = bus_find_device_by_fwnode(&mdio_bus_type, fwnode);
3602 if (!d)
3603 return NULL;
3604
3605 return to_mdio_device(d);
3606 }
3607 EXPORT_SYMBOL(fwnode_mdio_find_device);
3608
3609 /**
3610 * fwnode_phy_find_device - For provided phy_fwnode, find phy_device.
3611 *
3612 * @phy_fwnode: Pointer to the phy's fwnode.
3613 *
3614 * If successful, returns a pointer to the phy_device with the embedded
3615 * struct device refcount incremented by one, or NULL on failure.
3616 */
3617 struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode)
3618 {
3619 struct mdio_device *mdiodev;
3620
3621 mdiodev = fwnode_mdio_find_device(phy_fwnode);
3622 if (!mdiodev)
3623 return NULL;
3624
3625 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
3626 return to_phy_device(&mdiodev->dev);
3627
3628 put_device(&mdiodev->dev);
3629
3630 return NULL;
3631 }
3632 EXPORT_SYMBOL(fwnode_phy_find_device);
3633
3634 /**
3635 * fwnode_get_phy_node - Get the phy_node using the named reference.
3636 * @fwnode: Pointer to fwnode from which phy_node has to be obtained.
3637 *
3638 * Refer return conditions of fwnode_find_reference().
3639 * For ACPI, only "phy-handle" is supported. Legacy DT properties "phy"
3640 * and "phy-device" are not supported in ACPI. DT supports all the three
3641 * named references to the phy node.
3642 */
3643 struct fwnode_handle *fwnode_get_phy_node(const struct fwnode_handle *fwnode)
3644 {
3645 struct fwnode_handle *phy_node;
3646
3647 /* Only phy-handle is used for ACPI */
3648 phy_node = fwnode_find_reference(fwnode, "phy-handle", 0);
3649 if (!IS_ERR(phy_node) || is_acpi_node(fwnode))
3650 return phy_node;
3651 phy_node = fwnode_find_reference(fwnode, "phy", 0);
3652 if (!IS_ERR(phy_node))
3653 return phy_node;
3654 return fwnode_find_reference(fwnode, "phy-device", 0);
3655 }
3656 EXPORT_SYMBOL_GPL(fwnode_get_phy_node);
3657
3658 /**
3659 * phy_probe - probe and init a PHY device
3660 * @dev: device to probe and init
3661 *
3662 * Take care of setting up the phy_device structure, set the state to READY.
3663 */
3664 static int phy_probe(struct device *dev)
3665 {
3666 struct phy_device *phydev = to_phy_device(dev);
3667 struct device_driver *drv = phydev->mdio.dev.driver;
3668 struct phy_driver *phydrv = to_phy_driver(drv);
3669 int err = 0;
3670
3671 phydev->drv = phydrv;
3672
3673 /* Disable the interrupt if the PHY doesn't support it
3674 * but the interrupt is still a valid one
3675 */
3676 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
3677 phydev->irq = PHY_POLL;
3678
3679 if (phydrv->flags & PHY_IS_INTERNAL)
3680 phydev->is_internal = true;
3681
3682 /* Deassert the reset signal */
3683 phy_device_reset(phydev, 0);
3684
3685 if (phydev->drv->probe) {
3686 err = phydev->drv->probe(phydev);
3687 if (err)
3688 goto out;
3689 }
3690
3691 phy_disable_interrupts(phydev);
3692
3693 /* Start out supporting everything. Eventually,
3694 * a controller will attach, and may modify one
3695 * or both of these values
3696 */
3697 if (phydrv->features) {
3698 linkmode_copy(phydev->supported, phydrv->features);
3699 genphy_c45_read_eee_abilities(phydev);
3700 }
3701 else if (phydrv->get_features)
3702 err = phydrv->get_features(phydev);
3703 else if (phydev->is_c45)
3704 err = genphy_c45_pma_read_abilities(phydev);
3705 else
3706 err = genphy_read_abilities(phydev);
3707
3708 if (err)
3709 goto out;
3710
3711 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
3712 phydev->supported))
3713 phydev->autoneg = 0;
3714
3715 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
3716 phydev->supported))
3717 phydev->is_gigabit_capable = 1;
3718 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
3719 phydev->supported))
3720 phydev->is_gigabit_capable = 1;
3721
3722 of_set_phy_supported(phydev);
3723
3724 err = phy_setup_ports(phydev);
3725 if (err)
3726 goto out;
3727
3728 phy_advertise_supported(phydev);
3729
3730 /* Get PHY default EEE advertising modes and handle them as potentially
3731 * safe initial configuration.
3732 */
3733 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee);
3734 if (err)
3735 goto out;
3736
3737 /* Get the EEE modes we want to prohibit. */
3738 of_set_phy_eee_broken(phydev);
3739
3740 /* Some PHYs may advertise, by default, not support EEE modes. So,
3741 * we need to clean them. In addition remove all disabled EEE modes.
3742 */
3743 linkmode_and(phydev->advertising_eee, phydev->supported_eee,
3744 phydev->advertising_eee);
3745 linkmode_andnot(phydev->advertising_eee, phydev->advertising_eee,
3746 phydev->eee_disabled_modes);
3747
3748 /* There is no "enabled" flag. If PHY is advertising, assume it is
3749 * kind of enabled.
3750 */
3751 phydev->eee_cfg.eee_enabled = !linkmode_empty(phydev->advertising_eee);
3752
3753 /* Get master/slave strap overrides */
3754 of_set_phy_timing_role(phydev);
3755
3756 /* The Pause Frame bits indicate that the PHY can support passing
3757 * pause frames. During autonegotiation, the PHYs will determine if
3758 * they should allow pause frames to pass. The MAC driver should then
3759 * use that result to determine whether to enable flow control via
3760 * pause frames.
3761 *
3762 * Normally, PHY drivers should not set the Pause bits, and instead
3763 * allow phylib to do that. However, there may be some situations
3764 * (e.g. hardware erratum) where the driver wants to set only one
3765 * of these bits.
3766 */
3767 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
3768 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
3769 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3770 phydev->supported);
3771 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3772 phydev->supported);
3773 }
3774
3775 /* Set the state to READY by default */
3776 phydev->state = PHY_READY;
3777
3778 /* Register the PHY LED triggers */
3779 if (!phydev->is_on_sfp_module)
3780 phy_led_triggers_register(phydev);
3781
3782 /* Get the LEDs from the device tree, and instantiate standard
3783 * LEDs for them.
3784 */
3785 if (IS_ENABLED(CONFIG_PHYLIB_LEDS) && !phy_driver_is_genphy(phydev)) {
3786 err = of_phy_leds(phydev);
3787 if (err)
3788 goto out;
3789 }
3790
3791 return 0;
3792
3793 out:
3794 if (!phydev->is_on_sfp_module)
3795 phy_led_triggers_unregister(phydev);
3796
3797 /* Re-assert the reset signal on error */
3798 phy_device_reset(phydev, 1);
3799
3800 return err;
3801 }
3802
3803 static int phy_remove(struct device *dev)
3804 {
3805 struct phy_device *phydev = to_phy_device(dev);
3806
3807 cancel_delayed_work_sync(&phydev->state_queue);
3808
3809 if (IS_ENABLED(CONFIG_PHYLIB_LEDS) && !phy_driver_is_genphy(phydev))
3810 phy_leds_unregister(phydev);
3811
3812 if (!phydev->is_on_sfp_module)
3813 phy_led_triggers_unregister(phydev);
3814
3815 phydev->state = PHY_DOWN;
3816
3817 phy_cleanup_ports(phydev);
3818
3819 sfp_bus_del_upstream(phydev->sfp_bus);
3820 phydev->sfp_bus = NULL;
3821
3822 if (phydev->drv && phydev->drv->remove)
3823 phydev->drv->remove(phydev);
3824
3825 /* Assert the reset signal */
3826 phy_device_reset(phydev, 1);
3827
3828 phydev->drv = NULL;
3829
3830 return 0;
3831 }
3832
3833 /**
3834 * phy_driver_register - register a phy_driver with the PHY layer
3835 * @new_driver: new phy_driver to register
3836 * @owner: module owning this PHY
3837 */
3838 static int phy_driver_register(struct phy_driver *new_driver,
3839 struct module *owner)
3840 {
3841 int retval;
3842
3843 /* Either the features are hard coded, or dynamically
3844 * determined. It cannot be both.
3845 */
3846 if (WARN_ON(new_driver->features && new_driver->get_features)) {
3847 pr_err("%s: features and get_features must not both be set\n",
3848 new_driver->name);
3849 return -EINVAL;
3850 }
3851
3852 /* PHYLIB device drivers must not match using a DT compatible table
3853 * as this bypasses our checks that the mdiodev that is being matched
3854 * is backed by a struct phy_device. If such a case happens, we will
3855 * make out-of-bounds accesses and lockup in phydev->lock.
3856 */
3857 if (WARN(new_driver->mdiodrv.driver.of_match_table,
3858 "%s: driver must not provide a DT match table\n",
3859 new_driver->name))
3860 return -EINVAL;
3861
3862 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
3863 new_driver->mdiodrv.driver.name = new_driver->name;
3864 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
3865 new_driver->mdiodrv.driver.probe = phy_probe;
3866 new_driver->mdiodrv.driver.remove = phy_remove;
3867 new_driver->mdiodrv.driver.owner = owner;
3868 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
3869
3870 retval = driver_register(&new_driver->mdiodrv.driver);
3871 if (retval) {
3872 pr_err("%s: Error %d in registering driver\n",
3873 new_driver->name, retval);
3874
3875 return retval;
3876 }
3877
3878 pr_debug("%s: Registered new driver\n", new_driver->name);
3879
3880 return 0;
3881 }
3882
3883 static void phy_driver_unregister(struct phy_driver *drv)
3884 {
3885 driver_unregister(&drv->mdiodrv.driver);
3886 }
3887
3888 int phy_drivers_register(struct phy_driver *new_driver, int n,
3889 struct module *owner)
3890 {
3891 int i, ret = 0;
3892
3893 for (i = 0; i < n; i++) {
3894 ret = phy_driver_register(new_driver + i, owner);
3895 if (ret) {
3896 while (i-- > 0)
3897 phy_driver_unregister(new_driver + i);
3898 break;
3899 }
3900 }
3901 return ret;
3902 }
3903 EXPORT_SYMBOL(phy_drivers_register);
3904
3905 void phy_drivers_unregister(struct phy_driver *drv, int n)
3906 {
3907 int i;
3908
3909 for (i = 0; i < n; i++)
3910 phy_driver_unregister(drv + i);
3911 }
3912 EXPORT_SYMBOL(phy_drivers_unregister);
3913
3914 static struct phy_driver genphy_driver = {
3915 .phy_id = 0xffffffff,
3916 .phy_id_mask = 0xffffffff,
3917 .name = "Generic PHY",
3918 .get_features = genphy_read_abilities,
3919 .suspend = genphy_suspend,
3920 .resume = genphy_resume,
3921 .set_loopback = genphy_loopback,
3922 };
3923
3924 static const struct ethtool_phy_ops phy_ethtool_phy_ops = {
3925 .get_sset_count = phy_ethtool_get_sset_count,
3926 .get_strings = phy_ethtool_get_strings,
3927 .get_stats = phy_ethtool_get_stats,
3928 .get_plca_cfg = phy_ethtool_get_plca_cfg,
3929 .set_plca_cfg = phy_ethtool_set_plca_cfg,
3930 .get_plca_status = phy_ethtool_get_plca_status,
3931 .start_cable_test = phy_start_cable_test,
3932 .start_cable_test_tdr = phy_start_cable_test_tdr,
3933 };
3934
3935 static const struct phylib_stubs __phylib_stubs = {
3936 .hwtstamp_get = __phy_hwtstamp_get,
3937 .hwtstamp_set = __phy_hwtstamp_set,
3938 .get_phy_stats = __phy_ethtool_get_phy_stats,
3939 .get_link_ext_stats = __phy_ethtool_get_link_ext_stats,
3940 };
3941
3942 static void phylib_register_stubs(void)
3943 {
3944 phylib_stubs = &__phylib_stubs;
3945 }
3946
3947 static void phylib_unregister_stubs(void)
3948 {
3949 phylib_stubs = NULL;
3950 }
3951
3952 static int __init phy_init(void)
3953 {
3954 int rc;
3955
3956 rtnl_lock();
3957 ethtool_set_ethtool_phy_ops(&phy_ethtool_phy_ops);
3958 phylib_register_stubs();
3959 rtnl_unlock();
3960
3961 rc = phy_caps_init();
3962 if (rc)
3963 goto err_ethtool_phy_ops;
3964
3965 features_init();
3966
3967 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
3968 if (rc)
3969 goto err_ethtool_phy_ops;
3970
3971 rc = phy_driver_register(&genphy_driver, THIS_MODULE);
3972 if (rc)
3973 goto err_c45;
3974
3975 return 0;
3976
3977 err_c45:
3978 phy_driver_unregister(&genphy_c45_driver);
3979 err_ethtool_phy_ops:
3980 rtnl_lock();
3981 phylib_unregister_stubs();
3982 ethtool_set_ethtool_phy_ops(NULL);
3983 rtnl_unlock();
3984
3985 return rc;
3986 }
3987
3988 static void __exit phy_exit(void)
3989 {
3990 phy_driver_unregister(&genphy_c45_driver);
3991 phy_driver_unregister(&genphy_driver);
3992 rtnl_lock();
3993 phylib_unregister_stubs();
3994 ethtool_set_ethtool_phy_ops(NULL);
3995 rtnl_unlock();
3996 }
3997
3998 subsys_initcall(phy_init);
3999 module_exit(phy_exit);