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