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