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