1 // SPDX-License-Identifier: GPL-2.0+
2 /* Framework for finding and configuring PHYs.
3 * Also contains generic PHY driver
7 * Copyright (c) 2004 Freescale Semiconductor, Inc.
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/kernel.h>
13 #include <linux/string.h>
14 #include <linux/errno.h>
15 #include <linux/unistd.h>
16 #include <linux/slab.h>
17 #include <linux/interrupt.h>
18 #include <linux/init.h>
19 #include <linux/delay.h>
20 #include <linux/netdevice.h>
21 #include <linux/etherdevice.h>
22 #include <linux/skbuff.h>
24 #include <linux/module.h>
25 #include <linux/mii.h>
26 #include <linux/ethtool.h>
27 #include <linux/bitmap.h>
28 #include <linux/phy.h>
29 #include <linux/phy_led_triggers.h>
30 #include <linux/sfp.h>
31 #include <linux/mdio.h>
33 #include <linux/uaccess.h>
35 MODULE_DESCRIPTION("PHY library");
36 MODULE_AUTHOR("Andy Fleming");
37 MODULE_LICENSE("GPL");
39 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features
) __ro_after_init
;
40 EXPORT_SYMBOL_GPL(phy_basic_features
);
42 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features
) __ro_after_init
;
43 EXPORT_SYMBOL_GPL(phy_basic_t1_features
);
45 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features
) __ro_after_init
;
46 EXPORT_SYMBOL_GPL(phy_gbit_features
);
48 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features
) __ro_after_init
;
49 EXPORT_SYMBOL_GPL(phy_gbit_fibre_features
);
51 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features
) __ro_after_init
;
52 EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features
);
54 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features
) __ro_after_init
;
55 EXPORT_SYMBOL_GPL(phy_10gbit_features
);
57 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features
) __ro_after_init
;
58 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features
);
60 const int phy_basic_ports_array
[3] = {
61 ETHTOOL_LINK_MODE_Autoneg_BIT
,
62 ETHTOOL_LINK_MODE_TP_BIT
,
63 ETHTOOL_LINK_MODE_MII_BIT
,
65 EXPORT_SYMBOL_GPL(phy_basic_ports_array
);
67 const int phy_fibre_port_array
[1] = {
68 ETHTOOL_LINK_MODE_FIBRE_BIT
,
70 EXPORT_SYMBOL_GPL(phy_fibre_port_array
);
72 const int phy_all_ports_features_array
[7] = {
73 ETHTOOL_LINK_MODE_Autoneg_BIT
,
74 ETHTOOL_LINK_MODE_TP_BIT
,
75 ETHTOOL_LINK_MODE_MII_BIT
,
76 ETHTOOL_LINK_MODE_FIBRE_BIT
,
77 ETHTOOL_LINK_MODE_AUI_BIT
,
78 ETHTOOL_LINK_MODE_BNC_BIT
,
79 ETHTOOL_LINK_MODE_Backplane_BIT
,
81 EXPORT_SYMBOL_GPL(phy_all_ports_features_array
);
83 const int phy_10_100_features_array
[4] = {
84 ETHTOOL_LINK_MODE_10baseT_Half_BIT
,
85 ETHTOOL_LINK_MODE_10baseT_Full_BIT
,
86 ETHTOOL_LINK_MODE_100baseT_Half_BIT
,
87 ETHTOOL_LINK_MODE_100baseT_Full_BIT
,
89 EXPORT_SYMBOL_GPL(phy_10_100_features_array
);
91 const int phy_basic_t1_features_array
[2] = {
92 ETHTOOL_LINK_MODE_TP_BIT
,
93 ETHTOOL_LINK_MODE_100baseT1_Full_BIT
,
95 EXPORT_SYMBOL_GPL(phy_basic_t1_features_array
);
97 const int phy_gbit_features_array
[2] = {
98 ETHTOOL_LINK_MODE_1000baseT_Half_BIT
,
99 ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
101 EXPORT_SYMBOL_GPL(phy_gbit_features_array
);
103 const int phy_10gbit_features_array
[1] = {
104 ETHTOOL_LINK_MODE_10000baseT_Full_BIT
,
106 EXPORT_SYMBOL_GPL(phy_10gbit_features_array
);
108 const int phy_10gbit_fec_features_array
[1] = {
109 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT
,
111 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array
);
113 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features
) __ro_after_init
;
114 EXPORT_SYMBOL_GPL(phy_10gbit_full_features
);
116 static const int phy_10gbit_full_features_array
[] = {
117 ETHTOOL_LINK_MODE_10baseT_Full_BIT
,
118 ETHTOOL_LINK_MODE_100baseT_Full_BIT
,
119 ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
120 ETHTOOL_LINK_MODE_10000baseT_Full_BIT
,
123 static void features_init(void)
125 /* 10/100 half/full*/
126 linkmode_set_bit_array(phy_basic_ports_array
,
127 ARRAY_SIZE(phy_basic_ports_array
),
129 linkmode_set_bit_array(phy_10_100_features_array
,
130 ARRAY_SIZE(phy_10_100_features_array
),
134 linkmode_set_bit_array(phy_basic_t1_features_array
,
135 ARRAY_SIZE(phy_basic_t1_features_array
),
136 phy_basic_t1_features
);
138 /* 10/100 half/full + 1000 half/full */
139 linkmode_set_bit_array(phy_basic_ports_array
,
140 ARRAY_SIZE(phy_basic_ports_array
),
142 linkmode_set_bit_array(phy_10_100_features_array
,
143 ARRAY_SIZE(phy_10_100_features_array
),
145 linkmode_set_bit_array(phy_gbit_features_array
,
146 ARRAY_SIZE(phy_gbit_features_array
),
149 /* 10/100 half/full + 1000 half/full + fibre*/
150 linkmode_set_bit_array(phy_basic_ports_array
,
151 ARRAY_SIZE(phy_basic_ports_array
),
152 phy_gbit_fibre_features
);
153 linkmode_set_bit_array(phy_10_100_features_array
,
154 ARRAY_SIZE(phy_10_100_features_array
),
155 phy_gbit_fibre_features
);
156 linkmode_set_bit_array(phy_gbit_features_array
,
157 ARRAY_SIZE(phy_gbit_features_array
),
158 phy_gbit_fibre_features
);
159 linkmode_set_bit_array(phy_fibre_port_array
,
160 ARRAY_SIZE(phy_fibre_port_array
),
161 phy_gbit_fibre_features
);
163 /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
164 linkmode_set_bit_array(phy_all_ports_features_array
,
165 ARRAY_SIZE(phy_all_ports_features_array
),
166 phy_gbit_all_ports_features
);
167 linkmode_set_bit_array(phy_10_100_features_array
,
168 ARRAY_SIZE(phy_10_100_features_array
),
169 phy_gbit_all_ports_features
);
170 linkmode_set_bit_array(phy_gbit_features_array
,
171 ARRAY_SIZE(phy_gbit_features_array
),
172 phy_gbit_all_ports_features
);
174 /* 10/100 half/full + 1000 half/full + 10G full*/
175 linkmode_set_bit_array(phy_all_ports_features_array
,
176 ARRAY_SIZE(phy_all_ports_features_array
),
177 phy_10gbit_features
);
178 linkmode_set_bit_array(phy_10_100_features_array
,
179 ARRAY_SIZE(phy_10_100_features_array
),
180 phy_10gbit_features
);
181 linkmode_set_bit_array(phy_gbit_features_array
,
182 ARRAY_SIZE(phy_gbit_features_array
),
183 phy_10gbit_features
);
184 linkmode_set_bit_array(phy_10gbit_features_array
,
185 ARRAY_SIZE(phy_10gbit_features_array
),
186 phy_10gbit_features
);
188 /* 10/100/1000/10G full */
189 linkmode_set_bit_array(phy_all_ports_features_array
,
190 ARRAY_SIZE(phy_all_ports_features_array
),
191 phy_10gbit_full_features
);
192 linkmode_set_bit_array(phy_10gbit_full_features_array
,
193 ARRAY_SIZE(phy_10gbit_full_features_array
),
194 phy_10gbit_full_features
);
196 linkmode_set_bit_array(phy_10gbit_fec_features_array
,
197 ARRAY_SIZE(phy_10gbit_fec_features_array
),
198 phy_10gbit_fec_features
);
201 void phy_device_free(struct phy_device
*phydev
)
203 put_device(&phydev
->mdio
.dev
);
205 EXPORT_SYMBOL(phy_device_free
);
207 static void phy_mdio_device_free(struct mdio_device
*mdiodev
)
209 struct phy_device
*phydev
;
211 phydev
= container_of(mdiodev
, struct phy_device
, mdio
);
212 phy_device_free(phydev
);
215 static void phy_device_release(struct device
*dev
)
217 kfree(to_phy_device(dev
));
220 static void phy_mdio_device_remove(struct mdio_device
*mdiodev
)
222 struct phy_device
*phydev
;
224 phydev
= container_of(mdiodev
, struct phy_device
, mdio
);
225 phy_device_remove(phydev
);
228 static struct phy_driver genphy_driver
;
229 extern struct phy_driver genphy_c45_driver
;
231 static LIST_HEAD(phy_fixup_list
);
232 static DEFINE_MUTEX(phy_fixup_lock
);
235 static bool mdio_bus_phy_may_suspend(struct phy_device
*phydev
)
237 struct device_driver
*drv
= phydev
->mdio
.dev
.driver
;
238 struct phy_driver
*phydrv
= to_phy_driver(drv
);
239 struct net_device
*netdev
= phydev
->attached_dev
;
241 if (!drv
|| !phydrv
->suspend
)
244 /* PHY not attached? May suspend if the PHY has not already been
245 * suspended as part of a prior call to phy_disconnect() ->
246 * phy_detach() -> phy_suspend() because the parent netdev might be the
247 * MDIO bus driver and clock gated at this point.
252 if (netdev
->wol_enabled
)
255 /* As long as not all affected network drivers support the
256 * wol_enabled flag, let's check for hints that WoL is enabled.
257 * Don't suspend PHY if the attached netdev parent may wake up.
258 * The parent may point to a PCI device, as in tg3 driver.
260 if (netdev
->dev
.parent
&& device_may_wakeup(netdev
->dev
.parent
))
263 /* Also don't suspend PHY if the netdev itself may wakeup. This
264 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
267 if (device_may_wakeup(&netdev
->dev
))
271 return !phydev
->suspended
;
274 static int mdio_bus_phy_suspend(struct device
*dev
)
276 struct phy_device
*phydev
= to_phy_device(dev
);
278 /* We must stop the state machine manually, otherwise it stops out of
279 * control, possibly with the phydev->lock held. Upon resume, netdev
280 * may call phy routines that try to grab the same lock, and that may
281 * lead to a deadlock.
283 if (phydev
->attached_dev
&& phydev
->adjust_link
)
284 phy_stop_machine(phydev
);
286 if (!mdio_bus_phy_may_suspend(phydev
))
289 phydev
->suspended_by_mdio_bus
= 1;
291 return phy_suspend(phydev
);
294 static int mdio_bus_phy_resume(struct device
*dev
)
296 struct phy_device
*phydev
= to_phy_device(dev
);
299 if (!phydev
->suspended_by_mdio_bus
)
302 phydev
->suspended_by_mdio_bus
= 0;
304 ret
= phy_resume(phydev
);
309 if (phydev
->attached_dev
&& phydev
->adjust_link
)
310 phy_start_machine(phydev
);
315 static int mdio_bus_phy_restore(struct device
*dev
)
317 struct phy_device
*phydev
= to_phy_device(dev
);
318 struct net_device
*netdev
= phydev
->attached_dev
;
324 ret
= phy_init_hw(phydev
);
328 if (phydev
->attached_dev
&& phydev
->adjust_link
)
329 phy_start_machine(phydev
);
334 static const struct dev_pm_ops mdio_bus_phy_pm_ops
= {
335 .suspend
= mdio_bus_phy_suspend
,
336 .resume
= mdio_bus_phy_resume
,
337 .freeze
= mdio_bus_phy_suspend
,
338 .thaw
= mdio_bus_phy_resume
,
339 .restore
= mdio_bus_phy_restore
,
342 #define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
346 #define MDIO_BUS_PHY_PM_OPS NULL
348 #endif /* CONFIG_PM */
351 * phy_register_fixup - creates a new phy_fixup and adds it to the list
352 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
353 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
354 * It can also be PHY_ANY_UID
355 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
357 * @run: The actual code to be run when a matching PHY is found
359 int phy_register_fixup(const char *bus_id
, u32 phy_uid
, u32 phy_uid_mask
,
360 int (*run
)(struct phy_device
*))
362 struct phy_fixup
*fixup
= kzalloc(sizeof(*fixup
), GFP_KERNEL
);
367 strlcpy(fixup
->bus_id
, bus_id
, sizeof(fixup
->bus_id
));
368 fixup
->phy_uid
= phy_uid
;
369 fixup
->phy_uid_mask
= phy_uid_mask
;
372 mutex_lock(&phy_fixup_lock
);
373 list_add_tail(&fixup
->list
, &phy_fixup_list
);
374 mutex_unlock(&phy_fixup_lock
);
378 EXPORT_SYMBOL(phy_register_fixup
);
380 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
381 int phy_register_fixup_for_uid(u32 phy_uid
, u32 phy_uid_mask
,
382 int (*run
)(struct phy_device
*))
384 return phy_register_fixup(PHY_ANY_ID
, phy_uid
, phy_uid_mask
, run
);
386 EXPORT_SYMBOL(phy_register_fixup_for_uid
);
388 /* Registers a fixup to be run on the PHY with id string bus_id */
389 int phy_register_fixup_for_id(const char *bus_id
,
390 int (*run
)(struct phy_device
*))
392 return phy_register_fixup(bus_id
, PHY_ANY_UID
, 0xffffffff, run
);
394 EXPORT_SYMBOL(phy_register_fixup_for_id
);
397 * phy_unregister_fixup - remove a phy_fixup from the list
398 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
399 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
400 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
402 int phy_unregister_fixup(const char *bus_id
, u32 phy_uid
, u32 phy_uid_mask
)
404 struct list_head
*pos
, *n
;
405 struct phy_fixup
*fixup
;
410 mutex_lock(&phy_fixup_lock
);
411 list_for_each_safe(pos
, n
, &phy_fixup_list
) {
412 fixup
= list_entry(pos
, struct phy_fixup
, list
);
414 if ((!strcmp(fixup
->bus_id
, bus_id
)) &&
415 ((fixup
->phy_uid
& phy_uid_mask
) ==
416 (phy_uid
& phy_uid_mask
))) {
417 list_del(&fixup
->list
);
423 mutex_unlock(&phy_fixup_lock
);
427 EXPORT_SYMBOL(phy_unregister_fixup
);
429 /* Unregisters a fixup of any PHY with the UID in phy_uid */
430 int phy_unregister_fixup_for_uid(u32 phy_uid
, u32 phy_uid_mask
)
432 return phy_unregister_fixup(PHY_ANY_ID
, phy_uid
, phy_uid_mask
);
434 EXPORT_SYMBOL(phy_unregister_fixup_for_uid
);
436 /* Unregisters a fixup of the PHY with id string bus_id */
437 int phy_unregister_fixup_for_id(const char *bus_id
)
439 return phy_unregister_fixup(bus_id
, PHY_ANY_UID
, 0xffffffff);
441 EXPORT_SYMBOL(phy_unregister_fixup_for_id
);
443 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
444 * Fixups can be set to match any in one or more fields.
446 static int phy_needs_fixup(struct phy_device
*phydev
, struct phy_fixup
*fixup
)
448 if (strcmp(fixup
->bus_id
, phydev_name(phydev
)) != 0)
449 if (strcmp(fixup
->bus_id
, PHY_ANY_ID
) != 0)
452 if ((fixup
->phy_uid
& fixup
->phy_uid_mask
) !=
453 (phydev
->phy_id
& fixup
->phy_uid_mask
))
454 if (fixup
->phy_uid
!= PHY_ANY_UID
)
460 /* Runs any matching fixups for this phydev */
461 static int phy_scan_fixups(struct phy_device
*phydev
)
463 struct phy_fixup
*fixup
;
465 mutex_lock(&phy_fixup_lock
);
466 list_for_each_entry(fixup
, &phy_fixup_list
, list
) {
467 if (phy_needs_fixup(phydev
, fixup
)) {
468 int err
= fixup
->run(phydev
);
471 mutex_unlock(&phy_fixup_lock
);
474 phydev
->has_fixups
= true;
477 mutex_unlock(&phy_fixup_lock
);
482 static int phy_bus_match(struct device
*dev
, struct device_driver
*drv
)
484 struct phy_device
*phydev
= to_phy_device(dev
);
485 struct phy_driver
*phydrv
= to_phy_driver(drv
);
486 const int num_ids
= ARRAY_SIZE(phydev
->c45_ids
.device_ids
);
489 if (!(phydrv
->mdiodrv
.flags
& MDIO_DEVICE_IS_PHY
))
492 if (phydrv
->match_phy_device
)
493 return phydrv
->match_phy_device(phydev
);
495 if (phydev
->is_c45
) {
496 for (i
= 1; i
< num_ids
; i
++) {
497 if (phydev
->c45_ids
.device_ids
[i
] == 0xffffffff)
500 if ((phydrv
->phy_id
& phydrv
->phy_id_mask
) ==
501 (phydev
->c45_ids
.device_ids
[i
] &
502 phydrv
->phy_id_mask
))
507 return (phydrv
->phy_id
& phydrv
->phy_id_mask
) ==
508 (phydev
->phy_id
& phydrv
->phy_id_mask
);
513 phy_id_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
515 struct phy_device
*phydev
= to_phy_device(dev
);
517 return sprintf(buf
, "0x%.8lx\n", (unsigned long)phydev
->phy_id
);
519 static DEVICE_ATTR_RO(phy_id
);
522 phy_interface_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
524 struct phy_device
*phydev
= to_phy_device(dev
);
525 const char *mode
= NULL
;
527 if (phy_is_internal(phydev
))
530 mode
= phy_modes(phydev
->interface
);
532 return sprintf(buf
, "%s\n", mode
);
534 static DEVICE_ATTR_RO(phy_interface
);
537 phy_has_fixups_show(struct device
*dev
, struct device_attribute
*attr
,
540 struct phy_device
*phydev
= to_phy_device(dev
);
542 return sprintf(buf
, "%d\n", phydev
->has_fixups
);
544 static DEVICE_ATTR_RO(phy_has_fixups
);
546 static struct attribute
*phy_dev_attrs
[] = {
547 &dev_attr_phy_id
.attr
,
548 &dev_attr_phy_interface
.attr
,
549 &dev_attr_phy_has_fixups
.attr
,
552 ATTRIBUTE_GROUPS(phy_dev
);
554 static const struct device_type mdio_bus_phy_type
= {
556 .groups
= phy_dev_groups
,
557 .release
= phy_device_release
,
558 .pm
= MDIO_BUS_PHY_PM_OPS
,
561 static int phy_request_driver_module(struct phy_device
*dev
, u32 phy_id
)
565 ret
= request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT
,
566 MDIO_ID_ARGS(phy_id
));
567 /* We only check for failures in executing the usermode binary,
568 * not whether a PHY driver module exists for the PHY ID.
569 * Accept -ENOENT because this may occur in case no initramfs exists,
570 * then modprobe isn't available.
572 if (IS_ENABLED(CONFIG_MODULES
) && ret
< 0 && ret
!= -ENOENT
) {
573 phydev_err(dev
, "error %d loading PHY driver module for ID 0x%08lx\n",
574 ret
, (unsigned long)phy_id
);
581 struct phy_device
*phy_device_create(struct mii_bus
*bus
, int addr
, u32 phy_id
,
583 struct phy_c45_device_ids
*c45_ids
)
585 struct phy_device
*dev
;
586 struct mdio_device
*mdiodev
;
589 /* We allocate the device, and initialize the default values */
590 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
592 return ERR_PTR(-ENOMEM
);
594 mdiodev
= &dev
->mdio
;
595 mdiodev
->dev
.parent
= &bus
->dev
;
596 mdiodev
->dev
.bus
= &mdio_bus_type
;
597 mdiodev
->dev
.type
= &mdio_bus_phy_type
;
599 mdiodev
->bus_match
= phy_bus_match
;
600 mdiodev
->addr
= addr
;
601 mdiodev
->flags
= MDIO_DEVICE_FLAG_PHY
;
602 mdiodev
->device_free
= phy_mdio_device_free
;
603 mdiodev
->device_remove
= phy_mdio_device_remove
;
605 dev
->speed
= SPEED_UNKNOWN
;
606 dev
->duplex
= DUPLEX_UNKNOWN
;
610 dev
->interface
= PHY_INTERFACE_MODE_GMII
;
612 dev
->autoneg
= AUTONEG_ENABLE
;
614 dev
->is_c45
= is_c45
;
615 dev
->phy_id
= phy_id
;
617 dev
->c45_ids
= *c45_ids
;
618 dev
->irq
= bus
->irq
[addr
];
619 dev_set_name(&mdiodev
->dev
, PHY_ID_FMT
, bus
->id
, addr
);
621 dev
->state
= PHY_DOWN
;
623 mutex_init(&dev
->lock
);
624 INIT_DELAYED_WORK(&dev
->state_queue
, phy_state_machine
);
626 /* Request the appropriate module unconditionally; don't
627 * bother trying to do so only if it isn't already loaded,
628 * because that gets complicated. A hotplug event would have
629 * done an unconditional modprobe anyway.
630 * We don't do normal hotplug because it won't work for MDIO
631 * -- because it relies on the device staying around for long
632 * enough for the driver to get loaded. With MDIO, the NIC
633 * driver will get bored and give up as soon as it finds that
634 * there's no driver _already_ loaded.
636 if (is_c45
&& c45_ids
) {
637 const int num_ids
= ARRAY_SIZE(c45_ids
->device_ids
);
640 for (i
= 1; i
< num_ids
; i
++) {
641 if (c45_ids
->device_ids
[i
] == 0xffffffff)
644 ret
= phy_request_driver_module(dev
,
645 c45_ids
->device_ids
[i
]);
650 ret
= phy_request_driver_module(dev
, phy_id
);
654 device_initialize(&mdiodev
->dev
);
662 EXPORT_SYMBOL(phy_device_create
);
664 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
665 * @bus: the target MII bus
666 * @addr: PHY address on the MII bus
667 * @dev_addr: MMD address in the PHY.
668 * @devices_in_package: where to store the devices in package information.
670 * Description: reads devices in package registers of a MMD at @dev_addr
671 * from PHY at @addr on @bus.
673 * Returns: 0 on success, -EIO on failure.
675 static int get_phy_c45_devs_in_pkg(struct mii_bus
*bus
, int addr
, int dev_addr
,
676 u32
*devices_in_package
)
678 int phy_reg
, reg_addr
;
680 reg_addr
= MII_ADDR_C45
| dev_addr
<< 16 | MDIO_DEVS2
;
681 phy_reg
= mdiobus_read(bus
, addr
, reg_addr
);
684 *devices_in_package
= phy_reg
<< 16;
686 reg_addr
= MII_ADDR_C45
| dev_addr
<< 16 | MDIO_DEVS1
;
687 phy_reg
= mdiobus_read(bus
, addr
, reg_addr
);
690 *devices_in_package
|= phy_reg
;
692 /* Bit 0 doesn't represent a device, it indicates c22 regs presence */
693 *devices_in_package
&= ~BIT(0);
699 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
700 * @bus: the target MII bus
701 * @addr: PHY address on the MII bus
702 * @phy_id: where to store the ID retrieved.
703 * @c45_ids: where to store the c45 ID information.
705 * If the PHY devices-in-package appears to be valid, it and the
706 * corresponding identifiers are stored in @c45_ids, zero is stored
707 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
711 static int get_phy_c45_ids(struct mii_bus
*bus
, int addr
, u32
*phy_id
,
712 struct phy_c45_device_ids
*c45_ids
) {
715 const int num_ids
= ARRAY_SIZE(c45_ids
->device_ids
);
716 u32
*devs
= &c45_ids
->devices_in_package
;
718 /* Find first non-zero Devices In package. Device zero is reserved
719 * for 802.3 c45 complied PHYs, so don't probe it at first.
721 for (i
= 1; i
< num_ids
&& *devs
== 0; i
++) {
722 phy_reg
= get_phy_c45_devs_in_pkg(bus
, addr
, i
, devs
);
726 if ((*devs
& 0x1fffffff) == 0x1fffffff) {
727 /* If mostly Fs, there is no device there,
728 * then let's continue to probe more, as some
729 * 10G PHYs have zero Devices In package,
730 * e.g. Cortina CS4315/CS4340 PHY.
732 phy_reg
= get_phy_c45_devs_in_pkg(bus
, addr
, 0, devs
);
735 /* no device there, let's get out of here */
736 if ((*devs
& 0x1fffffff) == 0x1fffffff) {
737 *phy_id
= 0xffffffff;
745 /* Now probe Device Identifiers for each device present. */
746 for (i
= 1; i
< num_ids
; i
++) {
747 if (!(c45_ids
->devices_in_package
& (1 << i
)))
750 reg_addr
= MII_ADDR_C45
| i
<< 16 | MII_PHYSID1
;
751 phy_reg
= mdiobus_read(bus
, addr
, reg_addr
);
754 c45_ids
->device_ids
[i
] = phy_reg
<< 16;
756 reg_addr
= MII_ADDR_C45
| i
<< 16 | MII_PHYSID2
;
757 phy_reg
= mdiobus_read(bus
, addr
, reg_addr
);
760 c45_ids
->device_ids
[i
] |= phy_reg
;
767 * get_phy_id - reads the specified addr for its ID.
768 * @bus: the target MII bus
769 * @addr: PHY address on the MII bus
770 * @phy_id: where to store the ID retrieved.
771 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
772 * @c45_ids: where to store the c45 ID information.
774 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
775 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
778 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
779 * its return value is in turn returned.
782 static int get_phy_id(struct mii_bus
*bus
, int addr
, u32
*phy_id
,
783 bool is_c45
, struct phy_c45_device_ids
*c45_ids
)
788 return get_phy_c45_ids(bus
, addr
, phy_id
, c45_ids
);
790 /* Grab the bits from PHYIR1, and put them in the upper half */
791 phy_reg
= mdiobus_read(bus
, addr
, MII_PHYSID1
);
793 /* returning -ENODEV doesn't stop bus scanning */
794 return (phy_reg
== -EIO
|| phy_reg
== -ENODEV
) ? -ENODEV
: -EIO
;
797 *phy_id
= phy_reg
<< 16;
799 /* Grab the bits from PHYIR2, and put them in the lower half */
800 phy_reg
= mdiobus_read(bus
, addr
, MII_PHYSID2
);
810 * get_phy_device - reads the specified PHY device and returns its @phy_device
812 * @bus: the target MII bus
813 * @addr: PHY address on the MII bus
814 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
816 * Description: Reads the ID registers of the PHY at @addr on the
817 * @bus, then allocates and returns the phy_device to represent it.
819 struct phy_device
*get_phy_device(struct mii_bus
*bus
, int addr
, bool is_c45
)
821 struct phy_c45_device_ids c45_ids
;
825 c45_ids
.devices_in_package
= 0;
826 memset(c45_ids
.device_ids
, 0xff, sizeof(c45_ids
.device_ids
));
828 r
= get_phy_id(bus
, addr
, &phy_id
, is_c45
, &c45_ids
);
832 /* If the phy_id is mostly Fs, there is no device there */
833 if ((phy_id
& 0x1fffffff) == 0x1fffffff)
834 return ERR_PTR(-ENODEV
);
836 return phy_device_create(bus
, addr
, phy_id
, is_c45
, &c45_ids
);
838 EXPORT_SYMBOL(get_phy_device
);
841 * phy_device_register - Register the phy device on the MDIO bus
842 * @phydev: phy_device structure to be added to the MDIO bus
844 int phy_device_register(struct phy_device
*phydev
)
848 err
= mdiobus_register_device(&phydev
->mdio
);
852 /* Deassert the reset signal */
853 phy_device_reset(phydev
, 0);
855 /* Run all of the fixups for this PHY */
856 err
= phy_scan_fixups(phydev
);
858 phydev_err(phydev
, "failed to initialize\n");
862 err
= device_add(&phydev
->mdio
.dev
);
864 phydev_err(phydev
, "failed to add\n");
871 /* Assert the reset signal */
872 phy_device_reset(phydev
, 1);
874 mdiobus_unregister_device(&phydev
->mdio
);
877 EXPORT_SYMBOL(phy_device_register
);
880 * phy_device_remove - Remove a previously registered phy device from the MDIO bus
881 * @phydev: phy_device structure to remove
883 * This doesn't free the phy_device itself, it merely reverses the effects
884 * of phy_device_register(). Use phy_device_free() to free the device
885 * after calling this function.
887 void phy_device_remove(struct phy_device
*phydev
)
890 unregister_mii_timestamper(phydev
->mii_ts
);
892 device_del(&phydev
->mdio
.dev
);
894 /* Assert the reset signal */
895 phy_device_reset(phydev
, 1);
897 mdiobus_unregister_device(&phydev
->mdio
);
899 EXPORT_SYMBOL(phy_device_remove
);
902 * phy_find_first - finds the first PHY device on the bus
903 * @bus: the target MII bus
905 struct phy_device
*phy_find_first(struct mii_bus
*bus
)
907 struct phy_device
*phydev
;
910 for (addr
= 0; addr
< PHY_MAX_ADDR
; addr
++) {
911 phydev
= mdiobus_get_phy(bus
, addr
);
917 EXPORT_SYMBOL(phy_find_first
);
919 static void phy_link_change(struct phy_device
*phydev
, bool up
)
921 struct net_device
*netdev
= phydev
->attached_dev
;
924 netif_carrier_on(netdev
);
926 netif_carrier_off(netdev
);
927 phydev
->adjust_link(netdev
);
928 if (phydev
->mii_ts
&& phydev
->mii_ts
->link_state
)
929 phydev
->mii_ts
->link_state(phydev
->mii_ts
, phydev
);
933 * phy_prepare_link - prepares the PHY layer to monitor link status
934 * @phydev: target phy_device struct
935 * @handler: callback function for link status change notifications
937 * Description: Tells the PHY infrastructure to handle the
938 * gory details on monitoring link status (whether through
939 * polling or an interrupt), and to call back to the
940 * connected device driver when the link status changes.
941 * If you want to monitor your own link state, don't call
944 static void phy_prepare_link(struct phy_device
*phydev
,
945 void (*handler
)(struct net_device
*))
947 phydev
->adjust_link
= handler
;
951 * phy_connect_direct - connect an ethernet device to a specific phy_device
952 * @dev: the network device to connect
953 * @phydev: the pointer to the phy device
954 * @handler: callback function for state change notifications
955 * @interface: PHY device's interface
957 int phy_connect_direct(struct net_device
*dev
, struct phy_device
*phydev
,
958 void (*handler
)(struct net_device
*),
959 phy_interface_t interface
)
966 rc
= phy_attach_direct(dev
, phydev
, phydev
->dev_flags
, interface
);
970 phy_prepare_link(phydev
, handler
);
971 if (phy_interrupt_is_valid(phydev
))
972 phy_request_interrupt(phydev
);
976 EXPORT_SYMBOL(phy_connect_direct
);
979 * phy_connect - connect an ethernet device to a PHY device
980 * @dev: the network device to connect
981 * @bus_id: the id string of the PHY device to connect
982 * @handler: callback function for state change notifications
983 * @interface: PHY device's interface
985 * Description: Convenience function for connecting ethernet
986 * devices to PHY devices. The default behavior is for
987 * the PHY infrastructure to handle everything, and only notify
988 * the connected driver when the link status changes. If you
989 * don't want, or can't use the provided functionality, you may
990 * choose to call only the subset of functions which provide
991 * the desired functionality.
993 struct phy_device
*phy_connect(struct net_device
*dev
, const char *bus_id
,
994 void (*handler
)(struct net_device
*),
995 phy_interface_t interface
)
997 struct phy_device
*phydev
;
1001 /* Search the list of PHY devices on the mdio bus for the
1002 * PHY with the requested name
1004 d
= bus_find_device_by_name(&mdio_bus_type
, NULL
, bus_id
);
1006 pr_err("PHY %s not found\n", bus_id
);
1007 return ERR_PTR(-ENODEV
);
1009 phydev
= to_phy_device(d
);
1011 rc
= phy_connect_direct(dev
, phydev
, handler
, interface
);
1018 EXPORT_SYMBOL(phy_connect
);
1021 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
1023 * @phydev: target phy_device struct
1025 void phy_disconnect(struct phy_device
*phydev
)
1027 if (phy_is_started(phydev
))
1030 if (phy_interrupt_is_valid(phydev
))
1031 phy_free_interrupt(phydev
);
1033 phydev
->adjust_link
= NULL
;
1037 EXPORT_SYMBOL(phy_disconnect
);
1040 * phy_poll_reset - Safely wait until a PHY reset has properly completed
1041 * @phydev: The PHY device to poll
1043 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
1044 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
1045 * register must be polled until the BMCR_RESET bit clears.
1047 * Furthermore, any attempts to write to PHY registers may have no effect
1048 * or even generate MDIO bus errors until this is complete.
1050 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
1051 * standard and do not fully reset after the BMCR_RESET bit is set, and may
1052 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
1053 * effort to support such broken PHYs, this function is separate from the
1054 * standard phy_init_hw() which will zero all the other bits in the BMCR
1055 * and reapply all driver-specific and board-specific fixups.
1057 static int phy_poll_reset(struct phy_device
*phydev
)
1059 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
1062 ret
= phy_read_poll_timeout(phydev
, MII_BMCR
, val
, !(val
& BMCR_RESET
),
1063 50000, 600000, true);
1066 /* Some chips (smsc911x) may still need up to another 1ms after the
1067 * BMCR_RESET bit is cleared before they are usable.
1073 int phy_init_hw(struct phy_device
*phydev
)
1077 /* Deassert the reset signal */
1078 phy_device_reset(phydev
, 0);
1083 if (phydev
->drv
->soft_reset
) {
1084 ret
= phydev
->drv
->soft_reset(phydev
);
1085 /* see comment in genphy_soft_reset for an explanation */
1087 phydev
->suspended
= 0;
1093 ret
= phy_scan_fixups(phydev
);
1097 if (phydev
->drv
->config_init
)
1098 ret
= phydev
->drv
->config_init(phydev
);
1102 EXPORT_SYMBOL(phy_init_hw
);
1104 void phy_attached_info(struct phy_device
*phydev
)
1106 phy_attached_print(phydev
, NULL
);
1108 EXPORT_SYMBOL(phy_attached_info
);
1110 #define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
1111 char *phy_attached_info_irq(struct phy_device
*phydev
)
1116 switch(phydev
->irq
) {
1120 case PHY_IGNORE_INTERRUPT
:
1124 snprintf(irq_num
, sizeof(irq_num
), "%d", phydev
->irq
);
1129 return kasprintf(GFP_KERNEL
, "%s", irq_str
);
1131 EXPORT_SYMBOL(phy_attached_info_irq
);
1133 void phy_attached_print(struct phy_device
*phydev
, const char *fmt
, ...)
1135 const char *drv_name
= phydev
->drv
? phydev
->drv
->name
: "unbound";
1136 char *irq_str
= phy_attached_info_irq(phydev
);
1139 phydev_info(phydev
, ATTACHED_FMT
"\n",
1140 drv_name
, phydev_name(phydev
),
1145 phydev_info(phydev
, ATTACHED_FMT
,
1146 drv_name
, phydev_name(phydev
),
1155 EXPORT_SYMBOL(phy_attached_print
);
1157 static void phy_sysfs_create_links(struct phy_device
*phydev
)
1159 struct net_device
*dev
= phydev
->attached_dev
;
1165 err
= sysfs_create_link(&phydev
->mdio
.dev
.kobj
, &dev
->dev
.kobj
,
1170 err
= sysfs_create_link_nowarn(&dev
->dev
.kobj
,
1171 &phydev
->mdio
.dev
.kobj
,
1174 dev_err(&dev
->dev
, "could not add device link to %s err %d\n",
1175 kobject_name(&phydev
->mdio
.dev
.kobj
),
1177 /* non-fatal - some net drivers can use one netdevice
1178 * with more then one phy
1182 phydev
->sysfs_links
= true;
1186 phy_standalone_show(struct device
*dev
, struct device_attribute
*attr
,
1189 struct phy_device
*phydev
= to_phy_device(dev
);
1191 return sprintf(buf
, "%d\n", !phydev
->attached_dev
);
1193 static DEVICE_ATTR_RO(phy_standalone
);
1196 * phy_sfp_attach - attach the SFP bus to the PHY upstream network device
1197 * @upstream: pointer to the phy device
1198 * @bus: sfp bus representing cage being attached
1200 * This is used to fill in the sfp_upstream_ops .attach member.
1202 void phy_sfp_attach(void *upstream
, struct sfp_bus
*bus
)
1204 struct phy_device
*phydev
= upstream
;
1206 if (phydev
->attached_dev
)
1207 phydev
->attached_dev
->sfp_bus
= bus
;
1208 phydev
->sfp_bus_attached
= true;
1210 EXPORT_SYMBOL(phy_sfp_attach
);
1213 * phy_sfp_detach - detach the SFP bus from the PHY upstream network device
1214 * @upstream: pointer to the phy device
1215 * @bus: sfp bus representing cage being attached
1217 * This is used to fill in the sfp_upstream_ops .detach member.
1219 void phy_sfp_detach(void *upstream
, struct sfp_bus
*bus
)
1221 struct phy_device
*phydev
= upstream
;
1223 if (phydev
->attached_dev
)
1224 phydev
->attached_dev
->sfp_bus
= NULL
;
1225 phydev
->sfp_bus_attached
= false;
1227 EXPORT_SYMBOL(phy_sfp_detach
);
1230 * phy_sfp_probe - probe for a SFP cage attached to this PHY device
1231 * @phydev: Pointer to phy_device
1232 * @ops: SFP's upstream operations
1234 int phy_sfp_probe(struct phy_device
*phydev
,
1235 const struct sfp_upstream_ops
*ops
)
1237 struct sfp_bus
*bus
;
1240 if (phydev
->mdio
.dev
.fwnode
) {
1241 bus
= sfp_bus_find_fwnode(phydev
->mdio
.dev
.fwnode
);
1243 return PTR_ERR(bus
);
1245 phydev
->sfp_bus
= bus
;
1247 ret
= sfp_bus_add_upstream(bus
, phydev
, ops
);
1252 EXPORT_SYMBOL(phy_sfp_probe
);
1255 * phy_attach_direct - attach a network device to a given PHY device pointer
1256 * @dev: network device to attach
1257 * @phydev: Pointer to phy_device to attach
1258 * @flags: PHY device's dev_flags
1259 * @interface: PHY device's interface
1261 * Description: Called by drivers to attach to a particular PHY
1262 * device. The phy_device is found, and properly hooked up
1263 * to the phy_driver. If no driver is attached, then a
1264 * generic driver is used. The phy_device is given a ptr to
1265 * the attaching device, and given a callback for link status
1266 * change. The phy_device is returned to the attaching driver.
1267 * This function takes a reference on the phy device.
1269 int phy_attach_direct(struct net_device
*dev
, struct phy_device
*phydev
,
1270 u32 flags
, phy_interface_t interface
)
1272 struct mii_bus
*bus
= phydev
->mdio
.bus
;
1273 struct device
*d
= &phydev
->mdio
.dev
;
1274 struct module
*ndev_owner
= NULL
;
1275 bool using_genphy
= false;
1278 /* For Ethernet device drivers that register their own MDIO bus, we
1279 * will have bus->owner match ndev_mod, so we do not want to increment
1280 * our own module->refcnt here, otherwise we would not be able to
1284 ndev_owner
= dev
->dev
.parent
->driver
->owner
;
1285 if (ndev_owner
!= bus
->owner
&& !try_module_get(bus
->owner
)) {
1286 phydev_err(phydev
, "failed to get the bus module\n");
1292 /* Assume that if there is no driver, that it doesn't
1293 * exist, and we should use the genphy driver.
1297 d
->driver
= &genphy_c45_driver
.mdiodrv
.driver
;
1299 d
->driver
= &genphy_driver
.mdiodrv
.driver
;
1301 using_genphy
= true;
1304 if (!try_module_get(d
->driver
->owner
)) {
1305 phydev_err(phydev
, "failed to get the device driver module\n");
1307 goto error_put_device
;
1311 err
= d
->driver
->probe(d
);
1313 err
= device_bind_driver(d
);
1316 goto error_module_put
;
1319 if (phydev
->attached_dev
) {
1320 dev_err(&dev
->dev
, "PHY already attached\n");
1325 phydev
->phy_link_change
= phy_link_change
;
1327 phydev
->attached_dev
= dev
;
1328 dev
->phydev
= phydev
;
1330 if (phydev
->sfp_bus_attached
)
1331 dev
->sfp_bus
= phydev
->sfp_bus
;
1334 /* Some Ethernet drivers try to connect to a PHY device before
1335 * calling register_netdevice() -> netdev_register_kobject() and
1336 * does the dev->dev.kobj initialization. Here we only check for
1337 * success which indicates that the network device kobject is
1338 * ready. Once we do that we still need to keep track of whether
1339 * links were successfully set up or not for phy_detach() to
1340 * remove them accordingly.
1342 phydev
->sysfs_links
= false;
1344 phy_sysfs_create_links(phydev
);
1346 if (!phydev
->attached_dev
) {
1347 err
= sysfs_create_file(&phydev
->mdio
.dev
.kobj
,
1348 &dev_attr_phy_standalone
.attr
);
1350 phydev_err(phydev
, "error creating 'phy_standalone' sysfs entry\n");
1353 phydev
->dev_flags
|= flags
;
1355 phydev
->interface
= interface
;
1357 phydev
->state
= PHY_READY
;
1359 /* Initial carrier state is off as the phy is about to be
1363 netif_carrier_off(phydev
->attached_dev
);
1365 /* Do initial configuration here, now that
1366 * we have certain key parameters
1367 * (dev_flags and interface)
1369 err
= phy_init_hw(phydev
);
1374 phy_led_triggers_register(phydev
);
1379 /* phy_detach() does all of the cleanup below */
1384 module_put(d
->driver
->owner
);
1387 if (ndev_owner
!= bus
->owner
)
1388 module_put(bus
->owner
);
1391 EXPORT_SYMBOL(phy_attach_direct
);
1394 * phy_attach - attach a network device to a particular PHY device
1395 * @dev: network device to attach
1396 * @bus_id: Bus ID of PHY device to attach
1397 * @interface: PHY device's interface
1399 * Description: Same as phy_attach_direct() except that a PHY bus_id
1400 * string is passed instead of a pointer to a struct phy_device.
1402 struct phy_device
*phy_attach(struct net_device
*dev
, const char *bus_id
,
1403 phy_interface_t interface
)
1405 struct bus_type
*bus
= &mdio_bus_type
;
1406 struct phy_device
*phydev
;
1411 return ERR_PTR(-EINVAL
);
1413 /* Search the list of PHY devices on the mdio bus for the
1414 * PHY with the requested name
1416 d
= bus_find_device_by_name(bus
, NULL
, bus_id
);
1418 pr_err("PHY %s not found\n", bus_id
);
1419 return ERR_PTR(-ENODEV
);
1421 phydev
= to_phy_device(d
);
1423 rc
= phy_attach_direct(dev
, phydev
, phydev
->dev_flags
, interface
);
1430 EXPORT_SYMBOL(phy_attach
);
1432 static bool phy_driver_is_genphy_kind(struct phy_device
*phydev
,
1433 struct device_driver
*driver
)
1435 struct device
*d
= &phydev
->mdio
.dev
;
1442 ret
= d
->driver
== driver
;
1448 bool phy_driver_is_genphy(struct phy_device
*phydev
)
1450 return phy_driver_is_genphy_kind(phydev
,
1451 &genphy_driver
.mdiodrv
.driver
);
1453 EXPORT_SYMBOL_GPL(phy_driver_is_genphy
);
1455 bool phy_driver_is_genphy_10g(struct phy_device
*phydev
)
1457 return phy_driver_is_genphy_kind(phydev
,
1458 &genphy_c45_driver
.mdiodrv
.driver
);
1460 EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g
);
1463 * phy_package_join - join a common PHY group
1464 * @phydev: target phy_device struct
1465 * @addr: cookie and PHY address for global register access
1466 * @priv_size: if non-zero allocate this amount of bytes for private data
1468 * This joins a PHY group and provides a shared storage for all phydevs in
1469 * this group. This is intended to be used for packages which contain
1470 * more than one PHY, for example a quad PHY transceiver.
1472 * The addr parameter serves as a cookie which has to have the same value
1473 * for all members of one group and as a PHY address to access generic
1474 * registers of a PHY package. Usually, one of the PHY addresses of the
1475 * different PHYs in the package provides access to these global registers.
1476 * The address which is given here, will be used in the phy_package_read()
1477 * and phy_package_write() convenience functions. If your PHY doesn't have
1478 * global registers you can just pick any of the PHY addresses.
1480 * This will set the shared pointer of the phydev to the shared storage.
1481 * If this is the first call for a this cookie the shared storage will be
1482 * allocated. If priv_size is non-zero, the given amount of bytes are
1483 * allocated for the priv member.
1485 * Returns < 1 on error, 0 on success. Esp. calling phy_package_join()
1486 * with the same cookie but a different priv_size is an error.
1488 int phy_package_join(struct phy_device
*phydev
, int addr
, size_t priv_size
)
1490 struct mii_bus
*bus
= phydev
->mdio
.bus
;
1491 struct phy_package_shared
*shared
;
1494 if (addr
< 0 || addr
>= PHY_MAX_ADDR
)
1497 mutex_lock(&bus
->shared_lock
);
1498 shared
= bus
->shared
[addr
];
1501 shared
= kzalloc(sizeof(*shared
), GFP_KERNEL
);
1505 shared
->priv
= kzalloc(priv_size
, GFP_KERNEL
);
1508 shared
->priv_size
= priv_size
;
1510 shared
->addr
= addr
;
1511 refcount_set(&shared
->refcnt
, 1);
1512 bus
->shared
[addr
] = shared
;
1515 if (priv_size
&& priv_size
!= shared
->priv_size
)
1517 refcount_inc(&shared
->refcnt
);
1519 mutex_unlock(&bus
->shared_lock
);
1521 phydev
->shared
= shared
;
1528 mutex_unlock(&bus
->shared_lock
);
1531 EXPORT_SYMBOL_GPL(phy_package_join
);
1534 * phy_package_leave - leave a common PHY group
1535 * @phydev: target phy_device struct
1537 * This leaves a PHY group created by phy_package_join(). If this phydev
1538 * was the last user of the shared data between the group, this data is
1539 * freed. Resets the phydev->shared pointer to NULL.
1541 void phy_package_leave(struct phy_device
*phydev
)
1543 struct phy_package_shared
*shared
= phydev
->shared
;
1544 struct mii_bus
*bus
= phydev
->mdio
.bus
;
1549 if (refcount_dec_and_mutex_lock(&shared
->refcnt
, &bus
->shared_lock
)) {
1550 bus
->shared
[shared
->addr
] = NULL
;
1551 mutex_unlock(&bus
->shared_lock
);
1552 kfree(shared
->priv
);
1556 phydev
->shared
= NULL
;
1558 EXPORT_SYMBOL_GPL(phy_package_leave
);
1560 static void devm_phy_package_leave(struct device
*dev
, void *res
)
1562 phy_package_leave(*(struct phy_device
**)res
);
1566 * devm_phy_package_join - resource managed phy_package_join()
1567 * @dev: device that is registering this PHY package
1568 * @phydev: target phy_device struct
1569 * @addr: cookie and PHY address for global register access
1570 * @priv_size: if non-zero allocate this amount of bytes for private data
1572 * Managed phy_package_join(). Shared storage fetched by this function,
1573 * phy_package_leave() is automatically called on driver detach. See
1574 * phy_package_join() for more information.
1576 int devm_phy_package_join(struct device
*dev
, struct phy_device
*phydev
,
1577 int addr
, size_t priv_size
)
1579 struct phy_device
**ptr
;
1582 ptr
= devres_alloc(devm_phy_package_leave
, sizeof(*ptr
),
1587 ret
= phy_package_join(phydev
, addr
, priv_size
);
1591 devres_add(dev
, ptr
);
1598 EXPORT_SYMBOL_GPL(devm_phy_package_join
);
1601 * phy_detach - detach a PHY device from its network device
1602 * @phydev: target phy_device struct
1604 * This detaches the phy device from its network device and the phy
1605 * driver, and drops the reference count taken in phy_attach_direct().
1607 void phy_detach(struct phy_device
*phydev
)
1609 struct net_device
*dev
= phydev
->attached_dev
;
1610 struct module
*ndev_owner
= NULL
;
1611 struct mii_bus
*bus
;
1613 if (phydev
->sysfs_links
) {
1615 sysfs_remove_link(&dev
->dev
.kobj
, "phydev");
1616 sysfs_remove_link(&phydev
->mdio
.dev
.kobj
, "attached_dev");
1619 if (!phydev
->attached_dev
)
1620 sysfs_remove_file(&phydev
->mdio
.dev
.kobj
,
1621 &dev_attr_phy_standalone
.attr
);
1623 phy_suspend(phydev
);
1625 phydev
->attached_dev
->phydev
= NULL
;
1626 phydev
->attached_dev
= NULL
;
1628 phydev
->phylink
= NULL
;
1630 phy_led_triggers_unregister(phydev
);
1632 module_put(phydev
->mdio
.dev
.driver
->owner
);
1634 /* If the device had no specific driver before (i.e. - it
1635 * was using the generic driver), we unbind the device
1636 * from the generic driver so that there's a chance a
1637 * real driver could be loaded
1639 if (phy_driver_is_genphy(phydev
) ||
1640 phy_driver_is_genphy_10g(phydev
))
1641 device_release_driver(&phydev
->mdio
.dev
);
1644 * The phydev might go away on the put_device() below, so avoid
1645 * a use-after-free bug by reading the underlying bus first.
1647 bus
= phydev
->mdio
.bus
;
1649 put_device(&phydev
->mdio
.dev
);
1651 ndev_owner
= dev
->dev
.parent
->driver
->owner
;
1652 if (ndev_owner
!= bus
->owner
)
1653 module_put(bus
->owner
);
1655 /* Assert the reset signal */
1656 phy_device_reset(phydev
, 1);
1658 EXPORT_SYMBOL(phy_detach
);
1660 int phy_suspend(struct phy_device
*phydev
)
1662 struct ethtool_wolinfo wol
= { .cmd
= ETHTOOL_GWOL
};
1663 struct net_device
*netdev
= phydev
->attached_dev
;
1664 struct phy_driver
*phydrv
= phydev
->drv
;
1667 if (phydev
->suspended
)
1670 /* If the device has WOL enabled, we cannot suspend the PHY */
1671 phy_ethtool_get_wol(phydev
, &wol
);
1672 if (wol
.wolopts
|| (netdev
&& netdev
->wol_enabled
))
1675 if (!phydrv
|| !phydrv
->suspend
)
1678 ret
= phydrv
->suspend(phydev
);
1680 phydev
->suspended
= true;
1684 EXPORT_SYMBOL(phy_suspend
);
1686 int __phy_resume(struct phy_device
*phydev
)
1688 struct phy_driver
*phydrv
= phydev
->drv
;
1691 WARN_ON(!mutex_is_locked(&phydev
->lock
));
1693 if (!phydrv
|| !phydrv
->resume
)
1696 ret
= phydrv
->resume(phydev
);
1698 phydev
->suspended
= false;
1702 EXPORT_SYMBOL(__phy_resume
);
1704 int phy_resume(struct phy_device
*phydev
)
1708 mutex_lock(&phydev
->lock
);
1709 ret
= __phy_resume(phydev
);
1710 mutex_unlock(&phydev
->lock
);
1714 EXPORT_SYMBOL(phy_resume
);
1716 int phy_loopback(struct phy_device
*phydev
, bool enable
)
1718 struct phy_driver
*phydrv
= to_phy_driver(phydev
->mdio
.dev
.driver
);
1721 mutex_lock(&phydev
->lock
);
1723 if (enable
&& phydev
->loopback_enabled
) {
1728 if (!enable
&& !phydev
->loopback_enabled
) {
1733 if (phydev
->drv
&& phydrv
->set_loopback
)
1734 ret
= phydrv
->set_loopback(phydev
, enable
);
1741 phydev
->loopback_enabled
= enable
;
1744 mutex_unlock(&phydev
->lock
);
1747 EXPORT_SYMBOL(phy_loopback
);
1750 * phy_reset_after_clk_enable - perform a PHY reset if needed
1751 * @phydev: target phy_device struct
1753 * Description: Some PHYs are known to need a reset after their refclk was
1754 * enabled. This function evaluates the flags and perform the reset if it's
1755 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
1758 int phy_reset_after_clk_enable(struct phy_device
*phydev
)
1760 if (!phydev
|| !phydev
->drv
)
1763 if (phydev
->drv
->flags
& PHY_RST_AFTER_CLK_EN
) {
1764 phy_device_reset(phydev
, 1);
1765 phy_device_reset(phydev
, 0);
1771 EXPORT_SYMBOL(phy_reset_after_clk_enable
);
1773 /* Generic PHY support and helper functions */
1776 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1777 * @phydev: target phy_device struct
1779 * Description: Writes MII_ADVERTISE with the appropriate values,
1780 * after sanitizing the values to make sure we only advertise
1781 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1782 * hasn't changed, and > 0 if it has changed.
1784 static int genphy_config_advert(struct phy_device
*phydev
)
1786 int err
, bmsr
, changed
= 0;
1789 /* Only allow advertising what this PHY supports */
1790 linkmode_and(phydev
->advertising
, phydev
->advertising
,
1793 adv
= linkmode_adv_to_mii_adv_t(phydev
->advertising
);
1795 /* Setup standard advertisement */
1796 err
= phy_modify_changed(phydev
, MII_ADVERTISE
,
1797 ADVERTISE_ALL
| ADVERTISE_100BASE4
|
1798 ADVERTISE_PAUSE_CAP
| ADVERTISE_PAUSE_ASYM
,
1805 bmsr
= phy_read(phydev
, MII_BMSR
);
1809 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1810 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1813 if (!(bmsr
& BMSR_ESTATEN
))
1816 adv
= linkmode_adv_to_mii_ctrl1000_t(phydev
->advertising
);
1818 err
= phy_modify_changed(phydev
, MII_CTRL1000
,
1819 ADVERTISE_1000FULL
| ADVERTISE_1000HALF
,
1830 * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
1831 * @phydev: target phy_device struct
1833 * Description: Writes MII_ADVERTISE with the appropriate values,
1834 * after sanitizing the values to make sure we only advertise
1835 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1836 * hasn't changed, and > 0 if it has changed. This function is intended
1837 * for Clause 37 1000Base-X mode.
1839 static int genphy_c37_config_advert(struct phy_device
*phydev
)
1843 /* Only allow advertising what this PHY supports */
1844 linkmode_and(phydev
->advertising
, phydev
->advertising
,
1847 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT
,
1848 phydev
->advertising
))
1849 adv
|= ADVERTISE_1000XFULL
;
1850 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
1851 phydev
->advertising
))
1852 adv
|= ADVERTISE_1000XPAUSE
;
1853 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
,
1854 phydev
->advertising
))
1855 adv
|= ADVERTISE_1000XPSE_ASYM
;
1857 return phy_modify_changed(phydev
, MII_ADVERTISE
,
1858 ADVERTISE_1000XFULL
| ADVERTISE_1000XPAUSE
|
1859 ADVERTISE_1000XHALF
| ADVERTISE_1000XPSE_ASYM
,
1864 * genphy_config_eee_advert - disable unwanted eee mode advertisement
1865 * @phydev: target phy_device struct
1867 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1868 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1869 * changed, and 1 if it has changed.
1871 int genphy_config_eee_advert(struct phy_device
*phydev
)
1875 /* Nothing to disable */
1876 if (!phydev
->eee_broken_modes
)
1879 err
= phy_modify_mmd_changed(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
,
1880 phydev
->eee_broken_modes
, 0);
1881 /* If the call failed, we assume that EEE is not supported */
1882 return err
< 0 ? 0 : err
;
1884 EXPORT_SYMBOL(genphy_config_eee_advert
);
1887 * genphy_setup_forced - configures/forces speed/duplex from @phydev
1888 * @phydev: target phy_device struct
1890 * Description: Configures MII_BMCR to force speed/duplex
1891 * to the values in phydev. Assumes that the values are valid.
1892 * Please see phy_sanitize_settings().
1894 int genphy_setup_forced(struct phy_device
*phydev
)
1899 phydev
->asym_pause
= 0;
1901 if (SPEED_1000
== phydev
->speed
)
1902 ctl
|= BMCR_SPEED1000
;
1903 else if (SPEED_100
== phydev
->speed
)
1904 ctl
|= BMCR_SPEED100
;
1906 if (DUPLEX_FULL
== phydev
->duplex
)
1907 ctl
|= BMCR_FULLDPLX
;
1909 return phy_modify(phydev
, MII_BMCR
,
1910 ~(BMCR_LOOPBACK
| BMCR_ISOLATE
| BMCR_PDOWN
), ctl
);
1912 EXPORT_SYMBOL(genphy_setup_forced
);
1914 static int genphy_setup_master_slave(struct phy_device
*phydev
)
1918 if (!phydev
->is_gigabit_capable
)
1921 switch (phydev
->master_slave_set
) {
1922 case MASTER_SLAVE_CFG_MASTER_PREFERRED
:
1923 ctl
|= CTL1000_PREFER_MASTER
;
1925 case MASTER_SLAVE_CFG_SLAVE_PREFERRED
:
1927 case MASTER_SLAVE_CFG_MASTER_FORCE
:
1928 ctl
|= CTL1000_AS_MASTER
;
1930 case MASTER_SLAVE_CFG_SLAVE_FORCE
:
1931 ctl
|= CTL1000_ENABLE_MASTER
;
1933 case MASTER_SLAVE_CFG_UNKNOWN
:
1934 case MASTER_SLAVE_CFG_UNSUPPORTED
:
1937 phydev_warn(phydev
, "Unsupported Master/Slave mode\n");
1941 return phy_modify_changed(phydev
, MII_CTRL1000
,
1942 (CTL1000_ENABLE_MASTER
| CTL1000_AS_MASTER
|
1943 CTL1000_PREFER_MASTER
), ctl
);
1946 static int genphy_read_master_slave(struct phy_device
*phydev
)
1951 if (!phydev
->is_gigabit_capable
) {
1952 phydev
->master_slave_get
= MASTER_SLAVE_CFG_UNSUPPORTED
;
1953 phydev
->master_slave_state
= MASTER_SLAVE_STATE_UNSUPPORTED
;
1957 phydev
->master_slave_get
= MASTER_SLAVE_CFG_UNKNOWN
;
1958 phydev
->master_slave_state
= MASTER_SLAVE_STATE_UNKNOWN
;
1960 val
= phy_read(phydev
, MII_CTRL1000
);
1964 if (val
& CTL1000_ENABLE_MASTER
) {
1965 if (val
& CTL1000_AS_MASTER
)
1966 cfg
= MASTER_SLAVE_CFG_MASTER_FORCE
;
1968 cfg
= MASTER_SLAVE_CFG_SLAVE_FORCE
;
1970 if (val
& CTL1000_PREFER_MASTER
)
1971 cfg
= MASTER_SLAVE_CFG_MASTER_PREFERRED
;
1973 cfg
= MASTER_SLAVE_CFG_SLAVE_PREFERRED
;
1976 val
= phy_read(phydev
, MII_STAT1000
);
1980 if (val
& LPA_1000MSFAIL
) {
1981 state
= MASTER_SLAVE_STATE_ERR
;
1982 } else if (phydev
->link
) {
1983 /* this bits are valid only for active link */
1984 if (val
& LPA_1000MSRES
)
1985 state
= MASTER_SLAVE_STATE_MASTER
;
1987 state
= MASTER_SLAVE_STATE_SLAVE
;
1989 state
= MASTER_SLAVE_STATE_UNKNOWN
;
1992 phydev
->master_slave_get
= cfg
;
1993 phydev
->master_slave_state
= state
;
1999 * genphy_restart_aneg - Enable and Restart Autonegotiation
2000 * @phydev: target phy_device struct
2002 int genphy_restart_aneg(struct phy_device
*phydev
)
2004 /* Don't isolate the PHY if we're negotiating */
2005 return phy_modify(phydev
, MII_BMCR
, BMCR_ISOLATE
,
2006 BMCR_ANENABLE
| BMCR_ANRESTART
);
2008 EXPORT_SYMBOL(genphy_restart_aneg
);
2011 * genphy_check_and_restart_aneg - Enable and restart auto-negotiation
2012 * @phydev: target phy_device struct
2013 * @restart: whether aneg restart is requested
2015 * Check, and restart auto-negotiation if needed.
2017 int genphy_check_and_restart_aneg(struct phy_device
*phydev
, bool restart
)
2022 /* Advertisement hasn't changed, but maybe aneg was never on to
2023 * begin with? Or maybe phy was isolated?
2025 ret
= phy_read(phydev
, MII_BMCR
);
2029 if (!(ret
& BMCR_ANENABLE
) || (ret
& BMCR_ISOLATE
))
2034 return genphy_restart_aneg(phydev
);
2038 EXPORT_SYMBOL(genphy_check_and_restart_aneg
);
2041 * __genphy_config_aneg - restart auto-negotiation or write BMCR
2042 * @phydev: target phy_device struct
2043 * @changed: whether autoneg is requested
2045 * Description: If auto-negotiation is enabled, we configure the
2046 * advertising, and then restart auto-negotiation. If it is not
2047 * enabled, then we write the BMCR.
2049 int __genphy_config_aneg(struct phy_device
*phydev
, bool changed
)
2053 if (genphy_config_eee_advert(phydev
))
2056 err
= genphy_setup_master_slave(phydev
);
2062 if (AUTONEG_ENABLE
!= phydev
->autoneg
)
2063 return genphy_setup_forced(phydev
);
2065 err
= genphy_config_advert(phydev
);
2066 if (err
< 0) /* error */
2071 return genphy_check_and_restart_aneg(phydev
, changed
);
2073 EXPORT_SYMBOL(__genphy_config_aneg
);
2076 * genphy_c37_config_aneg - restart auto-negotiation or write BMCR
2077 * @phydev: target phy_device struct
2079 * Description: If auto-negotiation is enabled, we configure the
2080 * advertising, and then restart auto-negotiation. If it is not
2081 * enabled, then we write the BMCR. This function is intended
2082 * for use with Clause 37 1000Base-X mode.
2084 int genphy_c37_config_aneg(struct phy_device
*phydev
)
2088 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
2089 return genphy_setup_forced(phydev
);
2091 err
= phy_modify(phydev
, MII_BMCR
, BMCR_SPEED1000
| BMCR_SPEED100
,
2096 changed
= genphy_c37_config_advert(phydev
);
2097 if (changed
< 0) /* error */
2101 /* Advertisement hasn't changed, but maybe aneg was never on to
2102 * begin with? Or maybe phy was isolated?
2104 int ctl
= phy_read(phydev
, MII_BMCR
);
2109 if (!(ctl
& BMCR_ANENABLE
) || (ctl
& BMCR_ISOLATE
))
2110 changed
= 1; /* do restart aneg */
2113 /* Only restart aneg if we are advertising something different
2114 * than we were before.
2117 return genphy_restart_aneg(phydev
);
2121 EXPORT_SYMBOL(genphy_c37_config_aneg
);
2124 * genphy_aneg_done - return auto-negotiation status
2125 * @phydev: target phy_device struct
2127 * Description: Reads the status register and returns 0 either if
2128 * auto-negotiation is incomplete, or if there was an error.
2129 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
2131 int genphy_aneg_done(struct phy_device
*phydev
)
2133 int retval
= phy_read(phydev
, MII_BMSR
);
2135 return (retval
< 0) ? retval
: (retval
& BMSR_ANEGCOMPLETE
);
2137 EXPORT_SYMBOL(genphy_aneg_done
);
2140 * genphy_update_link - update link status in @phydev
2141 * @phydev: target phy_device struct
2143 * Description: Update the value in phydev->link to reflect the
2144 * current link value. In order to do this, we need to read
2145 * the status register twice, keeping the second value.
2147 int genphy_update_link(struct phy_device
*phydev
)
2149 int status
= 0, bmcr
;
2151 bmcr
= phy_read(phydev
, MII_BMCR
);
2155 /* Autoneg is being started, therefore disregard BMSR value and
2156 * report link as down.
2158 if (bmcr
& BMCR_ANRESTART
)
2161 /* The link state is latched low so that momentary link
2162 * drops can be detected. Do not double-read the status
2163 * in polling mode to detect such short link drops except
2164 * the link was already down.
2166 if (!phy_polling_mode(phydev
) || !phydev
->link
) {
2167 status
= phy_read(phydev
, MII_BMSR
);
2170 else if (status
& BMSR_LSTATUS
)
2174 /* Read link and autonegotiation status */
2175 status
= phy_read(phydev
, MII_BMSR
);
2179 phydev
->link
= status
& BMSR_LSTATUS
? 1 : 0;
2180 phydev
->autoneg_complete
= status
& BMSR_ANEGCOMPLETE
? 1 : 0;
2182 /* Consider the case that autoneg was started and "aneg complete"
2183 * bit has been reset, but "link up" bit not yet.
2185 if (phydev
->autoneg
== AUTONEG_ENABLE
&& !phydev
->autoneg_complete
)
2190 EXPORT_SYMBOL(genphy_update_link
);
2192 int genphy_read_lpa(struct phy_device
*phydev
)
2196 if (phydev
->autoneg
== AUTONEG_ENABLE
) {
2197 if (!phydev
->autoneg_complete
) {
2198 mii_stat1000_mod_linkmode_lpa_t(phydev
->lp_advertising
,
2200 mii_lpa_mod_linkmode_lpa_t(phydev
->lp_advertising
, 0);
2204 if (phydev
->is_gigabit_capable
) {
2205 lpagb
= phy_read(phydev
, MII_STAT1000
);
2209 if (lpagb
& LPA_1000MSFAIL
) {
2210 int adv
= phy_read(phydev
, MII_CTRL1000
);
2215 if (adv
& CTL1000_ENABLE_MASTER
)
2216 phydev_err(phydev
, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2218 phydev_err(phydev
, "Master/Slave resolution failed\n");
2222 mii_stat1000_mod_linkmode_lpa_t(phydev
->lp_advertising
,
2226 lpa
= phy_read(phydev
, MII_LPA
);
2230 mii_lpa_mod_linkmode_lpa_t(phydev
->lp_advertising
, lpa
);
2232 linkmode_zero(phydev
->lp_advertising
);
2237 EXPORT_SYMBOL(genphy_read_lpa
);
2240 * genphy_read_status_fixed - read the link parameters for !aneg mode
2241 * @phydev: target phy_device struct
2243 * Read the current duplex and speed state for a PHY operating with
2244 * autonegotiation disabled.
2246 int genphy_read_status_fixed(struct phy_device
*phydev
)
2248 int bmcr
= phy_read(phydev
, MII_BMCR
);
2253 if (bmcr
& BMCR_FULLDPLX
)
2254 phydev
->duplex
= DUPLEX_FULL
;
2256 phydev
->duplex
= DUPLEX_HALF
;
2258 if (bmcr
& BMCR_SPEED1000
)
2259 phydev
->speed
= SPEED_1000
;
2260 else if (bmcr
& BMCR_SPEED100
)
2261 phydev
->speed
= SPEED_100
;
2263 phydev
->speed
= SPEED_10
;
2267 EXPORT_SYMBOL(genphy_read_status_fixed
);
2270 * genphy_read_status - check the link status and update current link state
2271 * @phydev: target phy_device struct
2273 * Description: Check the link, then figure out the current state
2274 * by comparing what we advertise with what the link partner
2275 * advertises. Start by checking the gigabit possibilities,
2276 * then move on to 10/100.
2278 int genphy_read_status(struct phy_device
*phydev
)
2280 int err
, old_link
= phydev
->link
;
2282 /* Update the link, but return if there was an error */
2283 err
= genphy_update_link(phydev
);
2287 /* why bother the PHY if nothing can have changed */
2288 if (phydev
->autoneg
== AUTONEG_ENABLE
&& old_link
&& phydev
->link
)
2291 phydev
->speed
= SPEED_UNKNOWN
;
2292 phydev
->duplex
= DUPLEX_UNKNOWN
;
2294 phydev
->asym_pause
= 0;
2296 err
= genphy_read_master_slave(phydev
);
2300 err
= genphy_read_lpa(phydev
);
2304 if (phydev
->autoneg
== AUTONEG_ENABLE
&& phydev
->autoneg_complete
) {
2305 phy_resolve_aneg_linkmode(phydev
);
2306 } else if (phydev
->autoneg
== AUTONEG_DISABLE
) {
2307 err
= genphy_read_status_fixed(phydev
);
2314 EXPORT_SYMBOL(genphy_read_status
);
2317 * genphy_c37_read_status - check the link status and update current link state
2318 * @phydev: target phy_device struct
2320 * Description: Check the link, then figure out the current state
2321 * by comparing what we advertise with what the link partner
2322 * advertises. This function is for Clause 37 1000Base-X mode.
2324 int genphy_c37_read_status(struct phy_device
*phydev
)
2326 int lpa
, err
, old_link
= phydev
->link
;
2328 /* Update the link, but return if there was an error */
2329 err
= genphy_update_link(phydev
);
2333 /* why bother the PHY if nothing can have changed */
2334 if (phydev
->autoneg
== AUTONEG_ENABLE
&& old_link
&& phydev
->link
)
2337 phydev
->duplex
= DUPLEX_UNKNOWN
;
2339 phydev
->asym_pause
= 0;
2341 if (phydev
->autoneg
== AUTONEG_ENABLE
&& phydev
->autoneg_complete
) {
2342 lpa
= phy_read(phydev
, MII_LPA
);
2346 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
,
2347 phydev
->lp_advertising
, lpa
& LPA_LPACK
);
2348 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT
,
2349 phydev
->lp_advertising
, lpa
& LPA_1000XFULL
);
2350 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
2351 phydev
->lp_advertising
, lpa
& LPA_1000XPAUSE
);
2352 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
,
2353 phydev
->lp_advertising
,
2354 lpa
& LPA_1000XPAUSE_ASYM
);
2356 phy_resolve_aneg_linkmode(phydev
);
2357 } else if (phydev
->autoneg
== AUTONEG_DISABLE
) {
2358 int bmcr
= phy_read(phydev
, MII_BMCR
);
2363 if (bmcr
& BMCR_FULLDPLX
)
2364 phydev
->duplex
= DUPLEX_FULL
;
2366 phydev
->duplex
= DUPLEX_HALF
;
2371 EXPORT_SYMBOL(genphy_c37_read_status
);
2374 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
2375 * @phydev: target phy_device struct
2377 * Description: Perform a software PHY reset using the standard
2378 * BMCR_RESET bit and poll for the reset bit to be cleared.
2380 * Returns: 0 on success, < 0 on failure
2382 int genphy_soft_reset(struct phy_device
*phydev
)
2384 u16 res
= BMCR_RESET
;
2387 if (phydev
->autoneg
== AUTONEG_ENABLE
)
2388 res
|= BMCR_ANRESTART
;
2390 ret
= phy_modify(phydev
, MII_BMCR
, BMCR_ISOLATE
, res
);
2394 /* Clause 22 states that setting bit BMCR_RESET sets control registers
2395 * to their default value. Therefore the POWER DOWN bit is supposed to
2396 * be cleared after soft reset.
2398 phydev
->suspended
= 0;
2400 ret
= phy_poll_reset(phydev
);
2404 /* BMCR may be reset to defaults */
2405 if (phydev
->autoneg
== AUTONEG_DISABLE
)
2406 ret
= genphy_setup_forced(phydev
);
2410 EXPORT_SYMBOL(genphy_soft_reset
);
2413 * genphy_read_abilities - read PHY abilities from Clause 22 registers
2414 * @phydev: target phy_device struct
2416 * Description: Reads the PHY's abilities and populates
2417 * phydev->supported accordingly.
2419 * Returns: 0 on success, < 0 on failure
2421 int genphy_read_abilities(struct phy_device
*phydev
)
2425 linkmode_set_bit_array(phy_basic_ports_array
,
2426 ARRAY_SIZE(phy_basic_ports_array
),
2429 val
= phy_read(phydev
, MII_BMSR
);
2433 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
, phydev
->supported
,
2434 val
& BMSR_ANEGCAPABLE
);
2436 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT
, phydev
->supported
,
2437 val
& BMSR_100FULL
);
2438 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT
, phydev
->supported
,
2439 val
& BMSR_100HALF
);
2440 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT
, phydev
->supported
,
2442 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT
, phydev
->supported
,
2445 if (val
& BMSR_ESTATEN
) {
2446 val
= phy_read(phydev
, MII_ESTATUS
);
2450 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
2451 phydev
->supported
, val
& ESTATUS_1000_TFULL
);
2452 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT
,
2453 phydev
->supported
, val
& ESTATUS_1000_THALF
);
2454 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT
,
2455 phydev
->supported
, val
& ESTATUS_1000_XFULL
);
2460 EXPORT_SYMBOL(genphy_read_abilities
);
2462 /* This is used for the phy device which doesn't support the MMD extended
2463 * register access, but it does have side effect when we are trying to access
2464 * the MMD register via indirect method.
2466 int genphy_read_mmd_unsupported(struct phy_device
*phdev
, int devad
, u16 regnum
)
2470 EXPORT_SYMBOL(genphy_read_mmd_unsupported
);
2472 int genphy_write_mmd_unsupported(struct phy_device
*phdev
, int devnum
,
2473 u16 regnum
, u16 val
)
2477 EXPORT_SYMBOL(genphy_write_mmd_unsupported
);
2479 int genphy_suspend(struct phy_device
*phydev
)
2481 return phy_set_bits(phydev
, MII_BMCR
, BMCR_PDOWN
);
2483 EXPORT_SYMBOL(genphy_suspend
);
2485 int genphy_resume(struct phy_device
*phydev
)
2487 return phy_clear_bits(phydev
, MII_BMCR
, BMCR_PDOWN
);
2489 EXPORT_SYMBOL(genphy_resume
);
2491 int genphy_loopback(struct phy_device
*phydev
, bool enable
)
2493 return phy_modify(phydev
, MII_BMCR
, BMCR_LOOPBACK
,
2494 enable
? BMCR_LOOPBACK
: 0);
2496 EXPORT_SYMBOL(genphy_loopback
);
2499 * phy_remove_link_mode - Remove a supported link mode
2500 * @phydev: phy_device structure to remove link mode from
2501 * @link_mode: Link mode to be removed
2503 * Description: Some MACs don't support all link modes which the PHY
2504 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper
2505 * to remove a link mode.
2507 void phy_remove_link_mode(struct phy_device
*phydev
, u32 link_mode
)
2509 linkmode_clear_bit(link_mode
, phydev
->supported
);
2510 phy_advertise_supported(phydev
);
2512 EXPORT_SYMBOL(phy_remove_link_mode
);
2514 static void phy_copy_pause_bits(unsigned long *dst
, unsigned long *src
)
2516 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
, dst
,
2517 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
, src
));
2518 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT
, dst
,
2519 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT
, src
));
2523 * phy_advertise_supported - Advertise all supported modes
2524 * @phydev: target phy_device struct
2526 * Description: Called to advertise all supported modes, doesn't touch
2527 * pause mode advertising.
2529 void phy_advertise_supported(struct phy_device
*phydev
)
2531 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2533 linkmode_copy(new, phydev
->supported
);
2534 phy_copy_pause_bits(new, phydev
->advertising
);
2535 linkmode_copy(phydev
->advertising
, new);
2537 EXPORT_SYMBOL(phy_advertise_supported
);
2540 * phy_support_sym_pause - Enable support of symmetrical pause
2541 * @phydev: target phy_device struct
2543 * Description: Called by the MAC to indicate is supports symmetrical
2544 * Pause, but not asym pause.
2546 void phy_support_sym_pause(struct phy_device
*phydev
)
2548 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
, phydev
->supported
);
2549 phy_copy_pause_bits(phydev
->advertising
, phydev
->supported
);
2551 EXPORT_SYMBOL(phy_support_sym_pause
);
2554 * phy_support_asym_pause - Enable support of asym pause
2555 * @phydev: target phy_device struct
2557 * Description: Called by the MAC to indicate is supports Asym Pause.
2559 void phy_support_asym_pause(struct phy_device
*phydev
)
2561 phy_copy_pause_bits(phydev
->advertising
, phydev
->supported
);
2563 EXPORT_SYMBOL(phy_support_asym_pause
);
2566 * phy_set_sym_pause - Configure symmetric Pause
2567 * @phydev: target phy_device struct
2568 * @rx: Receiver Pause is supported
2569 * @tx: Transmit Pause is supported
2570 * @autoneg: Auto neg should be used
2572 * Description: Configure advertised Pause support depending on if
2573 * receiver pause and pause auto neg is supported. Generally called
2574 * from the set_pauseparam .ndo.
2576 void phy_set_sym_pause(struct phy_device
*phydev
, bool rx
, bool tx
,
2579 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT
, phydev
->supported
);
2581 if (rx
&& tx
&& autoneg
)
2582 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
2585 linkmode_copy(phydev
->advertising
, phydev
->supported
);
2587 EXPORT_SYMBOL(phy_set_sym_pause
);
2590 * phy_set_asym_pause - Configure Pause and Asym Pause
2591 * @phydev: target phy_device struct
2592 * @rx: Receiver Pause is supported
2593 * @tx: Transmit Pause is supported
2595 * Description: Configure advertised Pause support depending on if
2596 * transmit and receiver pause is supported. If there has been a
2597 * change in adverting, trigger a new autoneg. Generally called from
2598 * the set_pauseparam .ndo.
2600 void phy_set_asym_pause(struct phy_device
*phydev
, bool rx
, bool tx
)
2602 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv
);
2604 linkmode_copy(oldadv
, phydev
->advertising
);
2605 linkmode_set_pause(phydev
->advertising
, tx
, rx
);
2607 if (!linkmode_equal(oldadv
, phydev
->advertising
) &&
2609 phy_start_aneg(phydev
);
2611 EXPORT_SYMBOL(phy_set_asym_pause
);
2614 * phy_validate_pause - Test if the PHY/MAC support the pause configuration
2615 * @phydev: phy_device struct
2616 * @pp: requested pause configuration
2618 * Description: Test if the PHY/MAC combination supports the Pause
2619 * configuration the user is requesting. Returns True if it is
2620 * supported, false otherwise.
2622 bool phy_validate_pause(struct phy_device
*phydev
,
2623 struct ethtool_pauseparam
*pp
)
2625 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
2626 phydev
->supported
) && pp
->rx_pause
)
2629 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
,
2630 phydev
->supported
) &&
2631 pp
->rx_pause
!= pp
->tx_pause
)
2636 EXPORT_SYMBOL(phy_validate_pause
);
2639 * phy_get_pause - resolve negotiated pause modes
2640 * @phydev: phy_device struct
2641 * @tx_pause: pointer to bool to indicate whether transmit pause should be
2643 * @rx_pause: pointer to bool to indicate whether receive pause should be
2646 * Resolve and return the flow control modes according to the negotiation
2647 * result. This includes checking that we are operating in full duplex mode.
2648 * See linkmode_resolve_pause() for further details.
2650 void phy_get_pause(struct phy_device
*phydev
, bool *tx_pause
, bool *rx_pause
)
2652 if (phydev
->duplex
!= DUPLEX_FULL
) {
2658 return linkmode_resolve_pause(phydev
->advertising
,
2659 phydev
->lp_advertising
,
2660 tx_pause
, rx_pause
);
2662 EXPORT_SYMBOL(phy_get_pause
);
2664 static bool phy_drv_supports_irq(struct phy_driver
*phydrv
)
2666 return phydrv
->config_intr
&& phydrv
->ack_interrupt
;
2670 * phy_probe - probe and init a PHY device
2671 * @dev: device to probe and init
2673 * Description: Take care of setting up the phy_device structure,
2674 * set the state to READY (the driver's init function should
2675 * set it to STARTING if needed).
2677 static int phy_probe(struct device
*dev
)
2679 struct phy_device
*phydev
= to_phy_device(dev
);
2680 struct device_driver
*drv
= phydev
->mdio
.dev
.driver
;
2681 struct phy_driver
*phydrv
= to_phy_driver(drv
);
2684 phydev
->drv
= phydrv
;
2686 /* Disable the interrupt if the PHY doesn't support it
2687 * but the interrupt is still a valid one
2689 if (!phy_drv_supports_irq(phydrv
) && phy_interrupt_is_valid(phydev
))
2690 phydev
->irq
= PHY_POLL
;
2692 if (phydrv
->flags
& PHY_IS_INTERNAL
)
2693 phydev
->is_internal
= true;
2695 mutex_lock(&phydev
->lock
);
2697 if (phydev
->drv
->probe
) {
2698 /* Deassert the reset signal */
2699 phy_device_reset(phydev
, 0);
2701 err
= phydev
->drv
->probe(phydev
);
2703 /* Assert the reset signal */
2704 phy_device_reset(phydev
, 1);
2709 /* Start out supporting everything. Eventually,
2710 * a controller will attach, and may modify one
2711 * or both of these values
2713 if (phydrv
->features
) {
2714 linkmode_copy(phydev
->supported
, phydrv
->features
);
2715 } else if (phydrv
->get_features
) {
2716 err
= phydrv
->get_features(phydev
);
2717 } else if (phydev
->is_c45
) {
2718 err
= genphy_c45_pma_read_abilities(phydev
);
2720 err
= genphy_read_abilities(phydev
);
2726 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
,
2728 phydev
->autoneg
= 0;
2730 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT
,
2732 phydev
->is_gigabit_capable
= 1;
2733 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
2735 phydev
->is_gigabit_capable
= 1;
2737 of_set_phy_supported(phydev
);
2738 phy_advertise_supported(phydev
);
2740 /* Get the EEE modes we want to prohibit. We will ask
2741 * the PHY stop advertising these mode later on
2743 of_set_phy_eee_broken(phydev
);
2745 /* The Pause Frame bits indicate that the PHY can support passing
2746 * pause frames. During autonegotiation, the PHYs will determine if
2747 * they should allow pause frames to pass. The MAC driver should then
2748 * use that result to determine whether to enable flow control via
2751 * Normally, PHY drivers should not set the Pause bits, and instead
2752 * allow phylib to do that. However, there may be some situations
2753 * (e.g. hardware erratum) where the driver wants to set only one
2756 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT
, phydev
->supported
) &&
2757 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
, phydev
->supported
)) {
2758 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
2760 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
,
2764 /* Set the state to READY by default */
2765 phydev
->state
= PHY_READY
;
2768 mutex_unlock(&phydev
->lock
);
2773 static int phy_remove(struct device
*dev
)
2775 struct phy_device
*phydev
= to_phy_device(dev
);
2777 cancel_delayed_work_sync(&phydev
->state_queue
);
2779 mutex_lock(&phydev
->lock
);
2780 phydev
->state
= PHY_DOWN
;
2781 mutex_unlock(&phydev
->lock
);
2783 sfp_bus_del_upstream(phydev
->sfp_bus
);
2784 phydev
->sfp_bus
= NULL
;
2786 if (phydev
->drv
&& phydev
->drv
->remove
) {
2787 phydev
->drv
->remove(phydev
);
2789 /* Assert the reset signal */
2790 phy_device_reset(phydev
, 1);
2798 * phy_driver_register - register a phy_driver with the PHY layer
2799 * @new_driver: new phy_driver to register
2800 * @owner: module owning this PHY
2802 int phy_driver_register(struct phy_driver
*new_driver
, struct module
*owner
)
2806 /* Either the features are hard coded, or dynamically
2807 * determined. It cannot be both.
2809 if (WARN_ON(new_driver
->features
&& new_driver
->get_features
)) {
2810 pr_err("%s: features and get_features must not both be set\n",
2815 new_driver
->mdiodrv
.flags
|= MDIO_DEVICE_IS_PHY
;
2816 new_driver
->mdiodrv
.driver
.name
= new_driver
->name
;
2817 new_driver
->mdiodrv
.driver
.bus
= &mdio_bus_type
;
2818 new_driver
->mdiodrv
.driver
.probe
= phy_probe
;
2819 new_driver
->mdiodrv
.driver
.remove
= phy_remove
;
2820 new_driver
->mdiodrv
.driver
.owner
= owner
;
2821 new_driver
->mdiodrv
.driver
.probe_type
= PROBE_FORCE_SYNCHRONOUS
;
2823 retval
= driver_register(&new_driver
->mdiodrv
.driver
);
2825 pr_err("%s: Error %d in registering driver\n",
2826 new_driver
->name
, retval
);
2831 pr_debug("%s: Registered new driver\n", new_driver
->name
);
2835 EXPORT_SYMBOL(phy_driver_register
);
2837 int phy_drivers_register(struct phy_driver
*new_driver
, int n
,
2838 struct module
*owner
)
2842 for (i
= 0; i
< n
; i
++) {
2843 ret
= phy_driver_register(new_driver
+ i
, owner
);
2846 phy_driver_unregister(new_driver
+ i
);
2852 EXPORT_SYMBOL(phy_drivers_register
);
2854 void phy_driver_unregister(struct phy_driver
*drv
)
2856 driver_unregister(&drv
->mdiodrv
.driver
);
2858 EXPORT_SYMBOL(phy_driver_unregister
);
2860 void phy_drivers_unregister(struct phy_driver
*drv
, int n
)
2864 for (i
= 0; i
< n
; i
++)
2865 phy_driver_unregister(drv
+ i
);
2867 EXPORT_SYMBOL(phy_drivers_unregister
);
2869 static struct phy_driver genphy_driver
= {
2870 .phy_id
= 0xffffffff,
2871 .phy_id_mask
= 0xffffffff,
2872 .name
= "Generic PHY",
2873 .get_features
= genphy_read_abilities
,
2874 .suspend
= genphy_suspend
,
2875 .resume
= genphy_resume
,
2876 .set_loopback
= genphy_loopback
,
2879 static int __init
phy_init(void)
2883 rc
= mdio_bus_init();
2889 rc
= phy_driver_register(&genphy_c45_driver
, THIS_MODULE
);
2893 rc
= phy_driver_register(&genphy_driver
, THIS_MODULE
);
2895 phy_driver_unregister(&genphy_c45_driver
);
2903 static void __exit
phy_exit(void)
2905 phy_driver_unregister(&genphy_c45_driver
);
2906 phy_driver_unregister(&genphy_driver
);
2910 subsys_initcall(phy_init
);
2911 module_exit(phy_exit
);