projects/linux·blob master · refs

4038 lines · 106.3 KiB

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
48MODULE_DESCRIPTION("PHY library");
49MODULE_AUTHOR("Andy Fleming");
50MODULE_LICENSE("GPL");
51
52struct 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
60static 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;
68EXPORT_SYMBOL_GPL(phy_basic_features);
69
70__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
71EXPORT_SYMBOL_GPL(phy_basic_t1_features);
72
73__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1s_p2mp_features) __ro_after_init;
74EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features);
75
76__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
77EXPORT_SYMBOL_GPL(phy_gbit_features);
78
79__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
80EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
81
82__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
83EXPORT_SYMBOL_GPL(phy_10gbit_features);
84
85const 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};
90EXPORT_SYMBOL_GPL(phy_basic_ports_array);
91
92static 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
102static 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
109static 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
115static 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
120static const int phy_gbit_features_array[2] __initconst = {
121 ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
122 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
123};
124
125static 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;
135EXPORT_SYMBOL_GPL(phy_eee_cap1_features);
136
137static 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;
143EXPORT_SYMBOL_GPL(phy_eee_cap2_features);
144
145static 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
210void phy_device_free(struct phy_device *phydev)
211{
212 put_device(&phydev->mdio.dev);
213}
214EXPORT_SYMBOL(phy_device_free);
215
216static 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
224static void phy_device_release(struct device *dev)
225{
226 fwnode_handle_put(dev->fwnode);
227 kfree(to_phy_device(dev));
228}
229
230static 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
238static struct phy_driver genphy_driver;
239
240static LIST_HEAD(phy_fixup_list);
241static DEFINE_MUTEX(phy_fixup_lock);
242
243static 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
252bool 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}
260EXPORT_SYMBOL_GPL(phy_may_wakeup);
261
262static 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 */
293static 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
301static 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
342out:
343 return !phydev->suspended;
344}
345
346static __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
378static __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;
406no_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
427static 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 */
438static 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 */
460int 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}
465EXPORT_SYMBOL(phy_register_fixup_for_uid);
466
467/* Registers a fixup to be run on the PHY with id string bus_id */
468int 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}
473EXPORT_SYMBOL(phy_register_fixup_for_id);
474
475static 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 */
488static 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 */
522int 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}
544EXPORT_SYMBOL_GPL(genphy_match_phy_device);
545
546static 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
560static ssize_t
561phy_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}
567static DEVICE_ATTR_RO(phy_id);
568
569static ssize_t
570phy_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}
582static DEVICE_ATTR_RO(phy_interface);
583
584static ssize_t
585phy_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}
592static DEVICE_ATTR_RO(phy_has_fixups);
593
594static 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}
602static DEVICE_ATTR_RO(phy_dev_flags);
603
604static 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
612static const struct attribute_group phy_dev_group = {
613 .attrs = phy_dev_attrs,
614};
615
616#define MMD_DEVICE_ID_ATTR(n) \
617static 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} \
624static DEVICE_ATTR_RO(mmd##n##_device_id)
625
626MMD_DEVICE_ID_ATTR(1);
627MMD_DEVICE_ID_ATTR(2);
628MMD_DEVICE_ID_ATTR(3);
629MMD_DEVICE_ID_ATTR(4);
630MMD_DEVICE_ID_ATTR(5);
631MMD_DEVICE_ID_ATTR(6);
632MMD_DEVICE_ID_ATTR(7);
633MMD_DEVICE_ID_ATTR(8);
634MMD_DEVICE_ID_ATTR(9);
635MMD_DEVICE_ID_ATTR(10);
636MMD_DEVICE_ID_ATTR(11);
637MMD_DEVICE_ID_ATTR(12);
638MMD_DEVICE_ID_ATTR(13);
639MMD_DEVICE_ID_ATTR(14);
640MMD_DEVICE_ID_ATTR(15);
641MMD_DEVICE_ID_ATTR(16);
642MMD_DEVICE_ID_ATTR(17);
643MMD_DEVICE_ID_ATTR(18);
644MMD_DEVICE_ID_ATTR(19);
645MMD_DEVICE_ID_ATTR(20);
646MMD_DEVICE_ID_ATTR(21);
647MMD_DEVICE_ID_ATTR(22);
648MMD_DEVICE_ID_ATTR(23);
649MMD_DEVICE_ID_ATTR(24);
650MMD_DEVICE_ID_ATTR(25);
651MMD_DEVICE_ID_ATTR(26);
652MMD_DEVICE_ID_ATTR(27);
653MMD_DEVICE_ID_ATTR(28);
654MMD_DEVICE_ID_ATTR(29);
655MMD_DEVICE_ID_ATTR(30);
656MMD_DEVICE_ID_ATTR(31);
657
658static 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
693static 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
709static 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
715static const struct attribute_group *phy_device_groups[] = {
716 &phy_dev_group,
717 &phy_mmd_group,
718 NULL,
719};
720
721static 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
728static 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
748struct 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}
840EXPORT_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 */
853static 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 */
875static 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 */
906static 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 */
1002static 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 */
1034int 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}
1050EXPORT_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 */
1071struct 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}
1103EXPORT_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 */
1109int 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}
1142EXPORT_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 */
1152void 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}
1164EXPORT_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 */
1173int 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}
1178EXPORT_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 */
1187struct 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}
1198EXPORT_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 */
1212static 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 */
1225int 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}
1244EXPORT_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 */
1261struct 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}
1286EXPORT_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 */
1293void 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}
1305EXPORT_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 */
1325static 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
1341int 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 /* Re-apply autonomous EEE disable after soft reset */
1379 if (phydev->autonomous_eee_disabled &&
1380 phydev->drv->disable_autonomous_eee) {
1381 ret = phydev->drv->disable_autonomous_eee(phydev);
1382 if (ret)
1383 return ret;
1384 }
1385
1386 return 0;
1387}
1388EXPORT_SYMBOL(phy_init_hw);
1389
1390void phy_attached_info(struct phy_device *phydev)
1391{
1392 phy_attached_print(phydev, NULL);
1393}
1394EXPORT_SYMBOL(phy_attached_info);
1395
1396#define ATTACHED_FMT "attached PHY driver %s(mii_bus:phy_addr=%s, irq=%s)"
1397char *phy_attached_info_irq(struct phy_device *phydev)
1398{
1399 char *irq_str;
1400 char irq_num[8];
1401
1402 switch(phydev->irq) {
1403 case PHY_POLL:
1404 irq_str = "POLL";
1405 break;
1406 case PHY_MAC_INTERRUPT:
1407 irq_str = "MAC";
1408 break;
1409 default:
1410 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1411 irq_str = irq_num;
1412 break;
1413 }
1414
1415 return kasprintf(GFP_KERNEL, "%s", irq_str);
1416}
1417EXPORT_SYMBOL(phy_attached_info_irq);
1418
1419void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1420{
1421 const char *unbound = phydev->drv ? "" : "[unbound] ";
1422 char *irq_str = phy_attached_info_irq(phydev);
1423
1424 if (!fmt) {
1425 phydev_info(phydev, ATTACHED_FMT "\n", unbound,
1426 phydev_name(phydev), irq_str);
1427 } else {
1428 va_list ap;
1429
1430 phydev_info(phydev, ATTACHED_FMT, unbound,
1431 phydev_name(phydev), irq_str);
1432
1433 va_start(ap, fmt);
1434 vprintk(fmt, ap);
1435 va_end(ap);
1436 }
1437 kfree(irq_str);
1438}
1439EXPORT_SYMBOL(phy_attached_print);
1440
1441static void phy_sysfs_create_links(struct phy_device *phydev)
1442{
1443 struct net_device *dev = phydev->attached_dev;
1444 int err;
1445
1446 if (!dev)
1447 return;
1448
1449 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1450 "attached_dev");
1451 if (err)
1452 return;
1453
1454 err = sysfs_create_link_nowarn(&dev->dev.kobj,
1455 &phydev->mdio.dev.kobj,
1456 "phydev");
1457 if (err) {
1458 dev_err(&dev->dev, "could not add device link to %s err %d\n",
1459 kobject_name(&phydev->mdio.dev.kobj),
1460 err);
1461 /* non-fatal - some net drivers can use one netdevice
1462 * with more then one phy
1463 */
1464 }
1465
1466 phydev->sysfs_links = true;
1467}
1468
1469static ssize_t
1470phy_standalone_show(struct device *dev, struct device_attribute *attr,
1471 char *buf)
1472{
1473 struct phy_device *phydev = to_phy_device(dev);
1474
1475 return sysfs_emit(buf, "%d\n", !phydev->attached_dev);
1476}
1477static DEVICE_ATTR_RO(phy_standalone);
1478
1479/**
1480 * phy_sfp_connect_phy - Connect the SFP module's PHY to the upstream PHY
1481 * @upstream: pointer to the upstream phy device
1482 * @phy: pointer to the SFP module's phy device
1483 *
1484 * This helper allows keeping track of PHY devices on the link. It adds the
1485 * SFP module's phy to the phy namespace of the upstream phy
1486 *
1487 * Return: 0 on success, otherwise a negative error code.
1488 */
1489static int phy_sfp_connect_phy(void *upstream, struct phy_device *phy)
1490{
1491 struct phy_device *phydev = upstream;
1492 struct net_device *dev = phydev->attached_dev;
1493
1494 if (dev)
1495 return phy_link_topo_add_phy(dev, phy, PHY_UPSTREAM_PHY, phydev);
1496
1497 return 0;
1498}
1499
1500/**
1501 * phy_sfp_disconnect_phy - Disconnect the SFP module's PHY from the upstream PHY
1502 * @upstream: pointer to the upstream phy device
1503 * @phy: pointer to the SFP module's phy device
1504 *
1505 * This helper allows keeping track of PHY devices on the link. It removes the
1506 * SFP module's phy to the phy namespace of the upstream phy. As the module phy
1507 * will be destroyed, re-inserting the same module will add a new phy with a
1508 * new index.
1509 */
1510static void phy_sfp_disconnect_phy(void *upstream, struct phy_device *phy)
1511{
1512 struct phy_device *phydev = upstream;
1513 struct net_device *dev = phydev->attached_dev;
1514
1515 if (dev)
1516 phy_link_topo_del_phy(dev, phy);
1517}
1518
1519/**
1520 * phy_sfp_attach - attach the SFP bus to the PHY upstream network device
1521 * @upstream: pointer to the phy device
1522 * @bus: sfp bus representing cage being attached
1523 *
1524 * This is used to fill in the sfp_upstream_ops .attach member.
1525 */
1526static void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
1527{
1528 struct phy_device *phydev = upstream;
1529
1530 if (phydev->attached_dev)
1531 phydev->attached_dev->sfp_bus = bus;
1532 phydev->sfp_bus_attached = true;
1533}
1534
1535/**
1536 * phy_sfp_detach - detach the SFP bus from the PHY upstream network device
1537 * @upstream: pointer to the phy device
1538 * @bus: sfp bus representing cage being attached
1539 *
1540 * This is used to fill in the sfp_upstream_ops .detach member.
1541 */
1542static void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
1543{
1544 struct phy_device *phydev = upstream;
1545
1546 if (phydev->attached_dev)
1547 phydev->attached_dev->sfp_bus = NULL;
1548 phydev->sfp_bus_attached = false;
1549}
1550
1551static int phy_sfp_module_insert(void *upstream, const struct sfp_eeprom_id *id)
1552{
1553 __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support);
1554 struct phy_device *phydev = upstream;
1555 const struct sfp_module_caps *caps;
1556 struct phy_port *port;
1557
1558 phy_interface_t iface;
1559
1560 linkmode_zero(sfp_support);
1561
1562 port = phy_get_sfp_port(phydev);
1563 if (!port)
1564 return -EINVAL;
1565
1566 caps = sfp_get_module_caps(phydev->sfp_bus);
1567
1568 linkmode_and(sfp_support, port->supported, caps->link_modes);
1569 if (linkmode_empty(sfp_support)) {
1570 dev_err(&phydev->mdio.dev, "incompatible SFP module inserted, no common linkmode\n");
1571 return -EINVAL;
1572 }
1573
1574 iface = sfp_select_interface(phydev->sfp_bus, sfp_support);
1575 if (iface == PHY_INTERFACE_MODE_NA) {
1576 dev_err(&phydev->mdio.dev, "PHY %s does not support the SFP module's requested MII interfaces\n",
1577 phydev_name(phydev));
1578 return -EINVAL;
1579 }
1580
1581 if (phydev->n_ports == 1)
1582 phydev->port = caps->port;
1583
1584 if (port->ops && port->ops->configure_mii)
1585 return port->ops->configure_mii(port, true, iface);
1586
1587 return 0;
1588}
1589
1590static void phy_sfp_module_remove(void *upstream)
1591{
1592 struct phy_device *phydev = upstream;
1593 struct phy_port *port = phy_get_sfp_port(phydev);
1594
1595 if (port && port->ops && port->ops->configure_mii)
1596 port->ops->configure_mii(port, false, PHY_INTERFACE_MODE_NA);
1597
1598 if (phydev->n_ports == 1)
1599 phydev->port = PORT_NONE;
1600}
1601
1602static void phy_sfp_link_up(void *upstream)
1603{
1604 struct phy_device *phydev = upstream;
1605 struct phy_port *port = phy_get_sfp_port(phydev);
1606
1607 if (port && port->ops && port->ops->link_up)
1608 port->ops->link_up(port);
1609}
1610
1611static void phy_sfp_link_down(void *upstream)
1612{
1613 struct phy_device *phydev = upstream;
1614 struct phy_port *port = phy_get_sfp_port(phydev);
1615
1616 if (port && port->ops && port->ops->link_down)
1617 port->ops->link_down(port);
1618}
1619
1620static const struct sfp_upstream_ops sfp_phydev_ops = {
1621 .attach = phy_sfp_attach,
1622 .detach = phy_sfp_detach,
1623 .module_insert = phy_sfp_module_insert,
1624 .module_remove = phy_sfp_module_remove,
1625 .link_up = phy_sfp_link_up,
1626 .link_down = phy_sfp_link_down,
1627 .connect_phy = phy_sfp_connect_phy,
1628 .disconnect_phy = phy_sfp_disconnect_phy,
1629};
1630
1631static int phy_add_port(struct phy_device *phydev, struct phy_port *port)
1632{
1633 int ret = 0;
1634
1635 if (phydev->n_ports == phydev->max_n_ports)
1636 return -EBUSY;
1637
1638 /* We set all ports as active by default, PHY drivers may deactivate
1639 * them (when unused)
1640 */
1641 port->active = true;
1642
1643 if (port->is_mii) {
1644 if (phydev->drv && phydev->drv->attach_mii_port)
1645 ret = phydev->drv->attach_mii_port(phydev, port);
1646 } else {
1647 if (phydev->drv && phydev->drv->attach_mdi_port)
1648 ret = phydev->drv->attach_mdi_port(phydev, port);
1649 }
1650
1651 if (ret)
1652 return ret;
1653
1654 /* The PHY driver might have added, removed or set medium/pairs info,
1655 * so update the port supported accordingly.
1656 */
1657 phy_port_update_supported(port);
1658
1659 list_add(&port->head, &phydev->ports);
1660
1661 phydev->n_ports++;
1662
1663 return 0;
1664}
1665
1666static void phy_del_port(struct phy_device *phydev, struct phy_port *port)
1667{
1668 if (!phydev->n_ports)
1669 return;
1670
1671 list_del(&port->head);
1672
1673 phydev->n_ports--;
1674}
1675
1676static int phy_setup_sfp_port(struct phy_device *phydev)
1677{
1678 struct phy_port *port = phy_port_alloc();
1679 int ret;
1680
1681 if (!port)
1682 return -ENOMEM;
1683
1684 port->parent_type = PHY_PORT_PHY;
1685 port->phy = phydev;
1686
1687 /* The PHY is a media converter, the port connected to the SFP cage
1688 * is a MII port.
1689 */
1690 port->is_mii = true;
1691 port->is_sfp = true;
1692
1693 /* The port->supported and port->interfaces list will be populated
1694 * when attaching the port to the phydev.
1695 */
1696 ret = phy_add_port(phydev, port);
1697 if (ret)
1698 phy_port_destroy(port);
1699
1700 return ret;
1701}
1702
1703/**
1704 * phy_sfp_probe - probe for a SFP cage attached to this PHY device
1705 * @phydev: Pointer to phy_device
1706 */
1707static int phy_sfp_probe(struct phy_device *phydev)
1708{
1709 struct sfp_bus *bus;
1710 int ret = 0;
1711
1712 if (phydev->mdio.dev.fwnode) {
1713 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1714 if (IS_ERR(bus))
1715 return PTR_ERR(bus);
1716
1717 phydev->sfp_bus = bus;
1718
1719 ret = sfp_bus_add_upstream(bus, phydev, &sfp_phydev_ops);
1720 sfp_bus_put(bus);
1721
1722 if (ret)
1723 phydev->sfp_bus = NULL;
1724 }
1725
1726 if (!ret && phydev->sfp_bus)
1727 ret = phy_setup_sfp_port(phydev);
1728
1729 return ret;
1730}
1731
1732static bool phy_drv_supports_irq(const struct phy_driver *phydrv)
1733{
1734 return phydrv->config_intr && phydrv->handle_interrupt;
1735}
1736
1737/**
1738 * phy_attach_direct - attach a network device to a given PHY device pointer
1739 * @dev: network device to attach
1740 * @phydev: Pointer to phy_device to attach
1741 * @flags: PHY device's dev_flags
1742 * @interface: PHY device's interface
1743 *
1744 * Description: Called by drivers to attach to a particular PHY
1745 * device. The phy_device is found, and properly hooked up
1746 * to the phy_driver. If no driver is attached, then a
1747 * generic driver is used. The phy_device is given a ptr to
1748 * the attaching device, and given a callback for link status
1749 * change. The phy_device is returned to the attaching driver.
1750 * This function takes a reference on the phy device.
1751 */
1752int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1753 u32 flags, phy_interface_t interface)
1754{
1755 struct mii_bus *bus = phydev->mdio.bus;
1756 struct device *d = &phydev->mdio.dev;
1757 struct module *ndev_owner = NULL;
1758 int err;
1759
1760 /* For Ethernet device drivers that register their own MDIO bus, we
1761 * will have bus->owner match ndev_mod, so we do not want to increment
1762 * our own module->refcnt here, otherwise we would not be able to
1763 * unload later on.
1764 */
1765 if (dev)
1766 ndev_owner = dev->dev.parent->driver->owner;
1767 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1768 phydev_err(phydev, "failed to get the bus module\n");
1769 return -EIO;
1770 }
1771
1772 get_device(d);
1773
1774 /* Assume that if there is no driver, that it doesn't
1775 * exist, and we should use the genphy driver.
1776 */
1777 if (!d->driver) {
1778 if (phydev->is_c45)
1779 d->driver = &genphy_c45_driver.mdiodrv.driver;
1780 else
1781 d->driver = &genphy_driver.mdiodrv.driver;
1782
1783 phydev->is_genphy_driven = 1;
1784 }
1785
1786 if (!try_module_get(d->driver->owner)) {
1787 phydev_err(phydev, "failed to get the device driver module\n");
1788 err = -EIO;
1789 goto error_put_device;
1790 }
1791
1792 if (phydev->is_genphy_driven) {
1793 err = d->driver->probe(d);
1794 if (err >= 0)
1795 err = device_bind_driver(d);
1796
1797 if (err)
1798 goto error_module_put;
1799 }
1800
1801 if (phydev->attached_dev) {
1802 dev_err(&dev->dev, "PHY already attached\n");
1803 err = -EBUSY;
1804 goto error;
1805 }
1806
1807 phydev->phy_link_change = phy_link_change;
1808 if (dev) {
1809 phydev->attached_dev = dev;
1810 dev->phydev = phydev;
1811
1812 if (phydev->sfp_bus_attached)
1813 dev->sfp_bus = phydev->sfp_bus;
1814
1815 err = phy_link_topo_add_phy(dev, phydev, PHY_UPSTREAM_MAC, dev);
1816 if (err)
1817 goto error;
1818 }
1819
1820 /* Some Ethernet drivers try to connect to a PHY device before
1821 * calling register_netdevice() -> netdev_register_kobject() and
1822 * does the dev->dev.kobj initialization. Here we only check for
1823 * success which indicates that the network device kobject is
1824 * ready. Once we do that we still need to keep track of whether
1825 * links were successfully set up or not for phy_detach() to
1826 * remove them accordingly.
1827 */
1828 phydev->sysfs_links = false;
1829
1830 phy_sysfs_create_links(phydev);
1831
1832 if (!phydev->attached_dev) {
1833 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1834 &dev_attr_phy_standalone.attr);
1835 if (err)
1836 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1837 }
1838
1839 phydev->dev_flags |= flags;
1840
1841 phydev->interface = interface;
1842
1843 phydev->state = PHY_READY;
1844
1845 phydev->interrupts = PHY_INTERRUPT_DISABLED;
1846
1847 /* PHYs can request to use poll mode even though they have an
1848 * associated interrupt line. This could be the case if they
1849 * detect a broken interrupt handling.
1850 */
1851 if (phydev->dev_flags & PHY_F_NO_IRQ)
1852 phydev->irq = PHY_POLL;
1853
1854 if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev))
1855 phydev->irq = PHY_POLL;
1856
1857 /* Port is set to PORT_TP by default and the actual PHY driver will set
1858 * it to different value depending on the PHY configuration. If we have
1859 * the generic PHY driver we can't figure it out, thus set the old
1860 * legacy PORT_MII value.
1861 */
1862 if (phydev->is_genphy_driven)
1863 phydev->port = PORT_MII;
1864
1865 /* Initial carrier state is off as the phy is about to be
1866 * (re)initialized.
1867 */
1868 if (dev)
1869 netif_carrier_off(phydev->attached_dev);
1870
1871 /* Do initial configuration here, now that
1872 * we have certain key parameters
1873 * (dev_flags and interface)
1874 */
1875 err = phy_init_hw(phydev);
1876 if (err)
1877 goto error;
1878
1879 phy_resume(phydev);
1880
1881 /**
1882 * If the external phy used by current mac interface is managed by
1883 * another mac interface, so we should create a device link between
1884 * phy dev and mac dev.
1885 */
1886 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent)
1887 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev,
1888 DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS);
1889
1890 return err;
1891
1892error:
1893 /* phy_detach() does all of the cleanup below */
1894 phy_detach(phydev);
1895 return err;
1896
1897error_module_put:
1898 module_put(d->driver->owner);
1899 phydev->is_genphy_driven = 0;
1900 d->driver = NULL;
1901error_put_device:
1902 put_device(d);
1903 if (ndev_owner != bus->owner)
1904 module_put(bus->owner);
1905 return err;
1906}
1907EXPORT_SYMBOL(phy_attach_direct);
1908
1909/**
1910 * phy_detach - detach a PHY device from its network device
1911 * @phydev: target phy_device struct
1912 *
1913 * This detaches the phy device from its network device and the phy
1914 * driver, and drops the reference count taken in phy_attach_direct().
1915 */
1916void phy_detach(struct phy_device *phydev)
1917{
1918 struct net_device *dev = phydev->attached_dev;
1919 struct module *ndev_owner = NULL;
1920 struct mii_bus *bus;
1921
1922 if (phydev->devlink) {
1923 device_link_del(phydev->devlink);
1924 phydev->devlink = NULL;
1925 }
1926
1927 if (phydev->sysfs_links) {
1928 if (dev)
1929 sysfs_remove_link(&dev->dev.kobj, "phydev");
1930 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1931 }
1932
1933 if (!phydev->attached_dev)
1934 sysfs_remove_file(&phydev->mdio.dev.kobj,
1935 &dev_attr_phy_standalone.attr);
1936
1937 phy_suspend(phydev);
1938 if (dev) {
1939 struct hwtstamp_provider *hwprov;
1940
1941 /* hwprov may technically be protected by ops lock but
1942 * not for devices with a phydev, see phy_link_topo_add_phy()
1943 */
1944 hwprov = rtnl_dereference(dev->hwprov);
1945 /* Disable timestamp if it is the one selected */
1946 if (hwprov && hwprov->phydev == phydev) {
1947 rcu_assign_pointer(dev->hwprov, NULL);
1948 kfree_rcu(hwprov, rcu_head);
1949 }
1950
1951 phydev->attached_dev->phydev = NULL;
1952 phydev->attached_dev = NULL;
1953 phy_link_topo_del_phy(dev, phydev);
1954 }
1955
1956 phydev->phy_link_change = NULL;
1957 phydev->phylink = NULL;
1958
1959 if (phydev->mdio.dev.driver)
1960 module_put(phydev->mdio.dev.driver->owner);
1961
1962 /* If the device had no specific driver before (i.e. - it
1963 * was using the generic driver), we unbind the device
1964 * from the generic driver so that there's a chance a
1965 * real driver could be loaded
1966 */
1967 if (phydev->is_genphy_driven) {
1968 device_release_driver(&phydev->mdio.dev);
1969 phydev->is_genphy_driven = 0;
1970 }
1971
1972 /* Assert the reset signal */
1973 phy_device_reset(phydev, 1);
1974
1975 /*
1976 * The phydev might go away on the put_device() below, so avoid
1977 * a use-after-free bug by reading the underlying bus first.
1978 */
1979 bus = phydev->mdio.bus;
1980
1981 put_device(&phydev->mdio.dev);
1982 if (dev)
1983 ndev_owner = dev->dev.parent->driver->owner;
1984 if (ndev_owner != bus->owner)
1985 module_put(bus->owner);
1986}
1987EXPORT_SYMBOL(phy_detach);
1988
1989int phy_suspend(struct phy_device *phydev)
1990{
1991 struct net_device *netdev = phydev->attached_dev;
1992 const struct phy_driver *phydrv = phydev->drv;
1993 int ret;
1994
1995 if (phydev->suspended || !phydrv)
1996 return 0;
1997
1998 phydev->wol_enabled = phy_may_wakeup(phydev) ||
1999 (netdev && netdev->ethtool->wol_enabled);
2000 /* If the device has WOL enabled, we cannot suspend the PHY */
2001 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND))
2002 return -EBUSY;
2003
2004 if (!phydrv->suspend)
2005 return 0;
2006
2007 ret = phydrv->suspend(phydev);
2008 if (!ret)
2009 phydev->suspended = true;
2010
2011 return ret;
2012}
2013EXPORT_SYMBOL(phy_suspend);
2014
2015int __phy_resume(struct phy_device *phydev)
2016{
2017 const struct phy_driver *phydrv = phydev->drv;
2018 int ret;
2019
2020 lockdep_assert_held(&phydev->lock);
2021
2022 if (!phydrv || !phydrv->resume)
2023 return 0;
2024
2025 ret = phydrv->resume(phydev);
2026 if (!ret)
2027 phydev->suspended = false;
2028
2029 return ret;
2030}
2031EXPORT_SYMBOL(__phy_resume);
2032
2033int phy_resume(struct phy_device *phydev)
2034{
2035 int ret;
2036
2037 mutex_lock(&phydev->lock);
2038 ret = __phy_resume(phydev);
2039 mutex_unlock(&phydev->lock);
2040
2041 return ret;
2042}
2043EXPORT_SYMBOL(phy_resume);
2044
2045/**
2046 * phy_reset_after_clk_enable - perform a PHY reset if needed
2047 * @phydev: target phy_device struct
2048 *
2049 * Description: Some PHYs are known to need a reset after their refclk was
2050 * enabled. This function evaluates the flags and perform the reset if it's
2051 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
2052 * was reset.
2053 */
2054int phy_reset_after_clk_enable(struct phy_device *phydev)
2055{
2056 if (!phydev || !phydev->drv)
2057 return -ENODEV;
2058
2059 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
2060 phy_device_reset(phydev, 1);
2061 phy_device_reset(phydev, 0);
2062 return 1;
2063 }
2064
2065 return 0;
2066}
2067EXPORT_SYMBOL(phy_reset_after_clk_enable);
2068
2069/* Generic PHY support and helper functions */
2070
2071/**
2072 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
2073 * @phydev: target phy_device struct
2074 * @advert: auto-negotiation parameters to advertise
2075 *
2076 * Description: Writes MII_ADVERTISE with the appropriate values,
2077 * after sanitizing the values to make sure we only advertise
2078 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
2079 * hasn't changed, and > 0 if it has changed.
2080 */
2081static int genphy_config_advert(struct phy_device *phydev,
2082 const unsigned long *advert)
2083{
2084 int err, bmsr, changed = 0;
2085 u32 adv;
2086
2087 adv = linkmode_adv_to_mii_adv_t(advert);
2088
2089 /* Setup standard advertisement */
2090 err = phy_modify_changed(phydev, MII_ADVERTISE,
2091 ADVERTISE_ALL | ADVERTISE_100BASE4 |
2092 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
2093 adv);
2094 if (err < 0)
2095 return err;
2096 if (err > 0)
2097 changed = 1;
2098
2099 bmsr = phy_read(phydev, MII_BMSR);
2100 if (bmsr < 0)
2101 return bmsr;
2102
2103 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
2104 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
2105 * logical 1.
2106 */
2107 if (!(bmsr & BMSR_ESTATEN))
2108 return changed;
2109
2110 adv = linkmode_adv_to_mii_ctrl1000_t(advert);
2111
2112 err = phy_modify_changed(phydev, MII_CTRL1000,
2113 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
2114 adv);
2115 if (err < 0)
2116 return err;
2117 if (err > 0)
2118 changed = 1;
2119
2120 return changed;
2121}
2122
2123/**
2124 * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
2125 * @phydev: target phy_device struct
2126 *
2127 * Description: Writes MII_ADVERTISE with the appropriate values,
2128 * after sanitizing the values to make sure we only advertise
2129 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
2130 * hasn't changed, and > 0 if it has changed. This function is intended
2131 * for Clause 37 1000Base-X mode.
2132 */
2133static int genphy_c37_config_advert(struct phy_device *phydev)
2134{
2135 u16 adv = 0;
2136
2137 /* Only allow advertising what this PHY supports */
2138 linkmode_and(phydev->advertising, phydev->advertising,
2139 phydev->supported);
2140
2141 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2142 phydev->advertising))
2143 adv |= ADVERTISE_1000XFULL;
2144 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2145 phydev->advertising))
2146 adv |= ADVERTISE_1000XPAUSE;
2147 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2148 phydev->advertising))
2149 adv |= ADVERTISE_1000XPSE_ASYM;
2150
2151 return phy_modify_changed(phydev, MII_ADVERTISE,
2152 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
2153 ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
2154 adv);
2155}
2156
2157/**
2158 * genphy_setup_forced - configures/forces speed/duplex from @phydev
2159 * @phydev: target phy_device struct
2160 *
2161 * Description: Configures MII_BMCR to force speed/duplex
2162 * to the values in phydev. Assumes that the values are valid.
2163 * Please see phy_sanitize_settings().
2164 */
2165int genphy_setup_forced(struct phy_device *phydev)
2166{
2167 u16 ctl;
2168
2169 phydev->pause = false;
2170 phydev->asym_pause = false;
2171
2172 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2173
2174 return phy_modify(phydev, MII_BMCR,
2175 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
2176}
2177EXPORT_SYMBOL(genphy_setup_forced);
2178
2179static int genphy_setup_master_slave(struct phy_device *phydev)
2180{
2181 u16 ctl = 0;
2182
2183 if (!phydev->is_gigabit_capable)
2184 return 0;
2185
2186 switch (phydev->master_slave_set) {
2187 case MASTER_SLAVE_CFG_MASTER_PREFERRED:
2188 ctl |= CTL1000_PREFER_MASTER;
2189 break;
2190 case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
2191 break;
2192 case MASTER_SLAVE_CFG_MASTER_FORCE:
2193 ctl |= CTL1000_AS_MASTER;
2194 fallthrough;
2195 case MASTER_SLAVE_CFG_SLAVE_FORCE:
2196 ctl |= CTL1000_ENABLE_MASTER;
2197 break;
2198 case MASTER_SLAVE_CFG_UNKNOWN:
2199 case MASTER_SLAVE_CFG_UNSUPPORTED:
2200 return 0;
2201 default:
2202 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
2203 return -EOPNOTSUPP;
2204 }
2205
2206 return phy_modify_changed(phydev, MII_CTRL1000,
2207 (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
2208 CTL1000_PREFER_MASTER), ctl);
2209}
2210
2211int genphy_read_master_slave(struct phy_device *phydev)
2212{
2213 int cfg, state;
2214 int val;
2215
2216 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2217 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2218
2219 val = phy_read(phydev, MII_CTRL1000);
2220 if (val < 0)
2221 return val;
2222
2223 if (val & CTL1000_ENABLE_MASTER) {
2224 if (val & CTL1000_AS_MASTER)
2225 cfg = MASTER_SLAVE_CFG_MASTER_FORCE;
2226 else
2227 cfg = MASTER_SLAVE_CFG_SLAVE_FORCE;
2228 } else {
2229 if (val & CTL1000_PREFER_MASTER)
2230 cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED;
2231 else
2232 cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED;
2233 }
2234
2235 val = phy_read(phydev, MII_STAT1000);
2236 if (val < 0)
2237 return val;
2238
2239 if (val & LPA_1000MSFAIL) {
2240 state = MASTER_SLAVE_STATE_ERR;
2241 } else if (phydev->link) {
2242 /* this bits are valid only for active link */
2243 if (val & LPA_1000MSRES)
2244 state = MASTER_SLAVE_STATE_MASTER;
2245 else
2246 state = MASTER_SLAVE_STATE_SLAVE;
2247 } else {
2248 state = MASTER_SLAVE_STATE_UNKNOWN;
2249 }
2250
2251 phydev->master_slave_get = cfg;
2252 phydev->master_slave_state = state;
2253
2254 return 0;
2255}
2256EXPORT_SYMBOL(genphy_read_master_slave);
2257
2258/**
2259 * genphy_restart_aneg - Enable and Restart Autonegotiation
2260 * @phydev: target phy_device struct
2261 */
2262int genphy_restart_aneg(struct phy_device *phydev)
2263{
2264 /* Don't isolate the PHY if we're negotiating */
2265 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2266 BMCR_ANENABLE | BMCR_ANRESTART);
2267}
2268EXPORT_SYMBOL(genphy_restart_aneg);
2269
2270/**
2271 * genphy_check_and_restart_aneg - Enable and restart auto-negotiation
2272 * @phydev: target phy_device struct
2273 * @restart: whether aneg restart is requested
2274 *
2275 * Check, and restart auto-negotiation if needed.
2276 */
2277int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2278{
2279 int ret;
2280
2281 if (!restart) {
2282 /* Advertisement hasn't changed, but maybe aneg was never on to
2283 * begin with? Or maybe phy was isolated?
2284 */
2285 ret = phy_read(phydev, MII_BMCR);
2286 if (ret < 0)
2287 return ret;
2288
2289 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
2290 restart = true;
2291 }
2292
2293 if (restart)
2294 return genphy_restart_aneg(phydev);
2295
2296 return 0;
2297}
2298EXPORT_SYMBOL(genphy_check_and_restart_aneg);
2299
2300/**
2301 * __genphy_config_aneg - restart auto-negotiation or write BMCR
2302 * @phydev: target phy_device struct
2303 * @changed: whether autoneg is requested
2304 *
2305 * Description: If auto-negotiation is enabled, we configure the
2306 * advertising, and then restart auto-negotiation. If it is not
2307 * enabled, then we write the BMCR.
2308 */
2309int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2310{
2311 __ETHTOOL_DECLARE_LINK_MODE_MASK(fixed_advert);
2312 const struct link_capabilities *c;
2313 unsigned long *advert;
2314 int err;
2315
2316 err = genphy_c45_an_config_eee_aneg(phydev);
2317 if (err < 0)
2318 return err;
2319 else if (err)
2320 changed = true;
2321
2322 err = genphy_setup_master_slave(phydev);
2323 if (err < 0)
2324 return err;
2325 else if (err)
2326 changed = true;
2327
2328 if (phydev->autoneg == AUTONEG_ENABLE) {
2329 /* Only allow advertising what this PHY supports */
2330 linkmode_and(phydev->advertising, phydev->advertising,
2331 phydev->supported);
2332 advert = phydev->advertising;
2333 } else if (phydev->speed < SPEED_1000) {
2334 return genphy_setup_forced(phydev);
2335 } else {
2336 linkmode_zero(fixed_advert);
2337
2338 c = phy_caps_lookup(phydev->speed, phydev->duplex,
2339 phydev->supported, true);
2340 if (c)
2341 linkmode_and(fixed_advert, phydev->supported,
2342 c->linkmodes);
2343
2344 advert = fixed_advert;
2345 }
2346
2347 err = genphy_config_advert(phydev, advert);
2348 if (err < 0) /* error */
2349 return err;
2350 else if (err)
2351 changed = true;
2352
2353 return genphy_check_and_restart_aneg(phydev, changed);
2354}
2355EXPORT_SYMBOL(__genphy_config_aneg);
2356
2357/**
2358 * genphy_c37_config_aneg - restart auto-negotiation or write BMCR
2359 * @phydev: target phy_device struct
2360 *
2361 * Description: If auto-negotiation is enabled, we configure the
2362 * advertising, and then restart auto-negotiation. If it is not
2363 * enabled, then we write the BMCR. This function is intended
2364 * for use with Clause 37 1000Base-X mode.
2365 */
2366int genphy_c37_config_aneg(struct phy_device *phydev)
2367{
2368 int err, changed;
2369
2370 if (phydev->autoneg != AUTONEG_ENABLE)
2371 return genphy_setup_forced(phydev);
2372
2373 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2374 BMCR_SPEED1000);
2375 if (err)
2376 return err;
2377
2378 changed = genphy_c37_config_advert(phydev);
2379 if (changed < 0) /* error */
2380 return changed;
2381
2382 if (!changed) {
2383 /* Advertisement hasn't changed, but maybe aneg was never on to
2384 * begin with? Or maybe phy was isolated?
2385 */
2386 int ctl = phy_read(phydev, MII_BMCR);
2387
2388 if (ctl < 0)
2389 return ctl;
2390
2391 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
2392 changed = 1; /* do restart aneg */
2393 }
2394
2395 /* Only restart aneg if we are advertising something different
2396 * than we were before.
2397 */
2398 if (changed > 0)
2399 return genphy_restart_aneg(phydev);
2400
2401 return 0;
2402}
2403EXPORT_SYMBOL(genphy_c37_config_aneg);
2404
2405/**
2406 * genphy_aneg_done - return auto-negotiation status
2407 * @phydev: target phy_device struct
2408 *
2409 * Description: Reads the status register and returns 0 either if
2410 * auto-negotiation is incomplete, or if there was an error.
2411 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
2412 */
2413int genphy_aneg_done(struct phy_device *phydev)
2414{
2415 int retval = phy_read(phydev, MII_BMSR);
2416
2417 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
2418}
2419EXPORT_SYMBOL(genphy_aneg_done);
2420
2421/**
2422 * genphy_update_link - update link status in @phydev
2423 * @phydev: target phy_device struct
2424 *
2425 * Description: Update the value in phydev->link to reflect the
2426 * current link value. In order to do this, we need to read
2427 * the status register twice, keeping the second value.
2428 */
2429int genphy_update_link(struct phy_device *phydev)
2430{
2431 int status = 0, bmcr;
2432
2433 bmcr = phy_read(phydev, MII_BMCR);
2434 if (bmcr < 0)
2435 return bmcr;
2436
2437 /* Autoneg is being started, therefore disregard BMSR value and
2438 * report link as down.
2439 */
2440 if (bmcr & BMCR_ANRESTART)
2441 goto done;
2442
2443 /* The link state is latched low so that momentary link
2444 * drops can be detected. Do not double-read the status
2445 * in polling mode to detect such short link drops except
2446 * if the link was already down.
2447 */
2448 if (!phy_polling_mode(phydev) || !phydev->link) {
2449 status = phy_read(phydev, MII_BMSR);
2450 if (status < 0)
2451 return status;
2452 else if (status & BMSR_LSTATUS)
2453 goto done;
2454 }
2455
2456 /* Read link and autonegotiation status */
2457 status = phy_read(phydev, MII_BMSR);
2458 if (status < 0)
2459 return status;
2460done:
2461 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2462 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2463
2464 /* Consider the case that autoneg was started and "aneg complete"
2465 * bit has been reset, but "link up" bit not yet.
2466 */
2467 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2468 phydev->link = 0;
2469
2470 return 0;
2471}
2472EXPORT_SYMBOL(genphy_update_link);
2473
2474int genphy_read_lpa(struct phy_device *phydev)
2475{
2476 int lpa, lpagb;
2477
2478 if (phydev->autoneg == AUTONEG_ENABLE) {
2479 if (!phydev->autoneg_complete) {
2480 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2481 0);
2482 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2483 return 0;
2484 }
2485
2486 if (phydev->is_gigabit_capable) {
2487 lpagb = phy_read(phydev, MII_STAT1000);
2488 if (lpagb < 0)
2489 return lpagb;
2490
2491 if (lpagb & LPA_1000MSFAIL) {
2492 int adv = phy_read(phydev, MII_CTRL1000);
2493
2494 if (adv < 0)
2495 return adv;
2496
2497 if (adv & CTL1000_ENABLE_MASTER)
2498 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2499 else
2500 phydev_err(phydev, "Master/Slave resolution failed\n");
2501 return -ENOLINK;
2502 }
2503
2504 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2505 lpagb);
2506 }
2507
2508 lpa = phy_read(phydev, MII_LPA);
2509 if (lpa < 0)
2510 return lpa;
2511
2512 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2513 } else {
2514 linkmode_zero(phydev->lp_advertising);
2515 }
2516
2517 return 0;
2518}
2519EXPORT_SYMBOL(genphy_read_lpa);
2520
2521/**
2522 * genphy_read_status_fixed - read the link parameters for !aneg mode
2523 * @phydev: target phy_device struct
2524 *
2525 * Read the current duplex and speed state for a PHY operating with
2526 * autonegotiation disabled.
2527 */
2528int genphy_read_status_fixed(struct phy_device *phydev)
2529{
2530 int bmcr = phy_read(phydev, MII_BMCR);
2531
2532 if (bmcr < 0)
2533 return bmcr;
2534
2535 if (bmcr & BMCR_FULLDPLX)
2536 phydev->duplex = DUPLEX_FULL;
2537 else
2538 phydev->duplex = DUPLEX_HALF;
2539
2540 if (bmcr & BMCR_SPEED1000)
2541 phydev->speed = SPEED_1000;
2542 else if (bmcr & BMCR_SPEED100)
2543 phydev->speed = SPEED_100;
2544 else
2545 phydev->speed = SPEED_10;
2546
2547 return 0;
2548}
2549EXPORT_SYMBOL(genphy_read_status_fixed);
2550
2551/**
2552 * genphy_read_status - check the link status and update current link state
2553 * @phydev: target phy_device struct
2554 *
2555 * Description: Check the link, then figure out the current state
2556 * by comparing what we advertise with what the link partner
2557 * advertises. Start by checking the gigabit possibilities,
2558 * then move on to 10/100.
2559 */
2560int genphy_read_status(struct phy_device *phydev)
2561{
2562 int err, old_link = phydev->link;
2563
2564 /* Update the link, but return if there was an error */
2565 err = genphy_update_link(phydev);
2566 if (err)
2567 return err;
2568
2569 /* why bother the PHY if nothing can have changed */
2570 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2571 return 0;
2572
2573 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
2574 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2575 phydev->speed = SPEED_UNKNOWN;
2576 phydev->duplex = DUPLEX_UNKNOWN;
2577 phydev->pause = false;
2578 phydev->asym_pause = false;
2579
2580 if (phydev->is_gigabit_capable) {
2581 err = genphy_read_master_slave(phydev);
2582 if (err < 0)
2583 return err;
2584 }
2585
2586 err = genphy_read_lpa(phydev);
2587 if (err < 0)
2588 return err;
2589
2590 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2591 phy_resolve_aneg_linkmode(phydev);
2592 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2593 err = genphy_read_status_fixed(phydev);
2594 if (err < 0)
2595 return err;
2596 }
2597
2598 return 0;
2599}
2600EXPORT_SYMBOL(genphy_read_status);
2601
2602/**
2603 * genphy_c37_read_status - check the link status and update current link state
2604 * @phydev: target phy_device struct
2605 * @changed: pointer where to store if link changed
2606 *
2607 * Description: Check the link, then figure out the current state
2608 * by comparing what we advertise with what the link partner
2609 * advertises. This function is for Clause 37 1000Base-X mode.
2610 *
2611 * If link has changed, @changed is set to true, false otherwise.
2612 */
2613int genphy_c37_read_status(struct phy_device *phydev, bool *changed)
2614{
2615 int lpa, err, old_link = phydev->link;
2616
2617 /* Update the link, but return if there was an error */
2618 err = genphy_update_link(phydev);
2619 if (err)
2620 return err;
2621
2622 /* why bother the PHY if nothing can have changed */
2623 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) {
2624 *changed = false;
2625 return 0;
2626 }
2627
2628 /* Signal link has changed */
2629 *changed = true;
2630 phydev->duplex = DUPLEX_UNKNOWN;
2631 phydev->pause = false;
2632 phydev->asym_pause = false;
2633
2634 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2635 lpa = phy_read(phydev, MII_LPA);
2636 if (lpa < 0)
2637 return lpa;
2638
2639 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2640 phydev->lp_advertising, lpa & LPA_LPACK);
2641 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2642 phydev->lp_advertising, lpa & LPA_1000XFULL);
2643 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2644 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2645 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2646 phydev->lp_advertising,
2647 lpa & LPA_1000XPAUSE_ASYM);
2648
2649 phy_resolve_aneg_linkmode(phydev);
2650 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2651 int bmcr = phy_read(phydev, MII_BMCR);
2652
2653 if (bmcr < 0)
2654 return bmcr;
2655
2656 if (bmcr & BMCR_FULLDPLX)
2657 phydev->duplex = DUPLEX_FULL;
2658 else
2659 phydev->duplex = DUPLEX_HALF;
2660 }
2661
2662 return 0;
2663}
2664EXPORT_SYMBOL(genphy_c37_read_status);
2665
2666/**
2667 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
2668 * @phydev: target phy_device struct
2669 *
2670 * Description: Perform a software PHY reset using the standard
2671 * BMCR_RESET bit and poll for the reset bit to be cleared.
2672 *
2673 * Returns: 0 on success, < 0 on failure
2674 */
2675int genphy_soft_reset(struct phy_device *phydev)
2676{
2677 u16 res = BMCR_RESET;
2678 int ret;
2679
2680 if (phydev->autoneg == AUTONEG_ENABLE)
2681 res |= BMCR_ANRESTART;
2682
2683 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2684 if (ret < 0)
2685 return ret;
2686
2687 /* Clause 22 states that setting bit BMCR_RESET sets control registers
2688 * to their default value. Therefore the POWER DOWN bit is supposed to
2689 * be cleared after soft reset.
2690 */
2691 phydev->suspended = 0;
2692
2693 ret = phy_poll_reset(phydev);
2694 if (ret)
2695 return ret;
2696
2697 /* BMCR may be reset to defaults */
2698 if (phydev->autoneg == AUTONEG_DISABLE)
2699 ret = genphy_setup_forced(phydev);
2700
2701 return ret;
2702}
2703EXPORT_SYMBOL(genphy_soft_reset);
2704
2705irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
2706{
2707 /* It seems there are cases where the interrupts are handled by another
2708 * entity (ie an IRQ controller embedded inside the PHY) and do not
2709 * need any other interraction from phylib. In this case, just trigger
2710 * the state machine directly.
2711 */
2712 phy_trigger_machine(phydev);
2713
2714 return 0;
2715}
2716EXPORT_SYMBOL(genphy_handle_interrupt_no_ack);
2717
2718/**
2719 * genphy_read_abilities - read PHY abilities from Clause 22 registers
2720 * @phydev: target phy_device struct
2721 *
2722 * Description: Reads the PHY's abilities and populates
2723 * phydev->supported accordingly.
2724 *
2725 * Returns: 0 on success, < 0 on failure
2726 */
2727int genphy_read_abilities(struct phy_device *phydev)
2728{
2729 int val;
2730
2731 linkmode_set_bit_array(phy_basic_ports_array,
2732 ARRAY_SIZE(phy_basic_ports_array),
2733 phydev->supported);
2734
2735 val = phy_read(phydev, MII_BMSR);
2736 if (val < 0)
2737 return val;
2738
2739 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2740 val & BMSR_ANEGCAPABLE);
2741
2742 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2743 val & BMSR_100FULL);
2744 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2745 val & BMSR_100HALF);
2746 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2747 val & BMSR_10FULL);
2748 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2749 val & BMSR_10HALF);
2750
2751 if (val & BMSR_ESTATEN) {
2752 val = phy_read(phydev, MII_ESTATUS);
2753 if (val < 0)
2754 return val;
2755
2756 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2757 phydev->supported, val & ESTATUS_1000_TFULL);
2758 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2759 phydev->supported, val & ESTATUS_1000_THALF);
2760 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2761 phydev->supported, val & ESTATUS_1000_XFULL);
2762 }
2763
2764 /* This is optional functionality. If not supported, we may get an error
2765 * which should be ignored.
2766 */
2767 genphy_c45_read_eee_abilities(phydev);
2768
2769 return 0;
2770}
2771EXPORT_SYMBOL(genphy_read_abilities);
2772
2773/* Some PHYs support direct C45 register access but not C22 indirect
2774 * MMD access (registers 13 and 14). When discovered via C22, phylib
2775 * routes MMD access through the indirect path, which won't work on
2776 * these devices. These helpers bypass indirect access and use the bus
2777 * C45 accessors directly.
2778 */
2779int genphy_read_mmd_c45(struct phy_device *phydev, int devnum, u16 regnum)
2780{
2781 struct mii_bus *bus = phydev->mdio.bus;
2782 int addr = phydev->mdio.addr;
2783
2784 return __mdiobus_c45_read(bus, addr, devnum, regnum);
2785}
2786EXPORT_SYMBOL(genphy_read_mmd_c45);
2787
2788int genphy_write_mmd_c45(struct phy_device *phydev, int devnum, u16 regnum,
2789 u16 val)
2790{
2791 struct mii_bus *bus = phydev->mdio.bus;
2792 int addr = phydev->mdio.addr;
2793
2794 return __mdiobus_c45_write(bus, addr, devnum, regnum, val);
2795}
2796EXPORT_SYMBOL(genphy_write_mmd_c45);
2797
2798/* This is used for the phy device which doesn't support the MMD extended
2799 * register access, but it does have side effect when we are trying to access
2800 * the MMD register via indirect method.
2801 */
2802int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
2803{
2804 return -EOPNOTSUPP;
2805}
2806EXPORT_SYMBOL(genphy_read_mmd_unsupported);
2807
2808int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
2809 u16 regnum, u16 val)
2810{
2811 return -EOPNOTSUPP;
2812}
2813EXPORT_SYMBOL(genphy_write_mmd_unsupported);
2814
2815int genphy_suspend(struct phy_device *phydev)
2816{
2817 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2818}
2819EXPORT_SYMBOL(genphy_suspend);
2820
2821int genphy_resume(struct phy_device *phydev)
2822{
2823 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2824}
2825EXPORT_SYMBOL(genphy_resume);
2826
2827int genphy_loopback(struct phy_device *phydev, bool enable, int speed)
2828{
2829 if (enable) {
2830 u16 ctl = BMCR_LOOPBACK;
2831 int ret, val;
2832
2833 if (speed == SPEED_10 || speed == SPEED_100 ||
2834 speed == SPEED_1000)
2835 phydev->speed = speed;
2836 else if (speed)
2837 return -EINVAL;
2838
2839 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2840
2841 phy_modify(phydev, MII_BMCR, ~0, ctl);
2842
2843 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,
2844 val & BMSR_LSTATUS,
2845 5000, 500000, true);
2846 if (ret)
2847 return ret;
2848 } else {
2849 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
2850
2851 phy_config_aneg(phydev);
2852 }
2853
2854 return 0;
2855}
2856EXPORT_SYMBOL(genphy_loopback);
2857
2858/**
2859 * phy_remove_link_mode - Remove a supported link mode
2860 * @phydev: phy_device structure to remove link mode from
2861 * @link_mode: Link mode to be removed
2862 *
2863 * Description: Some MACs don't support all link modes which the PHY
2864 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper
2865 * to remove a link mode.
2866 */
2867void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2868{
2869 linkmode_clear_bit(link_mode, phydev->supported);
2870 phy_advertise_supported(phydev);
2871}
2872EXPORT_SYMBOL(phy_remove_link_mode);
2873
2874static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2875{
2876 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2877 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2878 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2879 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2880}
2881
2882/**
2883 * phy_advertise_supported - Advertise all supported modes
2884 * @phydev: target phy_device struct
2885 *
2886 * Description: Called to advertise all supported modes, doesn't touch
2887 * pause mode advertising.
2888 */
2889void phy_advertise_supported(struct phy_device *phydev)
2890{
2891 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2892
2893 linkmode_copy(new, phydev->supported);
2894 phy_copy_pause_bits(new, phydev->advertising);
2895 linkmode_copy(phydev->advertising, new);
2896}
2897EXPORT_SYMBOL(phy_advertise_supported);
2898
2899/**
2900 * phy_advertise_eee_all - Advertise all supported EEE modes
2901 * @phydev: target phy_device struct
2902 *
2903 * Description: Per default phylib preserves the EEE advertising at the time of
2904 * phy probing, which might be a subset of the supported EEE modes. Use this
2905 * function when all supported EEE modes should be advertised. This does not
2906 * trigger auto-negotiation, so must be called before phy_start()/
2907 * phylink_start() which will start auto-negotiation.
2908 */
2909void phy_advertise_eee_all(struct phy_device *phydev)
2910{
2911 linkmode_andnot(phydev->advertising_eee, phydev->supported_eee,
2912 phydev->eee_disabled_modes);
2913}
2914EXPORT_SYMBOL_GPL(phy_advertise_eee_all);
2915
2916/**
2917 * phy_support_eee - Set initial EEE policy configuration
2918 * @phydev: Target phy_device struct
2919 *
2920 * This function configures the initial policy for Energy Efficient Ethernet
2921 * (EEE) on the specified PHY device, influencing that EEE capabilities are
2922 * advertised before the link is established. It should be called during PHY
2923 * registration by the MAC driver and/or the PHY driver (for SmartEEE PHYs)
2924 * if MAC supports LPI or PHY is capable to compensate missing LPI functionality
2925 * of the MAC.
2926 *
2927 * The function sets default EEE policy parameters, including preparing the PHY
2928 * to advertise EEE capabilities based on hardware support.
2929 *
2930 * It also sets the expected configuration for Low Power Idle (LPI) in the MAC
2931 * driver. If the PHY framework determines that both local and remote
2932 * advertisements support EEE, and the negotiated link mode is compatible with
2933 * EEE, it will set enable_tx_lpi = true. The MAC driver is expected to act on
2934 * this setting by enabling the LPI timer if enable_tx_lpi is set.
2935 */
2936void phy_support_eee(struct phy_device *phydev)
2937{
2938 linkmode_andnot(phydev->advertising_eee, phydev->supported_eee,
2939 phydev->eee_disabled_modes);
2940 phydev->eee_cfg.tx_lpi_enabled = true;
2941 phydev->eee_cfg.eee_enabled = true;
2942
2943 /* If the PHY supports autonomous EEE, disable it so the MAC can
2944 * manage LPI signaling instead. The flag is stored so it can be
2945 * re-applied after a PHY soft reset (e.g. suspend/resume).
2946 */
2947 if (phydev->drv && phydev->drv->disable_autonomous_eee) {
2948 int ret = phydev->drv->disable_autonomous_eee(phydev);
2949
2950 if (ret)
2951 phydev_warn(phydev, "Failed to disable autonomous EEE: %pe\n",
2952 ERR_PTR(ret));
2953 else
2954 phydev->autonomous_eee_disabled = true;
2955 }
2956}
2957EXPORT_SYMBOL(phy_support_eee);
2958
2959/**
2960 * phy_disable_eee - Disable EEE for the PHY
2961 * @phydev: Target phy_device struct
2962 *
2963 * This function is used by MAC drivers for MAC's which don't support EEE.
2964 * It disables EEE on the PHY layer.
2965 */
2966void phy_disable_eee(struct phy_device *phydev)
2967{
2968 linkmode_zero(phydev->advertising_eee);
2969 phydev->eee_cfg.tx_lpi_enabled = false;
2970 phydev->eee_cfg.eee_enabled = false;
2971 /* don't let userspace re-enable EEE advertisement */
2972 linkmode_fill(phydev->eee_disabled_modes);
2973}
2974EXPORT_SYMBOL_GPL(phy_disable_eee);
2975
2976/**
2977 * phy_support_sym_pause - Enable support of symmetrical pause
2978 * @phydev: target phy_device struct
2979 *
2980 * Description: Called by the MAC to indicate is supports symmetrical
2981 * Pause, but not asym pause.
2982 */
2983void phy_support_sym_pause(struct phy_device *phydev)
2984{
2985 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2986 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2987}
2988EXPORT_SYMBOL(phy_support_sym_pause);
2989
2990/**
2991 * phy_support_asym_pause - Enable support of asym pause
2992 * @phydev: target phy_device struct
2993 *
2994 * Description: Called by the MAC to indicate is supports Asym Pause.
2995 */
2996void phy_support_asym_pause(struct phy_device *phydev)
2997{
2998 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2999}
3000EXPORT_SYMBOL(phy_support_asym_pause);
3001
3002/**
3003 * phy_set_sym_pause - Configure symmetric Pause
3004 * @phydev: target phy_device struct
3005 * @rx: Receiver Pause is supported
3006 * @tx: Transmit Pause is supported
3007 * @autoneg: Auto neg should be used
3008 *
3009 * Description: Configure advertised Pause support depending on if
3010 * receiver pause and pause auto neg is supported. Generally called
3011 * from the set_pauseparam .ndo.
3012 */
3013void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
3014 bool autoneg)
3015{
3016 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
3017
3018 if (rx && tx && autoneg)
3019 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3020 phydev->supported);
3021
3022 linkmode_copy(phydev->advertising, phydev->supported);
3023}
3024EXPORT_SYMBOL(phy_set_sym_pause);
3025
3026/**
3027 * phy_set_asym_pause - Configure Pause and Asym Pause
3028 * @phydev: target phy_device struct
3029 * @rx: Receiver Pause is supported
3030 * @tx: Transmit Pause is supported
3031 *
3032 * Description: Configure advertised Pause support depending on if
3033 * transmit and receiver pause is supported. If there has been a
3034 * change in adverting, trigger a new autoneg. Generally called from
3035 * the set_pauseparam .ndo.
3036 */
3037void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
3038{
3039 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
3040
3041 linkmode_copy(oldadv, phydev->advertising);
3042 linkmode_set_pause(phydev->advertising, tx, rx);
3043
3044 if (!linkmode_equal(oldadv, phydev->advertising) &&
3045 phydev->autoneg)
3046 phy_start_aneg(phydev);
3047}
3048EXPORT_SYMBOL(phy_set_asym_pause);
3049
3050/**
3051 * phy_validate_pause - Test if the PHY/MAC support the pause configuration
3052 * @phydev: phy_device struct
3053 * @pp: requested pause configuration
3054 *
3055 * Description: Test if the PHY/MAC combination supports the Pause
3056 * configuration the user is requesting. Returns True if it is
3057 * supported, false otherwise.
3058 */
3059bool phy_validate_pause(struct phy_device *phydev,
3060 struct ethtool_pauseparam *pp)
3061{
3062 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3063 phydev->supported) && pp->rx_pause)
3064 return false;
3065
3066 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3067 phydev->supported) &&
3068 pp->rx_pause != pp->tx_pause)
3069 return false;
3070
3071 return true;
3072}
3073EXPORT_SYMBOL(phy_validate_pause);
3074
3075/**
3076 * phy_get_pause - resolve negotiated pause modes
3077 * @phydev: phy_device struct
3078 * @tx_pause: pointer to bool to indicate whether transmit pause should be
3079 * enabled.
3080 * @rx_pause: pointer to bool to indicate whether receive pause should be
3081 * enabled.
3082 *
3083 * Resolve and return the flow control modes according to the negotiation
3084 * result. This includes checking that we are operating in full duplex mode.
3085 * See linkmode_resolve_pause() for further details.
3086 */
3087void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
3088{
3089 if (phydev->duplex != DUPLEX_FULL) {
3090 *tx_pause = false;
3091 *rx_pause = false;
3092 return;
3093 }
3094
3095 return linkmode_resolve_pause(phydev->advertising,
3096 phydev->lp_advertising,
3097 tx_pause, rx_pause);
3098}
3099EXPORT_SYMBOL(phy_get_pause);
3100
3101#if IS_ENABLED(CONFIG_OF_MDIO)
3102static int phy_get_u32_property(struct device *dev, const char *name, u32 *val)
3103{
3104 return device_property_read_u32(dev, name, val);
3105}
3106#else
3107static int phy_get_u32_property(struct device *dev, const char *name, u32 *val)
3108{
3109 return -EINVAL;
3110}
3111#endif
3112
3113/**
3114 * phy_get_internal_delay - returns the index of the internal delay
3115 * @phydev: phy_device struct
3116 * @delay_values: array of delays the PHY supports
3117 * @size: the size of the delay array
3118 * @is_rx: boolean to indicate to get the rx internal delay
3119 *
3120 * Returns the index within the array of internal delay passed in.
3121 * If the device property is not present then the interface type is checked
3122 * if the interface defines use of internal delay then a 1 is returned otherwise
3123 * a 0 is returned.
3124 * The array must be in ascending order. If PHY does not have an ascending order
3125 * array then size = 0 and the value of the delay property is returned.
3126 * Return -EINVAL if the delay is invalid or cannot be found.
3127 */
3128s32 phy_get_internal_delay(struct phy_device *phydev, const int *delay_values,
3129 int size, bool is_rx)
3130{
3131 struct device *dev = &phydev->mdio.dev;
3132 int i, ret;
3133 u32 delay;
3134
3135 if (is_rx) {
3136 ret = phy_get_u32_property(dev, "rx-internal-delay-ps", &delay);
3137 if (ret < 0 && size == 0) {
3138 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3139 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
3140 return 1;
3141 else
3142 return 0;
3143 }
3144
3145 } else {
3146 ret = phy_get_u32_property(dev, "tx-internal-delay-ps", &delay);
3147 if (ret < 0 && size == 0) {
3148 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3149 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
3150 return 1;
3151 else
3152 return 0;
3153 }
3154 }
3155
3156 if (ret < 0)
3157 return ret;
3158
3159 if (size == 0)
3160 return delay;
3161
3162 if (delay < delay_values[0] || delay > delay_values[size - 1]) {
3163 phydev_err(phydev, "Delay %d is out of range\n", delay);
3164 return -EINVAL;
3165 }
3166
3167 if (delay == delay_values[0])
3168 return 0;
3169
3170 for (i = 1; i < size; i++) {
3171 if (delay == delay_values[i])
3172 return i;
3173
3174 /* Find an approximate index by looking up the table */
3175 if (delay > delay_values[i - 1] &&
3176 delay < delay_values[i]) {
3177 if (delay - delay_values[i - 1] <
3178 delay_values[i] - delay)
3179 return i - 1;
3180 else
3181 return i;
3182 }
3183 }
3184
3185 phydev_err(phydev, "error finding internal delay index for %d\n",
3186 delay);
3187
3188 return -EINVAL;
3189}
3190EXPORT_SYMBOL(phy_get_internal_delay);
3191
3192/**
3193 * phy_get_tx_amplitude_gain - stores tx amplitude gain in @val
3194 * @phydev: phy_device struct
3195 * @dev: pointer to the devices device struct
3196 * @linkmode: linkmode for which the tx amplitude gain should be retrieved
3197 * @val: tx amplitude gain
3198 *
3199 * Returns: 0 on success, < 0 on failure
3200 */
3201int phy_get_tx_amplitude_gain(struct phy_device *phydev, struct device *dev,
3202 enum ethtool_link_mode_bit_indices linkmode,
3203 u32 *val)
3204{
3205 switch (linkmode) {
3206 case ETHTOOL_LINK_MODE_100baseT_Full_BIT:
3207 return phy_get_u32_property(dev,
3208 "tx-amplitude-100base-tx-percent",
3209 val);
3210 default:
3211 return -EINVAL;
3212 }
3213}
3214EXPORT_SYMBOL_GPL(phy_get_tx_amplitude_gain);
3215
3216/**
3217 * phy_get_mac_termination - stores MAC termination in @val
3218 * @phydev: phy_device struct
3219 * @dev: pointer to the devices device struct
3220 * @val: MAC termination
3221 *
3222 * Returns: 0 on success, < 0 on failure
3223 */
3224int phy_get_mac_termination(struct phy_device *phydev, struct device *dev,
3225 u32 *val)
3226{
3227 return phy_get_u32_property(dev, "mac-termination-ohms", val);
3228}
3229EXPORT_SYMBOL_GPL(phy_get_mac_termination);
3230
3231static int phy_led_set_brightness(struct led_classdev *led_cdev,
3232 enum led_brightness value)
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_brightness_set(phydev, phyled->index, value);
3240 mutex_unlock(&phydev->lock);
3241
3242 return err;
3243}
3244
3245static int phy_led_blink_set(struct led_classdev *led_cdev,
3246 unsigned long *delay_on,
3247 unsigned long *delay_off)
3248{
3249 struct phy_led *phyled = to_phy_led(led_cdev);
3250 struct phy_device *phydev = phyled->phydev;
3251 int err;
3252
3253 mutex_lock(&phydev->lock);
3254 err = phydev->drv->led_blink_set(phydev, phyled->index,
3255 delay_on, delay_off);
3256 mutex_unlock(&phydev->lock);
3257
3258 return err;
3259}
3260
3261static __maybe_unused struct device *
3262phy_led_hw_control_get_device(struct led_classdev *led_cdev)
3263{
3264 struct phy_led *phyled = to_phy_led(led_cdev);
3265 struct phy_device *phydev = phyled->phydev;
3266
3267 if (phydev->attached_dev)
3268 return &phydev->attached_dev->dev;
3269 return NULL;
3270}
3271
3272static int __maybe_unused
3273phy_led_hw_control_get(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_get(phydev, phyled->index, rules);
3282 mutex_unlock(&phydev->lock);
3283
3284 return err;
3285}
3286
3287static int __maybe_unused
3288phy_led_hw_control_set(struct led_classdev *led_cdev,
3289 unsigned long rules)
3290{
3291 struct phy_led *phyled = to_phy_led(led_cdev);
3292 struct phy_device *phydev = phyled->phydev;
3293 int err;
3294
3295 mutex_lock(&phydev->lock);
3296 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules);
3297 mutex_unlock(&phydev->lock);
3298
3299 return err;
3300}
3301
3302static __maybe_unused int phy_led_hw_is_supported(struct led_classdev *led_cdev,
3303 unsigned long rules)
3304{
3305 struct phy_led *phyled = to_phy_led(led_cdev);
3306 struct phy_device *phydev = phyled->phydev;
3307 int err;
3308
3309 mutex_lock(&phydev->lock);
3310 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules);
3311 mutex_unlock(&phydev->lock);
3312
3313 return err;
3314}
3315
3316static void phy_leds_unregister(struct phy_device *phydev)
3317{
3318 struct phy_led *phyled, *tmp;
3319
3320 list_for_each_entry_safe(phyled, tmp, &phydev->leds, list) {
3321 led_classdev_unregister(&phyled->led_cdev);
3322 list_del(&phyled->list);
3323 }
3324}
3325
3326static int of_phy_led(struct phy_device *phydev,
3327 struct device_node *led)
3328{
3329 struct device *dev = &phydev->mdio.dev;
3330 struct led_init_data init_data = {};
3331 struct led_classdev *cdev;
3332 unsigned long modes = 0;
3333 struct phy_led *phyled;
3334 u32 index;
3335 int err;
3336
3337 phyled = devm_kzalloc(dev, sizeof(*phyled), GFP_KERNEL);
3338 if (!phyled)
3339 return -ENOMEM;
3340
3341 cdev = &phyled->led_cdev;
3342 phyled->phydev = phydev;
3343
3344 err = of_property_read_u32(led, "reg", &index);
3345 if (err)
3346 return err;
3347 if (index > U8_MAX)
3348 return -EINVAL;
3349
3350 if (of_property_read_bool(led, "active-high"))
3351 set_bit(PHY_LED_ACTIVE_HIGH, &modes);
3352 if (of_property_read_bool(led, "active-low"))
3353 set_bit(PHY_LED_ACTIVE_LOW, &modes);
3354 if (of_property_read_bool(led, "inactive-high-impedance"))
3355 set_bit(PHY_LED_INACTIVE_HIGH_IMPEDANCE, &modes);
3356
3357 if (WARN_ON(modes & BIT(PHY_LED_ACTIVE_LOW) &&
3358 modes & BIT(PHY_LED_ACTIVE_HIGH)))
3359 return -EINVAL;
3360
3361 if (modes) {
3362 /* Return error if asked to set polarity modes but not supported */
3363 if (!phydev->drv->led_polarity_set)
3364 return -EINVAL;
3365
3366 err = phydev->drv->led_polarity_set(phydev, index, modes);
3367 if (err)
3368 return err;
3369 }
3370
3371 phyled->index = index;
3372 if (phydev->drv->led_brightness_set)
3373 cdev->brightness_set_blocking = phy_led_set_brightness;
3374 if (phydev->drv->led_blink_set)
3375 cdev->blink_set = phy_led_blink_set;
3376
3377#ifdef CONFIG_LEDS_TRIGGERS
3378 if (phydev->drv->led_hw_is_supported &&
3379 phydev->drv->led_hw_control_set &&
3380 phydev->drv->led_hw_control_get) {
3381 cdev->hw_control_is_supported = phy_led_hw_is_supported;
3382 cdev->hw_control_set = phy_led_hw_control_set;
3383 cdev->hw_control_get = phy_led_hw_control_get;
3384 cdev->hw_control_trigger = "netdev";
3385 }
3386
3387 cdev->hw_control_get_device = phy_led_hw_control_get_device;
3388#endif
3389 cdev->max_brightness = 1;
3390 init_data.devicename = dev_name(&phydev->mdio.dev);
3391 init_data.fwnode = of_fwnode_handle(led);
3392 init_data.devname_mandatory = true;
3393
3394 err = led_classdev_register_ext(dev, cdev, &init_data);
3395 if (err)
3396 return err;
3397
3398 list_add(&phyled->list, &phydev->leds);
3399
3400 return 0;
3401}
3402
3403static int of_phy_leds(struct phy_device *phydev)
3404{
3405 struct device_node *node = phydev->mdio.dev.of_node;
3406 struct device_node *leds;
3407 int err;
3408
3409 if (!IS_ENABLED(CONFIG_OF_MDIO))
3410 return 0;
3411
3412 if (!node)
3413 return 0;
3414
3415 leds = of_get_child_by_name(node, "leds");
3416 if (!leds)
3417 return 0;
3418
3419 /* Check if the PHY driver have at least an OP to
3420 * set the LEDs.
3421 */
3422 if (!(phydev->drv->led_brightness_set ||
3423 phydev->drv->led_blink_set ||
3424 phydev->drv->led_hw_control_set)) {
3425 phydev_dbg(phydev, "ignoring leds node defined with no PHY driver support\n");
3426 goto exit;
3427 }
3428
3429 for_each_available_child_of_node_scoped(leds, led) {
3430 err = of_phy_led(phydev, led);
3431 if (err) {
3432 of_node_put(leds);
3433 phy_leds_unregister(phydev);
3434 return err;
3435 }
3436 }
3437
3438exit:
3439 of_node_put(leds);
3440 return 0;
3441}
3442
3443static void phy_cleanup_ports(struct phy_device *phydev)
3444{
3445 struct phy_port *tmp, *port;
3446
3447 list_for_each_entry_safe(port, tmp, &phydev->ports, head) {
3448 phy_del_port(phydev, port);
3449 phy_port_destroy(port);
3450 }
3451}
3452
3453static int phy_default_setup_single_port(struct phy_device *phydev)
3454{
3455 struct phy_port *port = phy_port_alloc();
3456 unsigned long mode;
3457
3458 if (!port)
3459 return -ENOMEM;
3460
3461 port->parent_type = PHY_PORT_PHY;
3462 port->phy = phydev;
3463
3464 /* Let the PHY driver know that this port was never described anywhere.
3465 * This is the usual case, where we assume single-port PHY devices with
3466 * no SFP. In that case, the port supports exactly the same thing as
3467 * the PHY itself.
3468 *
3469 * However, this can also be because we have a combo-port PHY, with
3470 * only one port described in DT, through SFP for example.
3471 *
3472 * In that case, the PHY driver will be in charge of saying what we can
3473 * do on that non-represented port.
3474 */
3475 port->not_described = true;
3476 linkmode_copy(port->supported, phydev->supported);
3477 port->mediums = phy_caps_mediums_from_linkmodes(port->supported);
3478
3479 for_each_set_bit(mode, port->supported, __ETHTOOL_LINK_MODE_MASK_NBITS)
3480 port->pairs = max_t(int, port->pairs,
3481 ethtool_linkmode_n_pairs(mode));
3482
3483 phy_add_port(phydev, port);
3484
3485 return 0;
3486}
3487
3488static int of_phy_ports(struct phy_device *phydev)
3489{
3490 struct device_node *node = phydev->mdio.dev.of_node;
3491 struct device_node *mdi;
3492 struct phy_port *port;
3493 int err;
3494
3495 if (!IS_ENABLED(CONFIG_OF_MDIO))
3496 return 0;
3497
3498 if (!node)
3499 return 0;
3500
3501 mdi = of_get_child_by_name(node, "mdi");
3502 if (!mdi)
3503 return 0;
3504
3505 for_each_available_child_of_node_scoped(mdi, port_node) {
3506 port = phy_of_parse_port(port_node);
3507 if (IS_ERR(port)) {
3508 err = PTR_ERR(port);
3509 goto out_err;
3510 }
3511
3512 port->parent_type = PHY_PORT_PHY;
3513 port->phy = phydev;
3514
3515 linkmode_copy(port->supported, phydev->supported);
3516
3517 err = phy_add_port(phydev, port);
3518 if (err) {
3519 phy_port_destroy(port);
3520 goto out_err;
3521 }
3522 }
3523 of_node_put(mdi);
3524
3525 return 0;
3526
3527out_err:
3528 phy_cleanup_ports(phydev);
3529 of_node_put(mdi);
3530 return err;
3531}
3532
3533static int phy_setup_ports(struct phy_device *phydev)
3534{
3535 __ETHTOOL_DECLARE_LINK_MODE_MASK(ports_supported);
3536 struct phy_port *port;
3537 int ret;
3538
3539 ret = of_phy_ports(phydev);
3540 if (ret)
3541 return ret;
3542
3543 /* We don't support SFP with genphy drivers. Also, genphy driver
3544 * binding occurs with RTNL help, which will deadlock the call to
3545 * sfp_bus_add_upstream().
3546 */
3547 if (!phydev->is_genphy_driven) {
3548 ret = phy_sfp_probe(phydev);
3549 if (ret)
3550 goto out;
3551 }
3552
3553 if (phydev->n_ports < phydev->max_n_ports) {
3554 ret = phy_default_setup_single_port(phydev);
3555 if (ret)
3556 goto out;
3557 }
3558
3559 linkmode_zero(ports_supported);
3560
3561 /* Aggregate the supported modes, which are made-up of :
3562 * - What the PHY itself supports
3563 * - What the sum of all ports support
3564 */
3565 list_for_each_entry(port, &phydev->ports, head)
3566 if (port->active)
3567 linkmode_or(ports_supported, ports_supported,
3568 port->supported);
3569
3570 if (!linkmode_empty(ports_supported))
3571 linkmode_and(phydev->supported, phydev->supported,
3572 ports_supported);
3573
3574 /* For now, the phy->port field is set as the first active port's type */
3575 list_for_each_entry(port, &phydev->ports, head)
3576 if (port->active) {
3577 phydev->port = phy_port_get_type(port);
3578 break;
3579 }
3580
3581 return 0;
3582
3583out:
3584 phy_cleanup_ports(phydev);
3585 return ret;
3586}
3587
3588/**
3589 * phy_get_sfp_port() - Returns the first valid SFP port of a PHY
3590 * @phydev: pointer to the PHY device to get the SFP port from
3591 *
3592 * Returns: The first active SFP (serdes) port of a PHY device, NULL if none
3593 * exist.
3594 */
3595struct phy_port *phy_get_sfp_port(struct phy_device *phydev)
3596{
3597 struct phy_port *port;
3598
3599 list_for_each_entry(port, &phydev->ports, head)
3600 if (port->active && port->is_sfp)
3601 return port;
3602
3603 return NULL;
3604}
3605EXPORT_SYMBOL_GPL(phy_get_sfp_port);
3606
3607/**
3608 * fwnode_mdio_find_device - Given a fwnode, find the mdio_device
3609 * @fwnode: pointer to the mdio_device's fwnode
3610 *
3611 * If successful, returns a pointer to the mdio_device with the embedded
3612 * struct device refcount incremented by one, or NULL on failure.
3613 * The caller should call put_device() on the mdio_device after its use.
3614 */
3615struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode)
3616{
3617 struct device *d;
3618
3619 if (!fwnode)
3620 return NULL;
3621
3622 d = bus_find_device_by_fwnode(&mdio_bus_type, fwnode);
3623 if (!d)
3624 return NULL;
3625
3626 return to_mdio_device(d);
3627}
3628EXPORT_SYMBOL(fwnode_mdio_find_device);
3629
3630/**
3631 * fwnode_phy_find_device - For provided phy_fwnode, find phy_device.
3632 *
3633 * @phy_fwnode: Pointer to the phy's fwnode.
3634 *
3635 * If successful, returns a pointer to the phy_device with the embedded
3636 * struct device refcount incremented by one, or NULL on failure.
3637 */
3638struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode)
3639{
3640 struct mdio_device *mdiodev;
3641
3642 mdiodev = fwnode_mdio_find_device(phy_fwnode);
3643 if (!mdiodev)
3644 return NULL;
3645
3646 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
3647 return to_phy_device(&mdiodev->dev);
3648
3649 put_device(&mdiodev->dev);
3650
3651 return NULL;
3652}
3653EXPORT_SYMBOL(fwnode_phy_find_device);
3654
3655/**
3656 * fwnode_get_phy_node - Get the phy_node using the named reference.
3657 * @fwnode: Pointer to fwnode from which phy_node has to be obtained.
3658 *
3659 * Refer return conditions of fwnode_find_reference().
3660 * For ACPI, only "phy-handle" is supported. Legacy DT properties "phy"
3661 * and "phy-device" are not supported in ACPI. DT supports all the three
3662 * named references to the phy node.
3663 */
3664struct fwnode_handle *fwnode_get_phy_node(const struct fwnode_handle *fwnode)
3665{
3666 struct fwnode_handle *phy_node;
3667
3668 /* Only phy-handle is used for ACPI */
3669 phy_node = fwnode_find_reference(fwnode, "phy-handle", 0);
3670 if (!IS_ERR(phy_node) || is_acpi_node(fwnode))
3671 return phy_node;
3672 phy_node = fwnode_find_reference(fwnode, "phy", 0);
3673 if (!IS_ERR(phy_node))
3674 return phy_node;
3675 return fwnode_find_reference(fwnode, "phy-device", 0);
3676}
3677EXPORT_SYMBOL_GPL(fwnode_get_phy_node);
3678
3679/**
3680 * phy_probe - probe and init a PHY device
3681 * @dev: device to probe and init
3682 *
3683 * Take care of setting up the phy_device structure, set the state to READY.
3684 */
3685static int phy_probe(struct device *dev)
3686{
3687 struct phy_device *phydev = to_phy_device(dev);
3688 struct device_driver *drv = phydev->mdio.dev.driver;
3689 struct phy_driver *phydrv = to_phy_driver(drv);
3690 int err = 0;
3691
3692 phydev->drv = phydrv;
3693
3694 /* Disable the interrupt if the PHY doesn't support it
3695 * but the interrupt is still a valid one
3696 */
3697 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
3698 phydev->irq = PHY_POLL;
3699
3700 if (phydrv->flags & PHY_IS_INTERNAL)
3701 phydev->is_internal = true;
3702
3703 /* Deassert the reset signal */
3704 phy_device_reset(phydev, 0);
3705
3706 if (phydev->drv->probe) {
3707 err = phydev->drv->probe(phydev);
3708 if (err)
3709 goto out;
3710 }
3711
3712 phy_disable_interrupts(phydev);
3713
3714 /* Start out supporting everything. Eventually,
3715 * a controller will attach, and may modify one
3716 * or both of these values
3717 */
3718 if (phydrv->features) {
3719 linkmode_copy(phydev->supported, phydrv->features);
3720 genphy_c45_read_eee_abilities(phydev);
3721 }
3722 else if (phydrv->get_features)
3723 err = phydrv->get_features(phydev);
3724 else if (phydev->is_c45)
3725 err = genphy_c45_pma_read_abilities(phydev);
3726 else
3727 err = genphy_read_abilities(phydev);
3728
3729 if (err)
3730 goto out;
3731
3732 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
3733 phydev->supported))
3734 phydev->autoneg = 0;
3735
3736 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
3737 phydev->supported))
3738 phydev->is_gigabit_capable = 1;
3739 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
3740 phydev->supported))
3741 phydev->is_gigabit_capable = 1;
3742
3743 of_set_phy_supported(phydev);
3744
3745 err = phy_setup_ports(phydev);
3746 if (err)
3747 goto out;
3748
3749 phy_advertise_supported(phydev);
3750
3751 /* Get PHY default EEE advertising modes and handle them as potentially
3752 * safe initial configuration.
3753 */
3754 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee);
3755 if (err)
3756 goto out;
3757
3758 /* Get the EEE modes we want to prohibit. */
3759 of_set_phy_eee_broken(phydev);
3760
3761 /* Some PHYs may advertise, by default, not support EEE modes. So,
3762 * we need to clean them. In addition remove all disabled EEE modes.
3763 */
3764 linkmode_and(phydev->advertising_eee, phydev->supported_eee,
3765 phydev->advertising_eee);
3766 linkmode_andnot(phydev->advertising_eee, phydev->advertising_eee,
3767 phydev->eee_disabled_modes);
3768
3769 /* There is no "enabled" flag. If PHY is advertising, assume it is
3770 * kind of enabled.
3771 */
3772 phydev->eee_cfg.eee_enabled = !linkmode_empty(phydev->advertising_eee);
3773
3774 /* Get master/slave strap overrides */
3775 of_set_phy_timing_role(phydev);
3776
3777 /* The Pause Frame bits indicate that the PHY can support passing
3778 * pause frames. During autonegotiation, the PHYs will determine if
3779 * they should allow pause frames to pass. The MAC driver should then
3780 * use that result to determine whether to enable flow control via
3781 * pause frames.
3782 *
3783 * Normally, PHY drivers should not set the Pause bits, and instead
3784 * allow phylib to do that. However, there may be some situations
3785 * (e.g. hardware erratum) where the driver wants to set only one
3786 * of these bits.
3787 */
3788 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
3789 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
3790 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3791 phydev->supported);
3792 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3793 phydev->supported);
3794 }
3795
3796 /* Set the state to READY by default */
3797 phydev->state = PHY_READY;
3798
3799 /* Register the PHY LED triggers */
3800 if (!phydev->is_on_sfp_module)
3801 phy_led_triggers_register(phydev);
3802
3803 /* Get the LEDs from the device tree, and instantiate standard
3804 * LEDs for them.
3805 */
3806 if (IS_ENABLED(CONFIG_PHYLIB_LEDS) && !phy_driver_is_genphy(phydev)) {
3807 err = of_phy_leds(phydev);
3808 if (err)
3809 goto out;
3810 }
3811
3812 return 0;
3813
3814out:
3815 sfp_bus_del_upstream(phydev->sfp_bus);
3816 phydev->sfp_bus = NULL;
3817
3818 phy_cleanup_ports(phydev);
3819
3820 if (!phydev->is_on_sfp_module)
3821 phy_led_triggers_unregister(phydev);
3822
3823 /* Re-assert the reset signal on error */
3824 phy_device_reset(phydev, 1);
3825
3826 return err;
3827}
3828
3829static int phy_remove(struct device *dev)
3830{
3831 struct phy_device *phydev = to_phy_device(dev);
3832
3833 cancel_delayed_work_sync(&phydev->state_queue);
3834
3835 if (IS_ENABLED(CONFIG_PHYLIB_LEDS) && !phy_driver_is_genphy(phydev))
3836 phy_leds_unregister(phydev);
3837
3838 if (!phydev->is_on_sfp_module)
3839 phy_led_triggers_unregister(phydev);
3840
3841 phydev->state = PHY_DOWN;
3842
3843 sfp_bus_del_upstream(phydev->sfp_bus);
3844 phydev->sfp_bus = NULL;
3845
3846 phy_cleanup_ports(phydev);
3847
3848 if (phydev->drv && phydev->drv->remove)
3849 phydev->drv->remove(phydev);
3850
3851 /* Assert the reset signal */
3852 phy_device_reset(phydev, 1);
3853
3854 phydev->drv = NULL;
3855
3856 return 0;
3857}
3858
3859/**
3860 * phy_driver_register - register a phy_driver with the PHY layer
3861 * @new_driver: new phy_driver to register
3862 * @owner: module owning this PHY
3863 */
3864static int phy_driver_register(struct phy_driver *new_driver,
3865 struct module *owner)
3866{
3867 int retval;
3868
3869 /* Either the features are hard coded, or dynamically
3870 * determined. It cannot be both.
3871 */
3872 if (WARN_ON(new_driver->features && new_driver->get_features)) {
3873 pr_err("%s: features and get_features must not both be set\n",
3874 new_driver->name);
3875 return -EINVAL;
3876 }
3877
3878 /* PHYLIB device drivers must not match using a DT compatible table
3879 * as this bypasses our checks that the mdiodev that is being matched
3880 * is backed by a struct phy_device. If such a case happens, we will
3881 * make out-of-bounds accesses and lockup in phydev->lock.
3882 */
3883 if (WARN(new_driver->mdiodrv.driver.of_match_table,
3884 "%s: driver must not provide a DT match table\n",
3885 new_driver->name))
3886 return -EINVAL;
3887
3888 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
3889 new_driver->mdiodrv.driver.name = new_driver->name;
3890 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
3891 new_driver->mdiodrv.driver.probe = phy_probe;
3892 new_driver->mdiodrv.driver.remove = phy_remove;
3893 new_driver->mdiodrv.driver.owner = owner;
3894 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
3895
3896 retval = driver_register(&new_driver->mdiodrv.driver);
3897 if (retval) {
3898 pr_err("%s: Error %d in registering driver\n",
3899 new_driver->name, retval);
3900
3901 return retval;
3902 }
3903
3904 pr_debug("%s: Registered new driver\n", new_driver->name);
3905
3906 return 0;
3907}
3908
3909static void phy_driver_unregister(struct phy_driver *drv)
3910{
3911 driver_unregister(&drv->mdiodrv.driver);
3912}
3913
3914int phy_drivers_register(struct phy_driver *new_driver, int n,
3915 struct module *owner)
3916{
3917 int i, ret = 0;
3918
3919 for (i = 0; i < n; i++) {
3920 ret = phy_driver_register(new_driver + i, owner);
3921 if (ret) {
3922 while (i-- > 0)
3923 phy_driver_unregister(new_driver + i);
3924 break;
3925 }
3926 }
3927 return ret;
3928}
3929EXPORT_SYMBOL(phy_drivers_register);
3930
3931void phy_drivers_unregister(struct phy_driver *drv, int n)
3932{
3933 int i;
3934
3935 for (i = 0; i < n; i++)
3936 phy_driver_unregister(drv + i);
3937}
3938EXPORT_SYMBOL(phy_drivers_unregister);
3939
3940static struct phy_driver genphy_driver = {
3941 .phy_id = 0xffffffff,
3942 .phy_id_mask = 0xffffffff,
3943 .name = "Generic PHY",
3944 .get_features = genphy_read_abilities,
3945 .suspend = genphy_suspend,
3946 .resume = genphy_resume,
3947 .set_loopback = genphy_loopback,
3948};
3949
3950static const struct ethtool_phy_ops phy_ethtool_phy_ops = {
3951 .get_sset_count = phy_ethtool_get_sset_count,
3952 .get_strings = phy_ethtool_get_strings,
3953 .get_stats = phy_ethtool_get_stats,
3954 .get_plca_cfg = phy_ethtool_get_plca_cfg,
3955 .set_plca_cfg = phy_ethtool_set_plca_cfg,
3956 .get_plca_status = phy_ethtool_get_plca_status,
3957 .start_cable_test = phy_start_cable_test,
3958 .start_cable_test_tdr = phy_start_cable_test_tdr,
3959};
3960
3961static const struct phylib_stubs __phylib_stubs = {
3962 .hwtstamp_get = __phy_hwtstamp_get,
3963 .hwtstamp_set = __phy_hwtstamp_set,
3964 .get_phy_stats = __phy_ethtool_get_phy_stats,
3965 .get_link_ext_stats = __phy_ethtool_get_link_ext_stats,
3966};
3967
3968static void phylib_register_stubs(void)
3969{
3970 phylib_stubs = &__phylib_stubs;
3971}
3972
3973static void phylib_unregister_stubs(void)
3974{
3975 phylib_stubs = NULL;
3976}
3977
3978static int __init phy_init(void)
3979{
3980 int rc;
3981
3982 rc = class_register(&mdio_bus_class);
3983 if (rc)
3984 return rc;
3985
3986 rc = bus_register(&mdio_bus_type);
3987 if (rc)
3988 goto err_class;
3989
3990 rtnl_lock();
3991 ethtool_set_ethtool_phy_ops(&phy_ethtool_phy_ops);
3992 phylib_register_stubs();
3993 rtnl_unlock();
3994
3995 rc = phy_caps_init();
3996 if (rc)
3997 goto err_ethtool_phy_ops;
3998
3999 features_init();
4000
4001 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
4002 if (rc)
4003 goto err_ethtool_phy_ops;
4004
4005 rc = phy_driver_register(&genphy_driver, THIS_MODULE);
4006 if (rc)
4007 goto err_c45;
4008
4009 return 0;
4010
4011err_c45:
4012 phy_driver_unregister(&genphy_c45_driver);
4013err_ethtool_phy_ops:
4014 rtnl_lock();
4015 phylib_unregister_stubs();
4016 ethtool_set_ethtool_phy_ops(NULL);
4017 rtnl_unlock();
4018 bus_unregister(&mdio_bus_type);
4019err_class:
4020 class_unregister(&mdio_bus_class);
4021
4022 return rc;
4023}
4024
4025static void __exit phy_exit(void)
4026{
4027 phy_driver_unregister(&genphy_c45_driver);
4028 phy_driver_unregister(&genphy_driver);
4029 rtnl_lock();
4030 phylib_unregister_stubs();
4031 ethtool_set_ethtool_phy_ops(NULL);
4032 rtnl_unlock();
4033 bus_unregister(&mdio_bus_type);
4034 class_unregister(&mdio_bus_class);
4035}
4036
4037subsys_initcall(phy_init);
4038module_exit(phy_exit);