Branch data Line data Source code
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/kernel.h>
13 : : #include <linux/string.h>
14 : : #include <linux/errno.h>
15 : : #include <linux/unistd.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/interrupt.h>
18 : : #include <linux/init.h>
19 : : #include <linux/delay.h>
20 : : #include <linux/netdevice.h>
21 : : #include <linux/etherdevice.h>
22 : : #include <linux/skbuff.h>
23 : : #include <linux/mm.h>
24 : : #include <linux/module.h>
25 : : #include <linux/mii.h>
26 : : #include <linux/ethtool.h>
27 : : #include <linux/bitmap.h>
28 : : #include <linux/phy.h>
29 : : #include <linux/phy_led_triggers.h>
30 : : #include <linux/sfp.h>
31 : : #include <linux/mdio.h>
32 : : #include <linux/io.h>
33 : : #include <linux/uaccess.h>
34 : :
35 : : MODULE_DESCRIPTION("PHY library");
36 : : MODULE_AUTHOR("Andy Fleming");
37 : : MODULE_LICENSE("GPL");
38 : :
39 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
40 : : EXPORT_SYMBOL_GPL(phy_basic_features);
41 : :
42 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
43 : : EXPORT_SYMBOL_GPL(phy_basic_t1_features);
44 : :
45 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
46 : : EXPORT_SYMBOL_GPL(phy_gbit_features);
47 : :
48 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
49 : : EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
50 : :
51 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
52 : : EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
53 : :
54 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
55 : : EXPORT_SYMBOL_GPL(phy_10gbit_features);
56 : :
57 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
58 : : EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
59 : :
60 : : const int phy_basic_ports_array[3] = {
61 : : ETHTOOL_LINK_MODE_Autoneg_BIT,
62 : : ETHTOOL_LINK_MODE_TP_BIT,
63 : : ETHTOOL_LINK_MODE_MII_BIT,
64 : : };
65 : : EXPORT_SYMBOL_GPL(phy_basic_ports_array);
66 : :
67 : : const int phy_fibre_port_array[1] = {
68 : : ETHTOOL_LINK_MODE_FIBRE_BIT,
69 : : };
70 : : EXPORT_SYMBOL_GPL(phy_fibre_port_array);
71 : :
72 : : const int phy_all_ports_features_array[7] = {
73 : : ETHTOOL_LINK_MODE_Autoneg_BIT,
74 : : ETHTOOL_LINK_MODE_TP_BIT,
75 : : ETHTOOL_LINK_MODE_MII_BIT,
76 : : ETHTOOL_LINK_MODE_FIBRE_BIT,
77 : : ETHTOOL_LINK_MODE_AUI_BIT,
78 : : ETHTOOL_LINK_MODE_BNC_BIT,
79 : : ETHTOOL_LINK_MODE_Backplane_BIT,
80 : : };
81 : : EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
82 : :
83 : : const int phy_10_100_features_array[4] = {
84 : : ETHTOOL_LINK_MODE_10baseT_Half_BIT,
85 : : ETHTOOL_LINK_MODE_10baseT_Full_BIT,
86 : : ETHTOOL_LINK_MODE_100baseT_Half_BIT,
87 : : ETHTOOL_LINK_MODE_100baseT_Full_BIT,
88 : : };
89 : : EXPORT_SYMBOL_GPL(phy_10_100_features_array);
90 : :
91 : : const int phy_basic_t1_features_array[2] = {
92 : : ETHTOOL_LINK_MODE_TP_BIT,
93 : : ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
94 : : };
95 : : EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
96 : :
97 : : const int phy_gbit_features_array[2] = {
98 : : ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
99 : : ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
100 : : };
101 : : EXPORT_SYMBOL_GPL(phy_gbit_features_array);
102 : :
103 : : const int phy_10gbit_features_array[1] = {
104 : : ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
105 : : };
106 : : EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
107 : :
108 : : const int phy_10gbit_fec_features_array[1] = {
109 : : ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
110 : : };
111 : : EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array);
112 : :
113 : : __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
114 : : EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
115 : :
116 : : static const int phy_10gbit_full_features_array[] = {
117 : : ETHTOOL_LINK_MODE_10baseT_Full_BIT,
118 : : ETHTOOL_LINK_MODE_100baseT_Full_BIT,
119 : : ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
120 : : ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
121 : : };
122 : :
123 : 3 : static void features_init(void)
124 : : {
125 : : /* 10/100 half/full*/
126 : 3 : linkmode_set_bit_array(phy_basic_ports_array,
127 : : ARRAY_SIZE(phy_basic_ports_array),
128 : : phy_basic_features);
129 : 3 : linkmode_set_bit_array(phy_10_100_features_array,
130 : : ARRAY_SIZE(phy_10_100_features_array),
131 : : phy_basic_features);
132 : :
133 : : /* 100 full, TP */
134 : 3 : linkmode_set_bit_array(phy_basic_t1_features_array,
135 : : ARRAY_SIZE(phy_basic_t1_features_array),
136 : : phy_basic_t1_features);
137 : :
138 : : /* 10/100 half/full + 1000 half/full */
139 : 3 : linkmode_set_bit_array(phy_basic_ports_array,
140 : : ARRAY_SIZE(phy_basic_ports_array),
141 : : phy_gbit_features);
142 : 3 : linkmode_set_bit_array(phy_10_100_features_array,
143 : : ARRAY_SIZE(phy_10_100_features_array),
144 : : phy_gbit_features);
145 : 3 : linkmode_set_bit_array(phy_gbit_features_array,
146 : : ARRAY_SIZE(phy_gbit_features_array),
147 : : phy_gbit_features);
148 : :
149 : : /* 10/100 half/full + 1000 half/full + fibre*/
150 : 3 : linkmode_set_bit_array(phy_basic_ports_array,
151 : : ARRAY_SIZE(phy_basic_ports_array),
152 : : phy_gbit_fibre_features);
153 : 3 : linkmode_set_bit_array(phy_10_100_features_array,
154 : : ARRAY_SIZE(phy_10_100_features_array),
155 : : phy_gbit_fibre_features);
156 : 3 : linkmode_set_bit_array(phy_gbit_features_array,
157 : : ARRAY_SIZE(phy_gbit_features_array),
158 : : phy_gbit_fibre_features);
159 : 3 : linkmode_set_bit_array(phy_fibre_port_array,
160 : : ARRAY_SIZE(phy_fibre_port_array),
161 : : phy_gbit_fibre_features);
162 : :
163 : : /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
164 : 3 : linkmode_set_bit_array(phy_all_ports_features_array,
165 : : ARRAY_SIZE(phy_all_ports_features_array),
166 : : phy_gbit_all_ports_features);
167 : 3 : linkmode_set_bit_array(phy_10_100_features_array,
168 : : ARRAY_SIZE(phy_10_100_features_array),
169 : : phy_gbit_all_ports_features);
170 : 3 : linkmode_set_bit_array(phy_gbit_features_array,
171 : : ARRAY_SIZE(phy_gbit_features_array),
172 : : phy_gbit_all_ports_features);
173 : :
174 : : /* 10/100 half/full + 1000 half/full + 10G full*/
175 : 3 : linkmode_set_bit_array(phy_all_ports_features_array,
176 : : ARRAY_SIZE(phy_all_ports_features_array),
177 : : phy_10gbit_features);
178 : 3 : linkmode_set_bit_array(phy_10_100_features_array,
179 : : ARRAY_SIZE(phy_10_100_features_array),
180 : : phy_10gbit_features);
181 : 3 : linkmode_set_bit_array(phy_gbit_features_array,
182 : : ARRAY_SIZE(phy_gbit_features_array),
183 : : phy_10gbit_features);
184 : 3 : linkmode_set_bit_array(phy_10gbit_features_array,
185 : : ARRAY_SIZE(phy_10gbit_features_array),
186 : : phy_10gbit_features);
187 : :
188 : : /* 10/100/1000/10G full */
189 : 3 : linkmode_set_bit_array(phy_all_ports_features_array,
190 : : ARRAY_SIZE(phy_all_ports_features_array),
191 : : phy_10gbit_full_features);
192 : 3 : linkmode_set_bit_array(phy_10gbit_full_features_array,
193 : : ARRAY_SIZE(phy_10gbit_full_features_array),
194 : : phy_10gbit_full_features);
195 : : /* 10G FEC only */
196 : 3 : linkmode_set_bit_array(phy_10gbit_fec_features_array,
197 : : ARRAY_SIZE(phy_10gbit_fec_features_array),
198 : : phy_10gbit_fec_features);
199 : 3 : }
200 : :
201 : 0 : void phy_device_free(struct phy_device *phydev)
202 : : {
203 : 0 : put_device(&phydev->mdio.dev);
204 : 0 : }
205 : : EXPORT_SYMBOL(phy_device_free);
206 : :
207 : 0 : static void phy_mdio_device_free(struct mdio_device *mdiodev)
208 : : {
209 : 0 : struct phy_device *phydev;
210 : :
211 : 0 : phydev = container_of(mdiodev, struct phy_device, mdio);
212 : 0 : phy_device_free(phydev);
213 : 0 : }
214 : :
215 : 0 : static void phy_device_release(struct device *dev)
216 : : {
217 : 0 : kfree(to_phy_device(dev));
218 : 0 : }
219 : :
220 : 0 : static void phy_mdio_device_remove(struct mdio_device *mdiodev)
221 : : {
222 : 0 : struct phy_device *phydev;
223 : :
224 : 0 : phydev = container_of(mdiodev, struct phy_device, mdio);
225 : 0 : phy_device_remove(phydev);
226 : 0 : }
227 : :
228 : : static struct phy_driver genphy_driver;
229 : : extern struct phy_driver genphy_c45_driver;
230 : :
231 : : static LIST_HEAD(phy_fixup_list);
232 : : static DEFINE_MUTEX(phy_fixup_lock);
233 : :
234 : : #ifdef CONFIG_PM
235 : 0 : static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
236 : : {
237 : 0 : struct device_driver *drv = phydev->mdio.dev.driver;
238 : 0 : struct phy_driver *phydrv = to_phy_driver(drv);
239 : 0 : struct net_device *netdev = phydev->attached_dev;
240 : :
241 [ # # # # ]: 0 : if (!drv || !phydrv->suspend)
242 : : return false;
243 : :
244 : : /* PHY not attached? May suspend if the PHY has not already been
245 : : * suspended as part of a prior call to phy_disconnect() ->
246 : : * phy_detach() -> phy_suspend() because the parent netdev might be the
247 : : * MDIO bus driver and clock gated at this point.
248 : : */
249 [ # # ]: 0 : if (!netdev)
250 : 0 : goto out;
251 : :
252 [ # # ]: 0 : if (netdev->wol_enabled)
253 : : return false;
254 : :
255 : : /* As long as not all affected network drivers support the
256 : : * wol_enabled flag, let's check for hints that WoL is enabled.
257 : : * Don't suspend PHY if the attached netdev parent may wake up.
258 : : * The parent may point to a PCI device, as in tg3 driver.
259 : : */
260 [ # # # # ]: 0 : if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
261 : : return false;
262 : :
263 : : /* Also don't suspend PHY if the netdev itself may wakeup. This
264 : : * is the case for devices w/o underlaying pwr. mgmt. aware bus,
265 : : * e.g. SoC devices.
266 : : */
267 [ # # # # ]: 0 : if (device_may_wakeup(&netdev->dev))
268 : : return false;
269 : :
270 : 0 : out:
271 : 0 : return !phydev->suspended;
272 : : }
273 : :
274 : 0 : static int mdio_bus_phy_suspend(struct device *dev)
275 : : {
276 : 0 : struct phy_device *phydev = to_phy_device(dev);
277 : :
278 : : /* We must stop the state machine manually, otherwise it stops out of
279 : : * control, possibly with the phydev->lock held. Upon resume, netdev
280 : : * may call phy routines that try to grab the same lock, and that may
281 : : * lead to a deadlock.
282 : : */
283 [ # # # # ]: 0 : if (phydev->attached_dev && phydev->adjust_link)
284 : 0 : phy_stop_machine(phydev);
285 : :
286 [ # # ]: 0 : if (!mdio_bus_phy_may_suspend(phydev))
287 : : return 0;
288 : :
289 : 0 : phydev->suspended_by_mdio_bus = 1;
290 : :
291 : 0 : return phy_suspend(phydev);
292 : : }
293 : :
294 : 0 : static int mdio_bus_phy_resume(struct device *dev)
295 : : {
296 : 0 : struct phy_device *phydev = to_phy_device(dev);
297 : 0 : int ret;
298 : :
299 [ # # ]: 0 : if (!phydev->suspended_by_mdio_bus)
300 : 0 : goto no_resume;
301 : :
302 : 0 : phydev->suspended_by_mdio_bus = 0;
303 : :
304 : 0 : ret = phy_resume(phydev);
305 [ # # ]: 0 : if (ret < 0)
306 : : return ret;
307 : :
308 : 0 : no_resume:
309 [ # # # # ]: 0 : if (phydev->attached_dev && phydev->adjust_link)
310 : 0 : phy_start_machine(phydev);
311 : :
312 : : return 0;
313 : : }
314 : :
315 : 0 : static int mdio_bus_phy_restore(struct device *dev)
316 : : {
317 : 0 : struct phy_device *phydev = to_phy_device(dev);
318 : 0 : struct net_device *netdev = phydev->attached_dev;
319 : 0 : int ret;
320 : :
321 [ # # ]: 0 : if (!netdev)
322 : : return 0;
323 : :
324 : 0 : ret = phy_init_hw(phydev);
325 [ # # ]: 0 : if (ret < 0)
326 : : return ret;
327 : :
328 [ # # # # ]: 0 : if (phydev->attached_dev && phydev->adjust_link)
329 : 0 : phy_start_machine(phydev);
330 : :
331 : : return 0;
332 : : }
333 : :
334 : : static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
335 : : .suspend = mdio_bus_phy_suspend,
336 : : .resume = mdio_bus_phy_resume,
337 : : .freeze = mdio_bus_phy_suspend,
338 : : .thaw = mdio_bus_phy_resume,
339 : : .restore = mdio_bus_phy_restore,
340 : : };
341 : :
342 : : #define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
343 : :
344 : : #else
345 : :
346 : : #define MDIO_BUS_PHY_PM_OPS NULL
347 : :
348 : : #endif /* CONFIG_PM */
349 : :
350 : : /**
351 : : * phy_register_fixup - creates a new phy_fixup and adds it to the list
352 : : * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
353 : : * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
354 : : * It can also be PHY_ANY_UID
355 : : * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
356 : : * comparison
357 : : * @run: The actual code to be run when a matching PHY is found
358 : : */
359 : 0 : int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
360 : : int (*run)(struct phy_device *))
361 : : {
362 : 0 : struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
363 : :
364 [ # # ]: 0 : if (!fixup)
365 : : return -ENOMEM;
366 : :
367 : 0 : strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
368 : 0 : fixup->phy_uid = phy_uid;
369 : 0 : fixup->phy_uid_mask = phy_uid_mask;
370 : 0 : fixup->run = run;
371 : :
372 : 0 : mutex_lock(&phy_fixup_lock);
373 : 0 : list_add_tail(&fixup->list, &phy_fixup_list);
374 : 0 : mutex_unlock(&phy_fixup_lock);
375 : :
376 : 0 : return 0;
377 : : }
378 : : EXPORT_SYMBOL(phy_register_fixup);
379 : :
380 : : /* Registers a fixup to be run on any PHY with the UID in phy_uid */
381 : 0 : int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
382 : : int (*run)(struct phy_device *))
383 : : {
384 : 0 : return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
385 : : }
386 : : EXPORT_SYMBOL(phy_register_fixup_for_uid);
387 : :
388 : : /* Registers a fixup to be run on the PHY with id string bus_id */
389 : 0 : int phy_register_fixup_for_id(const char *bus_id,
390 : : int (*run)(struct phy_device *))
391 : : {
392 : 0 : return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
393 : : }
394 : : EXPORT_SYMBOL(phy_register_fixup_for_id);
395 : :
396 : : /**
397 : : * phy_unregister_fixup - remove a phy_fixup from the list
398 : : * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
399 : : * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
400 : : * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
401 : : */
402 : 0 : int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
403 : : {
404 : 0 : struct list_head *pos, *n;
405 : 0 : struct phy_fixup *fixup;
406 : 0 : int ret;
407 : :
408 : 0 : ret = -ENODEV;
409 : :
410 : 0 : mutex_lock(&phy_fixup_lock);
411 [ # # ]: 0 : list_for_each_safe(pos, n, &phy_fixup_list) {
412 : 0 : fixup = list_entry(pos, struct phy_fixup, list);
413 : :
414 [ # # ]: 0 : if ((!strcmp(fixup->bus_id, bus_id)) &&
415 [ # # ]: 0 : ((fixup->phy_uid & phy_uid_mask) ==
416 : : (phy_uid & phy_uid_mask))) {
417 : 0 : list_del(&fixup->list);
418 : 0 : kfree(fixup);
419 : 0 : ret = 0;
420 : 0 : break;
421 : : }
422 : : }
423 : 0 : mutex_unlock(&phy_fixup_lock);
424 : :
425 : 0 : return ret;
426 : : }
427 : : EXPORT_SYMBOL(phy_unregister_fixup);
428 : :
429 : : /* Unregisters a fixup of any PHY with the UID in phy_uid */
430 : 0 : int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
431 : : {
432 : 0 : return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
433 : : }
434 : : EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
435 : :
436 : : /* Unregisters a fixup of the PHY with id string bus_id */
437 : 0 : int phy_unregister_fixup_for_id(const char *bus_id)
438 : : {
439 : 0 : return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
440 : : }
441 : : EXPORT_SYMBOL(phy_unregister_fixup_for_id);
442 : :
443 : : /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
444 : : * Fixups can be set to match any in one or more fields.
445 : : */
446 : 0 : static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
447 : : {
448 [ # # # # ]: 0 : if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
449 [ # # ]: 0 : if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
450 : : return 0;
451 : :
452 : 0 : if ((fixup->phy_uid & fixup->phy_uid_mask) !=
453 [ # # ]: 0 : (phydev->phy_id & fixup->phy_uid_mask))
454 [ # # ]: 0 : if (fixup->phy_uid != PHY_ANY_UID)
455 : 0 : return 0;
456 : :
457 : : return 1;
458 : : }
459 : :
460 : : /* Runs any matching fixups for this phydev */
461 : 0 : static int phy_scan_fixups(struct phy_device *phydev)
462 : : {
463 : 0 : struct phy_fixup *fixup;
464 : :
465 : 0 : mutex_lock(&phy_fixup_lock);
466 [ # # ]: 0 : list_for_each_entry(fixup, &phy_fixup_list, list) {
467 [ # # ]: 0 : if (phy_needs_fixup(phydev, fixup)) {
468 : 0 : int err = fixup->run(phydev);
469 : :
470 [ # # ]: 0 : if (err < 0) {
471 : 0 : mutex_unlock(&phy_fixup_lock);
472 : 0 : return err;
473 : : }
474 : 0 : phydev->has_fixups = true;
475 : : }
476 : : }
477 : 0 : mutex_unlock(&phy_fixup_lock);
478 : :
479 : 0 : return 0;
480 : : }
481 : :
482 : 0 : static int phy_bus_match(struct device *dev, struct device_driver *drv)
483 : : {
484 : 0 : struct phy_device *phydev = to_phy_device(dev);
485 : 0 : struct phy_driver *phydrv = to_phy_driver(drv);
486 : 0 : const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
487 : 0 : int i;
488 : :
489 [ # # ]: 0 : if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
490 : : return 0;
491 : :
492 [ # # ]: 0 : if (phydrv->match_phy_device)
493 : 0 : return phydrv->match_phy_device(phydev);
494 : :
495 [ # # ]: 0 : if (phydev->is_c45) {
496 [ # # ]: 0 : for (i = 1; i < num_ids; i++) {
497 [ # # ]: 0 : if (phydev->c45_ids.device_ids[i] == 0xffffffff)
498 : 0 : continue;
499 : :
500 [ # # ]: 0 : if ((phydrv->phy_id & phydrv->phy_id_mask) ==
501 : : (phydev->c45_ids.device_ids[i] &
502 : : phydrv->phy_id_mask))
503 : : return 1;
504 : : }
505 : : return 0;
506 : : } else {
507 : 0 : return (phydrv->phy_id & phydrv->phy_id_mask) ==
508 : 0 : (phydev->phy_id & phydrv->phy_id_mask);
509 : : }
510 : : }
511 : :
512 : : static ssize_t
513 : 0 : phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
514 : : {
515 : 0 : struct phy_device *phydev = to_phy_device(dev);
516 : :
517 : 0 : return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
518 : : }
519 : : static DEVICE_ATTR_RO(phy_id);
520 : :
521 : : static ssize_t
522 : 0 : phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
523 : : {
524 : 0 : struct phy_device *phydev = to_phy_device(dev);
525 : 0 : const char *mode = NULL;
526 : :
527 [ # # ]: 0 : if (phy_is_internal(phydev))
528 : : mode = "internal";
529 : : else
530 [ # # ]: 0 : mode = phy_modes(phydev->interface);
531 : :
532 : 0 : return sprintf(buf, "%s\n", mode);
533 : : }
534 : : static DEVICE_ATTR_RO(phy_interface);
535 : :
536 : : static ssize_t
537 : 0 : phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
538 : : char *buf)
539 : : {
540 : 0 : struct phy_device *phydev = to_phy_device(dev);
541 : :
542 : 0 : return sprintf(buf, "%d\n", phydev->has_fixups);
543 : : }
544 : : static DEVICE_ATTR_RO(phy_has_fixups);
545 : :
546 : : static struct attribute *phy_dev_attrs[] = {
547 : : &dev_attr_phy_id.attr,
548 : : &dev_attr_phy_interface.attr,
549 : : &dev_attr_phy_has_fixups.attr,
550 : : NULL,
551 : : };
552 : : ATTRIBUTE_GROUPS(phy_dev);
553 : :
554 : : static const struct device_type mdio_bus_phy_type = {
555 : : .name = "PHY",
556 : : .groups = phy_dev_groups,
557 : : .release = phy_device_release,
558 : : .pm = MDIO_BUS_PHY_PM_OPS,
559 : : };
560 : :
561 : 0 : static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
562 : : {
563 : 0 : int ret;
564 : :
565 : 0 : ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
566 : : MDIO_ID_ARGS(phy_id));
567 : : /* We only check for failures in executing the usermode binary,
568 : : * not whether a PHY driver module exists for the PHY ID.
569 : : * Accept -ENOENT because this may occur in case no initramfs exists,
570 : : * then modprobe isn't available.
571 : : */
572 [ # # ]: 0 : if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
573 : 0 : phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",
574 : : ret, (unsigned long)phy_id);
575 : 0 : return ret;
576 : : }
577 : :
578 : : return 0;
579 : : }
580 : :
581 : 0 : struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
582 : : bool is_c45,
583 : : struct phy_c45_device_ids *c45_ids)
584 : : {
585 : 0 : struct phy_device *dev;
586 : 0 : struct mdio_device *mdiodev;
587 : 0 : int ret = 0;
588 : :
589 : : /* We allocate the device, and initialize the default values */
590 : 0 : dev = kzalloc(sizeof(*dev), GFP_KERNEL);
591 [ # # ]: 0 : if (!dev)
592 : : return ERR_PTR(-ENOMEM);
593 : :
594 : 0 : mdiodev = &dev->mdio;
595 : 0 : mdiodev->dev.parent = &bus->dev;
596 : 0 : mdiodev->dev.bus = &mdio_bus_type;
597 : 0 : mdiodev->dev.type = &mdio_bus_phy_type;
598 : 0 : mdiodev->bus = bus;
599 : 0 : mdiodev->bus_match = phy_bus_match;
600 : 0 : mdiodev->addr = addr;
601 : 0 : mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
602 : 0 : mdiodev->device_free = phy_mdio_device_free;
603 : 0 : mdiodev->device_remove = phy_mdio_device_remove;
604 : :
605 : 0 : dev->speed = SPEED_UNKNOWN;
606 : 0 : dev->duplex = DUPLEX_UNKNOWN;
607 : 0 : dev->pause = 0;
608 : 0 : dev->asym_pause = 0;
609 : 0 : dev->link = 0;
610 : 0 : dev->interface = PHY_INTERFACE_MODE_GMII;
611 : :
612 : 0 : dev->autoneg = AUTONEG_ENABLE;
613 : :
614 : 0 : dev->is_c45 = is_c45;
615 : 0 : dev->phy_id = phy_id;
616 [ # # ]: 0 : if (c45_ids)
617 : 0 : dev->c45_ids = *c45_ids;
618 : 0 : dev->irq = bus->irq[addr];
619 : 0 : dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
620 : :
621 : 0 : dev->state = PHY_DOWN;
622 : :
623 : 0 : mutex_init(&dev->lock);
624 : 0 : INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
625 : :
626 : : /* Request the appropriate module unconditionally; don't
627 : : * bother trying to do so only if it isn't already loaded,
628 : : * because that gets complicated. A hotplug event would have
629 : : * done an unconditional modprobe anyway.
630 : : * We don't do normal hotplug because it won't work for MDIO
631 : : * -- because it relies on the device staying around for long
632 : : * enough for the driver to get loaded. With MDIO, the NIC
633 : : * driver will get bored and give up as soon as it finds that
634 : : * there's no driver _already_ loaded.
635 : : */
636 [ # # ]: 0 : if (is_c45 && c45_ids) {
637 : : const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
638 : : int i;
639 : :
640 [ # # ]: 0 : for (i = 1; i < num_ids; i++) {
641 [ # # ]: 0 : if (c45_ids->device_ids[i] == 0xffffffff)
642 : 0 : continue;
643 : :
644 : 0 : ret = phy_request_driver_module(dev,
645 : : c45_ids->device_ids[i]);
646 [ # # ]: 0 : if (ret)
647 : : break;
648 : : }
649 : : } else {
650 : 0 : ret = phy_request_driver_module(dev, phy_id);
651 : : }
652 : :
653 [ # # ]: 0 : if (!ret) {
654 : 0 : device_initialize(&mdiodev->dev);
655 : : } else {
656 : 0 : kfree(dev);
657 : 0 : dev = ERR_PTR(ret);
658 : : }
659 : :
660 : : return dev;
661 : : }
662 : : EXPORT_SYMBOL(phy_device_create);
663 : :
664 : : /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
665 : : * @bus: the target MII bus
666 : : * @addr: PHY address on the MII bus
667 : : * @dev_addr: MMD address in the PHY.
668 : : * @devices_in_package: where to store the devices in package information.
669 : : *
670 : : * Description: reads devices in package registers of a MMD at @dev_addr
671 : : * from PHY at @addr on @bus.
672 : : *
673 : : * Returns: 0 on success, -EIO on failure.
674 : : */
675 : 0 : static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
676 : : u32 *devices_in_package)
677 : : {
678 : 0 : int phy_reg, reg_addr;
679 : :
680 : 0 : reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
681 : 0 : phy_reg = mdiobus_read(bus, addr, reg_addr);
682 [ # # ]: 0 : if (phy_reg < 0)
683 : : return -EIO;
684 : 0 : *devices_in_package = phy_reg << 16;
685 : :
686 : 0 : reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
687 : 0 : phy_reg = mdiobus_read(bus, addr, reg_addr);
688 [ # # ]: 0 : if (phy_reg < 0)
689 : : return -EIO;
690 : 0 : *devices_in_package |= phy_reg;
691 : :
692 : : /* Bit 0 doesn't represent a device, it indicates c22 regs presence */
693 : 0 : *devices_in_package &= ~BIT(0);
694 : :
695 : 0 : return 0;
696 : : }
697 : :
698 : : /**
699 : : * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
700 : : * @bus: the target MII bus
701 : : * @addr: PHY address on the MII bus
702 : : * @phy_id: where to store the ID retrieved.
703 : : * @c45_ids: where to store the c45 ID information.
704 : : *
705 : : * If the PHY devices-in-package appears to be valid, it and the
706 : : * corresponding identifiers are stored in @c45_ids, zero is stored
707 : : * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
708 : : * zero on success.
709 : : *
710 : : */
711 : 0 : static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
712 : : struct phy_c45_device_ids *c45_ids) {
713 : 0 : int phy_reg;
714 : 0 : int i, reg_addr;
715 : 0 : const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
716 : 0 : u32 *devs = &c45_ids->devices_in_package;
717 : :
718 : : /* Find first non-zero Devices In package. Device zero is reserved
719 : : * for 802.3 c45 complied PHYs, so don't probe it at first.
720 : : */
721 [ # # # # ]: 0 : for (i = 1; i < num_ids && *devs == 0; i++) {
722 : 0 : phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
723 [ # # ]: 0 : if (phy_reg < 0)
724 : : return -EIO;
725 : :
726 [ # # ]: 0 : if ((*devs & 0x1fffffff) == 0x1fffffff) {
727 : : /* If mostly Fs, there is no device there,
728 : : * then let's continue to probe more, as some
729 : : * 10G PHYs have zero Devices In package,
730 : : * e.g. Cortina CS4315/CS4340 PHY.
731 : : */
732 : 0 : phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
733 [ # # ]: 0 : if (phy_reg < 0)
734 : : return -EIO;
735 : : /* no device there, let's get out of here */
736 [ # # ]: 0 : if ((*devs & 0x1fffffff) == 0x1fffffff) {
737 : 0 : *phy_id = 0xffffffff;
738 : 0 : return 0;
739 : : } else {
740 : : break;
741 : : }
742 : : }
743 : : }
744 : :
745 : : /* Now probe Device Identifiers for each device present. */
746 [ # # ]: 0 : for (i = 1; i < num_ids; i++) {
747 [ # # ]: 0 : if (!(c45_ids->devices_in_package & (1 << i)))
748 : 0 : continue;
749 : :
750 : 0 : reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
751 : 0 : phy_reg = mdiobus_read(bus, addr, reg_addr);
752 [ # # ]: 0 : if (phy_reg < 0)
753 : : return -EIO;
754 : 0 : c45_ids->device_ids[i] = phy_reg << 16;
755 : :
756 : 0 : reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
757 : 0 : phy_reg = mdiobus_read(bus, addr, reg_addr);
758 [ # # ]: 0 : if (phy_reg < 0)
759 : : return -EIO;
760 : 0 : c45_ids->device_ids[i] |= phy_reg;
761 : : }
762 : 0 : *phy_id = 0;
763 : 0 : return 0;
764 : : }
765 : :
766 : : /**
767 : : * get_phy_id - reads the specified addr for its ID.
768 : : * @bus: the target MII bus
769 : : * @addr: PHY address on the MII bus
770 : : * @phy_id: where to store the ID retrieved.
771 : : * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
772 : : * @c45_ids: where to store the c45 ID information.
773 : : *
774 : : * Description: In the case of a 802.3-c22 PHY, reads the ID registers
775 : : * of the PHY at @addr on the @bus, stores it in @phy_id and returns
776 : : * zero on success.
777 : : *
778 : : * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
779 : : * its return value is in turn returned.
780 : : *
781 : : */
782 : 0 : static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
783 : : bool is_c45, struct phy_c45_device_ids *c45_ids)
784 : : {
785 : 0 : int phy_reg;
786 : :
787 [ # # ]: 0 : if (is_c45)
788 : 0 : return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
789 : :
790 : : /* Grab the bits from PHYIR1, and put them in the upper half */
791 : 0 : phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
792 [ # # ]: 0 : if (phy_reg < 0) {
793 : : /* returning -ENODEV doesn't stop bus scanning */
794 [ # # ]: 0 : return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
795 : : }
796 : :
797 : 0 : *phy_id = phy_reg << 16;
798 : :
799 : : /* Grab the bits from PHYIR2, and put them in the lower half */
800 : 0 : phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
801 [ # # ]: 0 : if (phy_reg < 0)
802 : : return -EIO;
803 : :
804 : 0 : *phy_id |= phy_reg;
805 : :
806 : 0 : return 0;
807 : : }
808 : :
809 : : /**
810 : : * get_phy_device - reads the specified PHY device and returns its @phy_device
811 : : * struct
812 : : * @bus: the target MII bus
813 : : * @addr: PHY address on the MII bus
814 : : * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
815 : : *
816 : : * Description: Reads the ID registers of the PHY at @addr on the
817 : : * @bus, then allocates and returns the phy_device to represent it.
818 : : */
819 : 0 : struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
820 : : {
821 : 0 : struct phy_c45_device_ids c45_ids;
822 : 0 : u32 phy_id = 0;
823 : 0 : int r;
824 : :
825 : 0 : c45_ids.devices_in_package = 0;
826 : 0 : memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));
827 : :
828 : 0 : r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
829 [ # # ]: 0 : if (r)
830 : 0 : return ERR_PTR(r);
831 : :
832 : : /* If the phy_id is mostly Fs, there is no device there */
833 [ # # ]: 0 : if ((phy_id & 0x1fffffff) == 0x1fffffff)
834 : : return ERR_PTR(-ENODEV);
835 : :
836 : 0 : return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
837 : : }
838 : : EXPORT_SYMBOL(get_phy_device);
839 : :
840 : : /**
841 : : * phy_device_register - Register the phy device on the MDIO bus
842 : : * @phydev: phy_device structure to be added to the MDIO bus
843 : : */
844 : 0 : int phy_device_register(struct phy_device *phydev)
845 : : {
846 : 0 : int err;
847 : :
848 : 0 : err = mdiobus_register_device(&phydev->mdio);
849 [ # # ]: 0 : if (err)
850 : : return err;
851 : :
852 : : /* Deassert the reset signal */
853 : 0 : phy_device_reset(phydev, 0);
854 : :
855 : : /* Run all of the fixups for this PHY */
856 : 0 : err = phy_scan_fixups(phydev);
857 [ # # ]: 0 : if (err) {
858 : 0 : phydev_err(phydev, "failed to initialize\n");
859 : 0 : goto out;
860 : : }
861 : :
862 : 0 : err = device_add(&phydev->mdio.dev);
863 [ # # ]: 0 : if (err) {
864 : 0 : phydev_err(phydev, "failed to add\n");
865 : 0 : goto out;
866 : : }
867 : :
868 : : return 0;
869 : :
870 : 0 : out:
871 : : /* Assert the reset signal */
872 : 0 : phy_device_reset(phydev, 1);
873 : :
874 : 0 : mdiobus_unregister_device(&phydev->mdio);
875 : 0 : return err;
876 : : }
877 : : EXPORT_SYMBOL(phy_device_register);
878 : :
879 : : /**
880 : : * phy_device_remove - Remove a previously registered phy device from the MDIO bus
881 : : * @phydev: phy_device structure to remove
882 : : *
883 : : * This doesn't free the phy_device itself, it merely reverses the effects
884 : : * of phy_device_register(). Use phy_device_free() to free the device
885 : : * after calling this function.
886 : : */
887 : 0 : void phy_device_remove(struct phy_device *phydev)
888 : : {
889 : 0 : if (phydev->mii_ts)
890 : : unregister_mii_timestamper(phydev->mii_ts);
891 : :
892 : 0 : device_del(&phydev->mdio.dev);
893 : :
894 : : /* Assert the reset signal */
895 : 0 : phy_device_reset(phydev, 1);
896 : :
897 : 0 : mdiobus_unregister_device(&phydev->mdio);
898 : 0 : }
899 : : EXPORT_SYMBOL(phy_device_remove);
900 : :
901 : : /**
902 : : * phy_find_first - finds the first PHY device on the bus
903 : : * @bus: the target MII bus
904 : : */
905 : 0 : struct phy_device *phy_find_first(struct mii_bus *bus)
906 : : {
907 : 0 : struct phy_device *phydev;
908 : 0 : int addr;
909 : :
910 [ # # ]: 0 : for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
911 : 0 : phydev = mdiobus_get_phy(bus, addr);
912 [ # # ]: 0 : if (phydev)
913 : 0 : return phydev;
914 : : }
915 : : return NULL;
916 : : }
917 : : EXPORT_SYMBOL(phy_find_first);
918 : :
919 : 0 : static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier)
920 : : {
921 : 0 : struct net_device *netdev = phydev->attached_dev;
922 : :
923 [ # # ]: 0 : if (do_carrier) {
924 [ # # ]: 0 : if (up)
925 : 0 : netif_carrier_on(netdev);
926 : : else
927 : 0 : netif_carrier_off(netdev);
928 : : }
929 : 0 : phydev->adjust_link(netdev);
930 [ # # # # ]: 0 : if (phydev->mii_ts && phydev->mii_ts->link_state)
931 : 0 : phydev->mii_ts->link_state(phydev->mii_ts, phydev);
932 : 0 : }
933 : :
934 : : /**
935 : : * phy_prepare_link - prepares the PHY layer to monitor link status
936 : : * @phydev: target phy_device struct
937 : : * @handler: callback function for link status change notifications
938 : : *
939 : : * Description: Tells the PHY infrastructure to handle the
940 : : * gory details on monitoring link status (whether through
941 : : * polling or an interrupt), and to call back to the
942 : : * connected device driver when the link status changes.
943 : : * If you want to monitor your own link state, don't call
944 : : * this function.
945 : : */
946 : 0 : static void phy_prepare_link(struct phy_device *phydev,
947 : : void (*handler)(struct net_device *))
948 : : {
949 : 0 : phydev->adjust_link = handler;
950 : : }
951 : :
952 : : /**
953 : : * phy_connect_direct - connect an ethernet device to a specific phy_device
954 : : * @dev: the network device to connect
955 : : * @phydev: the pointer to the phy device
956 : : * @handler: callback function for state change notifications
957 : : * @interface: PHY device's interface
958 : : */
959 : 0 : int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
960 : : void (*handler)(struct net_device *),
961 : : phy_interface_t interface)
962 : : {
963 : 0 : int rc;
964 : :
965 [ # # ]: 0 : if (!dev)
966 : : return -EINVAL;
967 : :
968 : 0 : rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
969 [ # # ]: 0 : if (rc)
970 : : return rc;
971 : :
972 : 0 : phy_prepare_link(phydev, handler);
973 [ # # ]: 0 : if (phy_interrupt_is_valid(phydev))
974 : 0 : phy_request_interrupt(phydev);
975 : :
976 : : return 0;
977 : : }
978 : : EXPORT_SYMBOL(phy_connect_direct);
979 : :
980 : : /**
981 : : * phy_connect - connect an ethernet device to a PHY device
982 : : * @dev: the network device to connect
983 : : * @bus_id: the id string of the PHY device to connect
984 : : * @handler: callback function for state change notifications
985 : : * @interface: PHY device's interface
986 : : *
987 : : * Description: Convenience function for connecting ethernet
988 : : * devices to PHY devices. The default behavior is for
989 : : * the PHY infrastructure to handle everything, and only notify
990 : : * the connected driver when the link status changes. If you
991 : : * don't want, or can't use the provided functionality, you may
992 : : * choose to call only the subset of functions which provide
993 : : * the desired functionality.
994 : : */
995 : 0 : struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
996 : : void (*handler)(struct net_device *),
997 : : phy_interface_t interface)
998 : : {
999 : 0 : struct phy_device *phydev;
1000 : 0 : struct device *d;
1001 : 0 : int rc;
1002 : :
1003 : : /* Search the list of PHY devices on the mdio bus for the
1004 : : * PHY with the requested name
1005 : : */
1006 : 0 : d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1007 [ # # ]: 0 : if (!d) {
1008 : 0 : pr_err("PHY %s not found\n", bus_id);
1009 : 0 : return ERR_PTR(-ENODEV);
1010 : : }
1011 : 0 : phydev = to_phy_device(d);
1012 : :
1013 : 0 : rc = phy_connect_direct(dev, phydev, handler, interface);
1014 : 0 : put_device(d);
1015 [ # # ]: 0 : if (rc)
1016 : 0 : return ERR_PTR(rc);
1017 : :
1018 : : return phydev;
1019 : : }
1020 : : EXPORT_SYMBOL(phy_connect);
1021 : :
1022 : : /**
1023 : : * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
1024 : : * device
1025 : : * @phydev: target phy_device struct
1026 : : */
1027 : 0 : void phy_disconnect(struct phy_device *phydev)
1028 : : {
1029 [ # # ]: 0 : if (phy_is_started(phydev))
1030 : 0 : phy_stop(phydev);
1031 : :
1032 [ # # ]: 0 : if (phy_interrupt_is_valid(phydev))
1033 : 0 : phy_free_interrupt(phydev);
1034 : :
1035 : 0 : phydev->adjust_link = NULL;
1036 : :
1037 : 0 : phy_detach(phydev);
1038 : 0 : }
1039 : : EXPORT_SYMBOL(phy_disconnect);
1040 : :
1041 : : /**
1042 : : * phy_poll_reset - Safely wait until a PHY reset has properly completed
1043 : : * @phydev: The PHY device to poll
1044 : : *
1045 : : * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
1046 : : * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
1047 : : * register must be polled until the BMCR_RESET bit clears.
1048 : : *
1049 : : * Furthermore, any attempts to write to PHY registers may have no effect
1050 : : * or even generate MDIO bus errors until this is complete.
1051 : : *
1052 : : * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
1053 : : * standard and do not fully reset after the BMCR_RESET bit is set, and may
1054 : : * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
1055 : : * effort to support such broken PHYs, this function is separate from the
1056 : : * standard phy_init_hw() which will zero all the other bits in the BMCR
1057 : : * and reapply all driver-specific and board-specific fixups.
1058 : : */
1059 : 0 : static int phy_poll_reset(struct phy_device *phydev)
1060 : : {
1061 : : /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
1062 : 0 : unsigned int retries = 12;
1063 : 0 : int ret;
1064 : :
1065 : 0 : do {
1066 : 0 : msleep(50);
1067 : 0 : ret = phy_read(phydev, MII_BMCR);
1068 [ # # ]: 0 : if (ret < 0)
1069 : 0 : return ret;
1070 [ # # # # ]: 0 : } while (ret & BMCR_RESET && --retries);
1071 [ # # ]: 0 : if (ret & BMCR_RESET)
1072 : : return -ETIMEDOUT;
1073 : :
1074 : : /* Some chips (smsc911x) may still need up to another 1ms after the
1075 : : * BMCR_RESET bit is cleared before they are usable.
1076 : : */
1077 : 0 : msleep(1);
1078 : 0 : return 0;
1079 : : }
1080 : :
1081 : 0 : int phy_init_hw(struct phy_device *phydev)
1082 : : {
1083 : 0 : int ret = 0;
1084 : :
1085 : : /* Deassert the reset signal */
1086 : 0 : phy_device_reset(phydev, 0);
1087 : :
1088 [ # # ]: 0 : if (!phydev->drv)
1089 : : return 0;
1090 : :
1091 [ # # ]: 0 : if (phydev->drv->soft_reset)
1092 : 0 : ret = phydev->drv->soft_reset(phydev);
1093 : :
1094 [ # # ]: 0 : if (ret < 0)
1095 : : return ret;
1096 : :
1097 : 0 : ret = phy_scan_fixups(phydev);
1098 [ # # ]: 0 : if (ret < 0)
1099 : : return ret;
1100 : :
1101 [ # # ]: 0 : if (phydev->drv->config_init)
1102 : 0 : ret = phydev->drv->config_init(phydev);
1103 : :
1104 : : return ret;
1105 : : }
1106 : : EXPORT_SYMBOL(phy_init_hw);
1107 : :
1108 : 0 : void phy_attached_info(struct phy_device *phydev)
1109 : : {
1110 : 0 : phy_attached_print(phydev, NULL);
1111 : 0 : }
1112 : : EXPORT_SYMBOL(phy_attached_info);
1113 : :
1114 : : #define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
1115 : 0 : char *phy_attached_info_irq(struct phy_device *phydev)
1116 : : {
1117 : 0 : char *irq_str;
1118 : 0 : char irq_num[8];
1119 : :
1120 [ # # # ]: 0 : switch(phydev->irq) {
1121 : : case PHY_POLL:
1122 : : irq_str = "POLL";
1123 : : break;
1124 : 0 : case PHY_IGNORE_INTERRUPT:
1125 : 0 : irq_str = "IGNORE";
1126 : 0 : break;
1127 : 0 : default:
1128 : 0 : snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1129 : 0 : irq_str = irq_num;
1130 : 0 : break;
1131 : : }
1132 : :
1133 : 0 : return kasprintf(GFP_KERNEL, "%s", irq_str);
1134 : : }
1135 : : EXPORT_SYMBOL(phy_attached_info_irq);
1136 : :
1137 : 0 : void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1138 : : {
1139 [ # # ]: 0 : const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
1140 : 0 : char *irq_str = phy_attached_info_irq(phydev);
1141 : :
1142 [ # # ]: 0 : if (!fmt) {
1143 [ # # ]: 0 : phydev_info(phydev, ATTACHED_FMT "\n",
1144 : : drv_name, phydev_name(phydev),
1145 : : irq_str);
1146 : : } else {
1147 : 0 : va_list ap;
1148 : :
1149 [ # # ]: 0 : phydev_info(phydev, ATTACHED_FMT,
1150 : : drv_name, phydev_name(phydev),
1151 : : irq_str);
1152 : :
1153 : 0 : va_start(ap, fmt);
1154 : 0 : vprintk(fmt, ap);
1155 : 0 : va_end(ap);
1156 : : }
1157 : 0 : kfree(irq_str);
1158 : 0 : }
1159 : : EXPORT_SYMBOL(phy_attached_print);
1160 : :
1161 : 0 : static void phy_sysfs_create_links(struct phy_device *phydev)
1162 : : {
1163 : 0 : struct net_device *dev = phydev->attached_dev;
1164 : 0 : int err;
1165 : :
1166 [ # # ]: 0 : if (!dev)
1167 : : return;
1168 : :
1169 : 0 : err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1170 : : "attached_dev");
1171 [ # # ]: 0 : if (err)
1172 : : return;
1173 : :
1174 : 0 : err = sysfs_create_link_nowarn(&dev->dev.kobj,
1175 : : &phydev->mdio.dev.kobj,
1176 : : "phydev");
1177 [ # # ]: 0 : if (err) {
1178 : 0 : dev_err(&dev->dev, "could not add device link to %s err %d\n",
1179 : : kobject_name(&phydev->mdio.dev.kobj),
1180 : : err);
1181 : : /* non-fatal - some net drivers can use one netdevice
1182 : : * with more then one phy
1183 : : */
1184 : : }
1185 : :
1186 : 0 : phydev->sysfs_links = true;
1187 : : }
1188 : :
1189 : : static ssize_t
1190 : 0 : phy_standalone_show(struct device *dev, struct device_attribute *attr,
1191 : : char *buf)
1192 : : {
1193 : 0 : struct phy_device *phydev = to_phy_device(dev);
1194 : :
1195 : 0 : return sprintf(buf, "%d\n", !phydev->attached_dev);
1196 : : }
1197 : : static DEVICE_ATTR_RO(phy_standalone);
1198 : :
1199 : : /**
1200 : : * phy_sfp_attach - attach the SFP bus to the PHY upstream network device
1201 : : * @upstream: pointer to the phy device
1202 : : * @bus: sfp bus representing cage being attached
1203 : : *
1204 : : * This is used to fill in the sfp_upstream_ops .attach member.
1205 : : */
1206 : 0 : void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
1207 : : {
1208 : 0 : struct phy_device *phydev = upstream;
1209 : :
1210 [ # # ]: 0 : if (phydev->attached_dev)
1211 : 0 : phydev->attached_dev->sfp_bus = bus;
1212 : 0 : phydev->sfp_bus_attached = true;
1213 : 0 : }
1214 : : EXPORT_SYMBOL(phy_sfp_attach);
1215 : :
1216 : : /**
1217 : : * phy_sfp_detach - detach the SFP bus from the PHY upstream network device
1218 : : * @upstream: pointer to the phy device
1219 : : * @bus: sfp bus representing cage being attached
1220 : : *
1221 : : * This is used to fill in the sfp_upstream_ops .detach member.
1222 : : */
1223 : 0 : void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
1224 : : {
1225 : 0 : struct phy_device *phydev = upstream;
1226 : :
1227 [ # # ]: 0 : if (phydev->attached_dev)
1228 : 0 : phydev->attached_dev->sfp_bus = NULL;
1229 : 0 : phydev->sfp_bus_attached = false;
1230 : 0 : }
1231 : : EXPORT_SYMBOL(phy_sfp_detach);
1232 : :
1233 : : /**
1234 : : * phy_sfp_probe - probe for a SFP cage attached to this PHY device
1235 : : * @phydev: Pointer to phy_device
1236 : : * @ops: SFP's upstream operations
1237 : : */
1238 : 0 : int phy_sfp_probe(struct phy_device *phydev,
1239 : : const struct sfp_upstream_ops *ops)
1240 : : {
1241 : 0 : struct sfp_bus *bus;
1242 : 0 : int ret;
1243 : :
1244 [ # # ]: 0 : if (phydev->mdio.dev.fwnode) {
1245 : 0 : bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1246 : 0 : if (IS_ERR(bus))
1247 : : return PTR_ERR(bus);
1248 : :
1249 : 0 : phydev->sfp_bus = bus;
1250 : :
1251 : 0 : ret = sfp_bus_add_upstream(bus, phydev, ops);
1252 : 0 : sfp_bus_put(bus);
1253 : : }
1254 : 0 : return 0;
1255 : : }
1256 : : EXPORT_SYMBOL(phy_sfp_probe);
1257 : :
1258 : : /**
1259 : : * phy_attach_direct - attach a network device to a given PHY device pointer
1260 : : * @dev: network device to attach
1261 : : * @phydev: Pointer to phy_device to attach
1262 : : * @flags: PHY device's dev_flags
1263 : : * @interface: PHY device's interface
1264 : : *
1265 : : * Description: Called by drivers to attach to a particular PHY
1266 : : * device. The phy_device is found, and properly hooked up
1267 : : * to the phy_driver. If no driver is attached, then a
1268 : : * generic driver is used. The phy_device is given a ptr to
1269 : : * the attaching device, and given a callback for link status
1270 : : * change. The phy_device is returned to the attaching driver.
1271 : : * This function takes a reference on the phy device.
1272 : : */
1273 : 0 : int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1274 : : u32 flags, phy_interface_t interface)
1275 : : {
1276 : 0 : struct mii_bus *bus = phydev->mdio.bus;
1277 : 0 : struct device *d = &phydev->mdio.dev;
1278 : 0 : struct module *ndev_owner = NULL;
1279 : 0 : bool using_genphy = false;
1280 : 0 : int err;
1281 : :
1282 : : /* For Ethernet device drivers that register their own MDIO bus, we
1283 : : * will have bus->owner match ndev_mod, so we do not want to increment
1284 : : * our own module->refcnt here, otherwise we would not be able to
1285 : : * unload later on.
1286 : : */
1287 [ # # ]: 0 : if (dev)
1288 : 0 : ndev_owner = dev->dev.parent->driver->owner;
1289 [ # # # # ]: 0 : if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1290 : 0 : phydev_err(phydev, "failed to get the bus module\n");
1291 : 0 : return -EIO;
1292 : : }
1293 : :
1294 : 0 : get_device(d);
1295 : :
1296 : : /* Assume that if there is no driver, that it doesn't
1297 : : * exist, and we should use the genphy driver.
1298 : : */
1299 [ # # ]: 0 : if (!d->driver) {
1300 [ # # ]: 0 : if (phydev->is_c45)
1301 : 0 : d->driver = &genphy_c45_driver.mdiodrv.driver;
1302 : : else
1303 : 0 : d->driver = &genphy_driver.mdiodrv.driver;
1304 : :
1305 : : using_genphy = true;
1306 : : }
1307 : :
1308 [ # # ]: 0 : if (!try_module_get(d->driver->owner)) {
1309 : 0 : phydev_err(phydev, "failed to get the device driver module\n");
1310 : 0 : err = -EIO;
1311 : 0 : goto error_put_device;
1312 : : }
1313 : :
1314 [ # # ]: 0 : if (using_genphy) {
1315 : 0 : err = d->driver->probe(d);
1316 [ # # ]: 0 : if (err >= 0)
1317 : 0 : err = device_bind_driver(d);
1318 : :
1319 [ # # ]: 0 : if (err)
1320 : 0 : goto error_module_put;
1321 : : }
1322 : :
1323 [ # # ]: 0 : if (phydev->attached_dev) {
1324 : 0 : dev_err(&dev->dev, "PHY already attached\n");
1325 : 0 : err = -EBUSY;
1326 : 0 : goto error;
1327 : : }
1328 : :
1329 : 0 : phydev->phy_link_change = phy_link_change;
1330 [ # # ]: 0 : if (dev) {
1331 : 0 : phydev->attached_dev = dev;
1332 : 0 : dev->phydev = phydev;
1333 : :
1334 [ # # ]: 0 : if (phydev->sfp_bus_attached)
1335 : 0 : dev->sfp_bus = phydev->sfp_bus;
1336 : : }
1337 : :
1338 : : /* Some Ethernet drivers try to connect to a PHY device before
1339 : : * calling register_netdevice() -> netdev_register_kobject() and
1340 : : * does the dev->dev.kobj initialization. Here we only check for
1341 : : * success which indicates that the network device kobject is
1342 : : * ready. Once we do that we still need to keep track of whether
1343 : : * links were successfully set up or not for phy_detach() to
1344 : : * remove them accordingly.
1345 : : */
1346 : 0 : phydev->sysfs_links = false;
1347 : :
1348 : 0 : phy_sysfs_create_links(phydev);
1349 : :
1350 [ # # ]: 0 : if (!phydev->attached_dev) {
1351 : 0 : err = sysfs_create_file(&phydev->mdio.dev.kobj,
1352 : : &dev_attr_phy_standalone.attr);
1353 [ # # ]: 0 : if (err)
1354 : 0 : phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1355 : : }
1356 : :
1357 : 0 : phydev->dev_flags |= flags;
1358 : :
1359 : 0 : phydev->interface = interface;
1360 : :
1361 : 0 : phydev->state = PHY_READY;
1362 : :
1363 : : /* Initial carrier state is off as the phy is about to be
1364 : : * (re)initialized.
1365 : : */
1366 [ # # ]: 0 : if (dev)
1367 : 0 : netif_carrier_off(phydev->attached_dev);
1368 : :
1369 : : /* Do initial configuration here, now that
1370 : : * we have certain key parameters
1371 : : * (dev_flags and interface)
1372 : : */
1373 : 0 : err = phy_init_hw(phydev);
1374 [ # # ]: 0 : if (err)
1375 : 0 : goto error;
1376 : :
1377 : 0 : phy_resume(phydev);
1378 : 0 : phy_led_triggers_register(phydev);
1379 : :
1380 : 0 : return err;
1381 : :
1382 : 0 : error:
1383 : : /* phy_detach() does all of the cleanup below */
1384 : 0 : phy_detach(phydev);
1385 : 0 : return err;
1386 : :
1387 : : error_module_put:
1388 : 0 : module_put(d->driver->owner);
1389 : 0 : error_put_device:
1390 : 0 : put_device(d);
1391 [ # # ]: 0 : if (ndev_owner != bus->owner)
1392 : 0 : module_put(bus->owner);
1393 : : return err;
1394 : : }
1395 : : EXPORT_SYMBOL(phy_attach_direct);
1396 : :
1397 : : /**
1398 : : * phy_attach - attach a network device to a particular PHY device
1399 : : * @dev: network device to attach
1400 : : * @bus_id: Bus ID of PHY device to attach
1401 : : * @interface: PHY device's interface
1402 : : *
1403 : : * Description: Same as phy_attach_direct() except that a PHY bus_id
1404 : : * string is passed instead of a pointer to a struct phy_device.
1405 : : */
1406 : 0 : struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1407 : : phy_interface_t interface)
1408 : : {
1409 : 0 : struct bus_type *bus = &mdio_bus_type;
1410 : 0 : struct phy_device *phydev;
1411 : 0 : struct device *d;
1412 : 0 : int rc;
1413 : :
1414 [ # # ]: 0 : if (!dev)
1415 : : return ERR_PTR(-EINVAL);
1416 : :
1417 : : /* Search the list of PHY devices on the mdio bus for the
1418 : : * PHY with the requested name
1419 : : */
1420 : 0 : d = bus_find_device_by_name(bus, NULL, bus_id);
1421 [ # # ]: 0 : if (!d) {
1422 : 0 : pr_err("PHY %s not found\n", bus_id);
1423 : 0 : return ERR_PTR(-ENODEV);
1424 : : }
1425 : 0 : phydev = to_phy_device(d);
1426 : :
1427 : 0 : rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1428 : 0 : put_device(d);
1429 [ # # ]: 0 : if (rc)
1430 : 0 : return ERR_PTR(rc);
1431 : :
1432 : : return phydev;
1433 : : }
1434 : : EXPORT_SYMBOL(phy_attach);
1435 : :
1436 : 0 : static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1437 : : struct device_driver *driver)
1438 : : {
1439 : 0 : struct device *d = &phydev->mdio.dev;
1440 : 0 : bool ret = false;
1441 : :
1442 : 0 : if (!phydev->drv)
1443 : : return ret;
1444 : :
1445 : 0 : get_device(d);
1446 : 0 : ret = d->driver == driver;
1447 : 0 : put_device(d);
1448 : :
1449 : 0 : return ret;
1450 : : }
1451 : :
1452 : 0 : bool phy_driver_is_genphy(struct phy_device *phydev)
1453 : : {
1454 [ # # ]: 0 : return phy_driver_is_genphy_kind(phydev,
1455 : : &genphy_driver.mdiodrv.driver);
1456 : : }
1457 : : EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
1458 : :
1459 : 0 : bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1460 : : {
1461 [ # # ]: 0 : return phy_driver_is_genphy_kind(phydev,
1462 : : &genphy_c45_driver.mdiodrv.driver);
1463 : : }
1464 : : EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
1465 : :
1466 : : /**
1467 : : * phy_detach - detach a PHY device from its network device
1468 : : * @phydev: target phy_device struct
1469 : : *
1470 : : * This detaches the phy device from its network device and the phy
1471 : : * driver, and drops the reference count taken in phy_attach_direct().
1472 : : */
1473 : 0 : void phy_detach(struct phy_device *phydev)
1474 : : {
1475 : 0 : struct net_device *dev = phydev->attached_dev;
1476 : 0 : struct module *ndev_owner = NULL;
1477 : 0 : struct mii_bus *bus;
1478 : :
1479 [ # # ]: 0 : if (phydev->sysfs_links) {
1480 [ # # ]: 0 : if (dev)
1481 : 0 : sysfs_remove_link(&dev->dev.kobj, "phydev");
1482 : 0 : sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1483 : : }
1484 : :
1485 [ # # ]: 0 : if (!phydev->attached_dev)
1486 : 0 : sysfs_remove_file(&phydev->mdio.dev.kobj,
1487 : : &dev_attr_phy_standalone.attr);
1488 : :
1489 : 0 : phy_suspend(phydev);
1490 [ # # ]: 0 : if (dev) {
1491 : 0 : phydev->attached_dev->phydev = NULL;
1492 : 0 : phydev->attached_dev = NULL;
1493 : : }
1494 : 0 : phydev->phylink = NULL;
1495 : :
1496 : 0 : phy_led_triggers_unregister(phydev);
1497 : :
1498 : 0 : module_put(phydev->mdio.dev.driver->owner);
1499 : :
1500 : : /* If the device had no specific driver before (i.e. - it
1501 : : * was using the generic driver), we unbind the device
1502 : : * from the generic driver so that there's a chance a
1503 : : * real driver could be loaded
1504 : : */
1505 [ # # # # ]: 0 : if (phy_driver_is_genphy(phydev) ||
1506 : 0 : phy_driver_is_genphy_10g(phydev))
1507 : 0 : device_release_driver(&phydev->mdio.dev);
1508 : :
1509 : : /*
1510 : : * The phydev might go away on the put_device() below, so avoid
1511 : : * a use-after-free bug by reading the underlying bus first.
1512 : : */
1513 : 0 : bus = phydev->mdio.bus;
1514 : :
1515 : 0 : put_device(&phydev->mdio.dev);
1516 [ # # ]: 0 : if (dev)
1517 : 0 : ndev_owner = dev->dev.parent->driver->owner;
1518 [ # # ]: 0 : if (ndev_owner != bus->owner)
1519 : 0 : module_put(bus->owner);
1520 : :
1521 : : /* Assert the reset signal */
1522 : 0 : phy_device_reset(phydev, 1);
1523 : 0 : }
1524 : : EXPORT_SYMBOL(phy_detach);
1525 : :
1526 : 0 : int phy_suspend(struct phy_device *phydev)
1527 : : {
1528 : 0 : struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1529 : 0 : struct net_device *netdev = phydev->attached_dev;
1530 : 0 : struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1531 : 0 : int ret = 0;
1532 : :
1533 : : /* If the device has WOL enabled, we cannot suspend the PHY */
1534 : 0 : phy_ethtool_get_wol(phydev, &wol);
1535 [ # # # # : 0 : if (wol.wolopts || (netdev && netdev->wol_enabled))
# # ]
1536 : : return -EBUSY;
1537 : :
1538 [ # # # # ]: 0 : if (phydev->drv && phydrv->suspend)
1539 : 0 : ret = phydrv->suspend(phydev);
1540 : :
1541 [ # # ]: 0 : if (ret)
1542 : : return ret;
1543 : :
1544 : 0 : phydev->suspended = true;
1545 : :
1546 : 0 : return ret;
1547 : : }
1548 : : EXPORT_SYMBOL(phy_suspend);
1549 : :
1550 : 0 : int __phy_resume(struct phy_device *phydev)
1551 : : {
1552 : 0 : struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1553 : 0 : int ret = 0;
1554 : :
1555 [ # # ]: 0 : WARN_ON(!mutex_is_locked(&phydev->lock));
1556 : :
1557 [ # # # # ]: 0 : if (phydev->drv && phydrv->resume)
1558 : 0 : ret = phydrv->resume(phydev);
1559 : :
1560 [ # # ]: 0 : if (ret)
1561 : : return ret;
1562 : :
1563 : 0 : phydev->suspended = false;
1564 : :
1565 : 0 : return ret;
1566 : : }
1567 : : EXPORT_SYMBOL(__phy_resume);
1568 : :
1569 : 0 : int phy_resume(struct phy_device *phydev)
1570 : : {
1571 : 0 : int ret;
1572 : :
1573 : 0 : mutex_lock(&phydev->lock);
1574 : 0 : ret = __phy_resume(phydev);
1575 : 0 : mutex_unlock(&phydev->lock);
1576 : :
1577 : 0 : return ret;
1578 : : }
1579 : : EXPORT_SYMBOL(phy_resume);
1580 : :
1581 : 0 : int phy_loopback(struct phy_device *phydev, bool enable)
1582 : : {
1583 : 0 : struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1584 : 0 : int ret = 0;
1585 : :
1586 : 0 : mutex_lock(&phydev->lock);
1587 : :
1588 [ # # # # ]: 0 : if (enable && phydev->loopback_enabled) {
1589 : 0 : ret = -EBUSY;
1590 : 0 : goto out;
1591 : : }
1592 : :
1593 [ # # # # ]: 0 : if (!enable && !phydev->loopback_enabled) {
1594 : 0 : ret = -EINVAL;
1595 : 0 : goto out;
1596 : : }
1597 : :
1598 [ # # # # ]: 0 : if (phydev->drv && phydrv->set_loopback)
1599 : 0 : ret = phydrv->set_loopback(phydev, enable);
1600 : : else
1601 : : ret = -EOPNOTSUPP;
1602 : :
1603 [ # # ]: 0 : if (ret)
1604 : 0 : goto out;
1605 : :
1606 : 0 : phydev->loopback_enabled = enable;
1607 : :
1608 : 0 : out:
1609 : 0 : mutex_unlock(&phydev->lock);
1610 : 0 : return ret;
1611 : : }
1612 : : EXPORT_SYMBOL(phy_loopback);
1613 : :
1614 : : /**
1615 : : * phy_reset_after_clk_enable - perform a PHY reset if needed
1616 : : * @phydev: target phy_device struct
1617 : : *
1618 : : * Description: Some PHYs are known to need a reset after their refclk was
1619 : : * enabled. This function evaluates the flags and perform the reset if it's
1620 : : * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
1621 : : * was reset.
1622 : : */
1623 : 0 : int phy_reset_after_clk_enable(struct phy_device *phydev)
1624 : : {
1625 [ # # # # ]: 0 : if (!phydev || !phydev->drv)
1626 : : return -ENODEV;
1627 : :
1628 [ # # ]: 0 : if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1629 : 0 : phy_device_reset(phydev, 1);
1630 : 0 : phy_device_reset(phydev, 0);
1631 : 0 : return 1;
1632 : : }
1633 : :
1634 : : return 0;
1635 : : }
1636 : : EXPORT_SYMBOL(phy_reset_after_clk_enable);
1637 : :
1638 : : /* Generic PHY support and helper functions */
1639 : :
1640 : : /**
1641 : : * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1642 : : * @phydev: target phy_device struct
1643 : : *
1644 : : * Description: Writes MII_ADVERTISE with the appropriate values,
1645 : : * after sanitizing the values to make sure we only advertise
1646 : : * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1647 : : * hasn't changed, and > 0 if it has changed.
1648 : : */
1649 : 0 : static int genphy_config_advert(struct phy_device *phydev)
1650 : : {
1651 : 0 : int err, bmsr, changed = 0;
1652 : 0 : u32 adv;
1653 : :
1654 : : /* Only allow advertising what this PHY supports */
1655 : 0 : linkmode_and(phydev->advertising, phydev->advertising,
1656 : 0 : phydev->supported);
1657 : :
1658 : 0 : adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1659 : :
1660 : : /* Setup standard advertisement */
1661 : 0 : err = phy_modify_changed(phydev, MII_ADVERTISE,
1662 : : ADVERTISE_ALL | ADVERTISE_100BASE4 |
1663 : : ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
1664 : : adv);
1665 [ # # ]: 0 : if (err < 0)
1666 : : return err;
1667 [ # # ]: 0 : if (err > 0)
1668 : 0 : changed = 1;
1669 : :
1670 : 0 : bmsr = phy_read(phydev, MII_BMSR);
1671 [ # # ]: 0 : if (bmsr < 0)
1672 : : return bmsr;
1673 : :
1674 : : /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1675 : : * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1676 : : * logical 1.
1677 : : */
1678 [ # # ]: 0 : if (!(bmsr & BMSR_ESTATEN))
1679 : : return changed;
1680 : :
1681 : 0 : adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
1682 : :
1683 : 0 : err = phy_modify_changed(phydev, MII_CTRL1000,
1684 : : ADVERTISE_1000FULL | ADVERTISE_1000HALF,
1685 : : adv);
1686 [ # # ]: 0 : if (err < 0)
1687 : : return err;
1688 [ # # ]: 0 : if (err > 0)
1689 : 0 : changed = 1;
1690 : :
1691 : : return changed;
1692 : : }
1693 : :
1694 : : /**
1695 : : * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
1696 : : * @phydev: target phy_device struct
1697 : : *
1698 : : * Description: Writes MII_ADVERTISE with the appropriate values,
1699 : : * after sanitizing the values to make sure we only advertise
1700 : : * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1701 : : * hasn't changed, and > 0 if it has changed. This function is intended
1702 : : * for Clause 37 1000Base-X mode.
1703 : : */
1704 : 0 : static int genphy_c37_config_advert(struct phy_device *phydev)
1705 : : {
1706 : 0 : u16 adv = 0;
1707 : :
1708 : : /* Only allow advertising what this PHY supports */
1709 : 0 : linkmode_and(phydev->advertising, phydev->advertising,
1710 : 0 : phydev->supported);
1711 : :
1712 [ # # ]: 0 : if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
1713 : : phydev->advertising))
1714 : 0 : adv |= ADVERTISE_1000XFULL;
1715 [ # # ]: 0 : if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1716 : : phydev->advertising))
1717 : 0 : adv |= ADVERTISE_1000XPAUSE;
1718 [ # # ]: 0 : if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1719 : : phydev->advertising))
1720 : 0 : adv |= ADVERTISE_1000XPSE_ASYM;
1721 : :
1722 : 0 : return phy_modify_changed(phydev, MII_ADVERTISE,
1723 : : ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
1724 : : ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
1725 : : adv);
1726 : : }
1727 : :
1728 : : /**
1729 : : * genphy_config_eee_advert - disable unwanted eee mode advertisement
1730 : : * @phydev: target phy_device struct
1731 : : *
1732 : : * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1733 : : * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1734 : : * changed, and 1 if it has changed.
1735 : : */
1736 : 0 : int genphy_config_eee_advert(struct phy_device *phydev)
1737 : : {
1738 : 0 : int err;
1739 : :
1740 : : /* Nothing to disable */
1741 [ # # ]: 0 : if (!phydev->eee_broken_modes)
1742 : : return 0;
1743 : :
1744 : 0 : err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
1745 : : phydev->eee_broken_modes, 0);
1746 : : /* If the call failed, we assume that EEE is not supported */
1747 : 0 : return err < 0 ? 0 : err;
1748 : : }
1749 : : EXPORT_SYMBOL(genphy_config_eee_advert);
1750 : :
1751 : : /**
1752 : : * genphy_setup_forced - configures/forces speed/duplex from @phydev
1753 : : * @phydev: target phy_device struct
1754 : : *
1755 : : * Description: Configures MII_BMCR to force speed/duplex
1756 : : * to the values in phydev. Assumes that the values are valid.
1757 : : * Please see phy_sanitize_settings().
1758 : : */
1759 : 0 : int genphy_setup_forced(struct phy_device *phydev)
1760 : : {
1761 : 0 : u16 ctl = 0;
1762 : :
1763 : 0 : phydev->pause = 0;
1764 : 0 : phydev->asym_pause = 0;
1765 : :
1766 [ # # ]: 0 : if (SPEED_1000 == phydev->speed)
1767 : : ctl |= BMCR_SPEED1000;
1768 [ # # ]: 0 : else if (SPEED_100 == phydev->speed)
1769 : 0 : ctl |= BMCR_SPEED100;
1770 : :
1771 [ # # ]: 0 : if (DUPLEX_FULL == phydev->duplex)
1772 : 0 : ctl |= BMCR_FULLDPLX;
1773 : :
1774 : 0 : return phy_modify(phydev, MII_BMCR,
1775 : : ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
1776 : : }
1777 : : EXPORT_SYMBOL(genphy_setup_forced);
1778 : :
1779 : : /**
1780 : : * genphy_restart_aneg - Enable and Restart Autonegotiation
1781 : : * @phydev: target phy_device struct
1782 : : */
1783 : 0 : int genphy_restart_aneg(struct phy_device *phydev)
1784 : : {
1785 : : /* Don't isolate the PHY if we're negotiating */
1786 : 0 : return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
1787 : : BMCR_ANENABLE | BMCR_ANRESTART);
1788 : : }
1789 : : EXPORT_SYMBOL(genphy_restart_aneg);
1790 : :
1791 : : /**
1792 : : * genphy_check_and_restart_aneg - Enable and restart auto-negotiation
1793 : : * @phydev: target phy_device struct
1794 : : * @restart: whether aneg restart is requested
1795 : : *
1796 : : * Check, and restart auto-negotiation if needed.
1797 : : */
1798 : 0 : int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
1799 : : {
1800 : 0 : int ret;
1801 : :
1802 [ # # ]: 0 : if (!restart) {
1803 : : /* Advertisement hasn't changed, but maybe aneg was never on to
1804 : : * begin with? Or maybe phy was isolated?
1805 : : */
1806 : 0 : ret = phy_read(phydev, MII_BMCR);
1807 [ # # ]: 0 : if (ret < 0)
1808 : : return ret;
1809 : :
1810 [ # # ]: 0 : if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
1811 : : restart = true;
1812 : : }
1813 : :
1814 [ # # ]: 0 : if (restart)
1815 : 0 : return genphy_restart_aneg(phydev);
1816 : :
1817 : : return 0;
1818 : : }
1819 : : EXPORT_SYMBOL(genphy_check_and_restart_aneg);
1820 : :
1821 : : /**
1822 : : * __genphy_config_aneg - restart auto-negotiation or write BMCR
1823 : : * @phydev: target phy_device struct
1824 : : * @changed: whether autoneg is requested
1825 : : *
1826 : : * Description: If auto-negotiation is enabled, we configure the
1827 : : * advertising, and then restart auto-negotiation. If it is not
1828 : : * enabled, then we write the BMCR.
1829 : : */
1830 : 0 : int __genphy_config_aneg(struct phy_device *phydev, bool changed)
1831 : : {
1832 : 0 : int err;
1833 : :
1834 [ # # ]: 0 : if (genphy_config_eee_advert(phydev))
1835 : 0 : changed = true;
1836 : :
1837 [ # # ]: 0 : if (AUTONEG_ENABLE != phydev->autoneg)
1838 : 0 : return genphy_setup_forced(phydev);
1839 : :
1840 : 0 : err = genphy_config_advert(phydev);
1841 [ # # ]: 0 : if (err < 0) /* error */
1842 : : return err;
1843 [ # # ]: 0 : else if (err)
1844 : 0 : changed = true;
1845 : :
1846 : 0 : return genphy_check_and_restart_aneg(phydev, changed);
1847 : : }
1848 : : EXPORT_SYMBOL(__genphy_config_aneg);
1849 : :
1850 : : /**
1851 : : * genphy_c37_config_aneg - restart auto-negotiation or write BMCR
1852 : : * @phydev: target phy_device struct
1853 : : *
1854 : : * Description: If auto-negotiation is enabled, we configure the
1855 : : * advertising, and then restart auto-negotiation. If it is not
1856 : : * enabled, then we write the BMCR. This function is intended
1857 : : * for use with Clause 37 1000Base-X mode.
1858 : : */
1859 : 0 : int genphy_c37_config_aneg(struct phy_device *phydev)
1860 : : {
1861 : 0 : int err, changed;
1862 : :
1863 [ # # ]: 0 : if (phydev->autoneg != AUTONEG_ENABLE)
1864 : 0 : return genphy_setup_forced(phydev);
1865 : :
1866 : 0 : err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
1867 : : BMCR_SPEED1000);
1868 [ # # ]: 0 : if (err)
1869 : : return err;
1870 : :
1871 : 0 : changed = genphy_c37_config_advert(phydev);
1872 [ # # ]: 0 : if (changed < 0) /* error */
1873 : : return changed;
1874 : :
1875 [ # # ]: 0 : if (!changed) {
1876 : : /* Advertisement hasn't changed, but maybe aneg was never on to
1877 : : * begin with? Or maybe phy was isolated?
1878 : : */
1879 : 0 : int ctl = phy_read(phydev, MII_BMCR);
1880 : :
1881 [ # # ]: 0 : if (ctl < 0)
1882 : : return ctl;
1883 : :
1884 [ # # ]: 0 : if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
1885 : : changed = 1; /* do restart aneg */
1886 : : }
1887 : :
1888 : : /* Only restart aneg if we are advertising something different
1889 : : * than we were before.
1890 : : */
1891 [ # # ]: 0 : if (changed > 0)
1892 : 0 : return genphy_restart_aneg(phydev);
1893 : :
1894 : : return 0;
1895 : : }
1896 : : EXPORT_SYMBOL(genphy_c37_config_aneg);
1897 : :
1898 : : /**
1899 : : * genphy_aneg_done - return auto-negotiation status
1900 : : * @phydev: target phy_device struct
1901 : : *
1902 : : * Description: Reads the status register and returns 0 either if
1903 : : * auto-negotiation is incomplete, or if there was an error.
1904 : : * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
1905 : : */
1906 : 0 : int genphy_aneg_done(struct phy_device *phydev)
1907 : : {
1908 : 0 : int retval = phy_read(phydev, MII_BMSR);
1909 : :
1910 [ # # ]: 0 : return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
1911 : : }
1912 : : EXPORT_SYMBOL(genphy_aneg_done);
1913 : :
1914 : : /**
1915 : : * genphy_update_link - update link status in @phydev
1916 : : * @phydev: target phy_device struct
1917 : : *
1918 : : * Description: Update the value in phydev->link to reflect the
1919 : : * current link value. In order to do this, we need to read
1920 : : * the status register twice, keeping the second value.
1921 : : */
1922 : 0 : int genphy_update_link(struct phy_device *phydev)
1923 : : {
1924 : 0 : int status = 0, bmcr;
1925 : :
1926 : 0 : bmcr = phy_read(phydev, MII_BMCR);
1927 [ # # ]: 0 : if (bmcr < 0)
1928 : : return bmcr;
1929 : :
1930 : : /* Autoneg is being started, therefore disregard BMSR value and
1931 : : * report link as down.
1932 : : */
1933 [ # # ]: 0 : if (bmcr & BMCR_ANRESTART)
1934 : 0 : goto done;
1935 : :
1936 : : /* The link state is latched low so that momentary link
1937 : : * drops can be detected. Do not double-read the status
1938 : : * in polling mode to detect such short link drops.
1939 : : */
1940 [ # # ]: 0 : if (!phy_polling_mode(phydev)) {
1941 : 0 : status = phy_read(phydev, MII_BMSR);
1942 [ # # ]: 0 : if (status < 0)
1943 : : return status;
1944 [ # # ]: 0 : else if (status & BMSR_LSTATUS)
1945 : 0 : goto done;
1946 : : }
1947 : :
1948 : : /* Read link and autonegotiation status */
1949 : 0 : status = phy_read(phydev, MII_BMSR);
1950 [ # # ]: 0 : if (status < 0)
1951 : : return status;
1952 : 0 : done:
1953 : 0 : phydev->link = status & BMSR_LSTATUS ? 1 : 0;
1954 : 0 : phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
1955 : :
1956 : : /* Consider the case that autoneg was started and "aneg complete"
1957 : : * bit has been reset, but "link up" bit not yet.
1958 : : */
1959 [ # # ]: 0 : if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
1960 : 0 : phydev->link = 0;
1961 : :
1962 : : return 0;
1963 : : }
1964 : : EXPORT_SYMBOL(genphy_update_link);
1965 : :
1966 : 0 : int genphy_read_lpa(struct phy_device *phydev)
1967 : : {
1968 : 0 : int lpa, lpagb;
1969 : :
1970 [ # # ]: 0 : if (phydev->autoneg == AUTONEG_ENABLE) {
1971 [ # # ]: 0 : if (!phydev->autoneg_complete) {
1972 : 0 : mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
1973 : : 0);
1974 : 0 : mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
1975 : 0 : return 0;
1976 : : }
1977 : :
1978 [ # # ]: 0 : if (phydev->is_gigabit_capable) {
1979 : 0 : lpagb = phy_read(phydev, MII_STAT1000);
1980 [ # # ]: 0 : if (lpagb < 0)
1981 : : return lpagb;
1982 : :
1983 [ # # ]: 0 : if (lpagb & LPA_1000MSFAIL) {
1984 : 0 : int adv = phy_read(phydev, MII_CTRL1000);
1985 : :
1986 [ # # ]: 0 : if (adv < 0)
1987 : : return adv;
1988 : :
1989 [ # # ]: 0 : if (adv & CTL1000_ENABLE_MASTER)
1990 : 0 : phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
1991 : : else
1992 : 0 : phydev_err(phydev, "Master/Slave resolution failed\n");
1993 : 0 : return -ENOLINK;
1994 : : }
1995 : :
1996 : 0 : mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
1997 : : lpagb);
1998 : : }
1999 : :
2000 : 0 : lpa = phy_read(phydev, MII_LPA);
2001 [ # # ]: 0 : if (lpa < 0)
2002 : : return lpa;
2003 : :
2004 : 0 : mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2005 : : } else {
2006 : 0 : linkmode_zero(phydev->lp_advertising);
2007 : : }
2008 : :
2009 : : return 0;
2010 : : }
2011 : : EXPORT_SYMBOL(genphy_read_lpa);
2012 : :
2013 : : /**
2014 : : * genphy_read_status_fixed - read the link parameters for !aneg mode
2015 : : * @phydev: target phy_device struct
2016 : : *
2017 : : * Read the current duplex and speed state for a PHY operating with
2018 : : * autonegotiation disabled.
2019 : : */
2020 : 0 : int genphy_read_status_fixed(struct phy_device *phydev)
2021 : : {
2022 : 0 : int bmcr = phy_read(phydev, MII_BMCR);
2023 : :
2024 [ # # ]: 0 : if (bmcr < 0)
2025 : : return bmcr;
2026 : :
2027 [ # # ]: 0 : if (bmcr & BMCR_FULLDPLX)
2028 : 0 : phydev->duplex = DUPLEX_FULL;
2029 : : else
2030 : 0 : phydev->duplex = DUPLEX_HALF;
2031 : :
2032 [ # # ]: 0 : if (bmcr & BMCR_SPEED1000)
2033 : 0 : phydev->speed = SPEED_1000;
2034 [ # # ]: 0 : else if (bmcr & BMCR_SPEED100)
2035 : 0 : phydev->speed = SPEED_100;
2036 : : else
2037 : 0 : phydev->speed = SPEED_10;
2038 : :
2039 : : return 0;
2040 : : }
2041 : : EXPORT_SYMBOL(genphy_read_status_fixed);
2042 : :
2043 : : /**
2044 : : * genphy_read_status - check the link status and update current link state
2045 : : * @phydev: target phy_device struct
2046 : : *
2047 : : * Description: Check the link, then figure out the current state
2048 : : * by comparing what we advertise with what the link partner
2049 : : * advertises. Start by checking the gigabit possibilities,
2050 : : * then move on to 10/100.
2051 : : */
2052 : 0 : int genphy_read_status(struct phy_device *phydev)
2053 : : {
2054 : 0 : int err, old_link = phydev->link;
2055 : :
2056 : : /* Update the link, but return if there was an error */
2057 : 0 : err = genphy_update_link(phydev);
2058 [ # # ]: 0 : if (err)
2059 : : return err;
2060 : :
2061 : : /* why bother the PHY if nothing can have changed */
2062 [ # # # # : 0 : if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
# # ]
2063 : : return 0;
2064 : :
2065 : 0 : phydev->speed = SPEED_UNKNOWN;
2066 : 0 : phydev->duplex = DUPLEX_UNKNOWN;
2067 : 0 : phydev->pause = 0;
2068 : 0 : phydev->asym_pause = 0;
2069 : :
2070 : 0 : err = genphy_read_lpa(phydev);
2071 [ # # ]: 0 : if (err < 0)
2072 : : return err;
2073 : :
2074 [ # # ]: 0 : if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2075 : 0 : phy_resolve_aneg_linkmode(phydev);
2076 [ # # ]: 0 : } else if (phydev->autoneg == AUTONEG_DISABLE) {
2077 : 0 : err = genphy_read_status_fixed(phydev);
2078 : 0 : if (err < 0)
2079 : : return err;
2080 : : }
2081 : :
2082 : : return 0;
2083 : : }
2084 : : EXPORT_SYMBOL(genphy_read_status);
2085 : :
2086 : : /**
2087 : : * genphy_c37_read_status - check the link status and update current link state
2088 : : * @phydev: target phy_device struct
2089 : : *
2090 : : * Description: Check the link, then figure out the current state
2091 : : * by comparing what we advertise with what the link partner
2092 : : * advertises. This function is for Clause 37 1000Base-X mode.
2093 : : */
2094 : 0 : int genphy_c37_read_status(struct phy_device *phydev)
2095 : : {
2096 : 0 : int lpa, err, old_link = phydev->link;
2097 : :
2098 : : /* Update the link, but return if there was an error */
2099 : 0 : err = genphy_update_link(phydev);
2100 [ # # ]: 0 : if (err)
2101 : : return err;
2102 : :
2103 : : /* why bother the PHY if nothing can have changed */
2104 [ # # # # : 0 : if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
# # ]
2105 : : return 0;
2106 : :
2107 : 0 : phydev->duplex = DUPLEX_UNKNOWN;
2108 : 0 : phydev->pause = 0;
2109 : 0 : phydev->asym_pause = 0;
2110 : :
2111 [ # # ]: 0 : if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2112 : 0 : lpa = phy_read(phydev, MII_LPA);
2113 [ # # ]: 0 : if (lpa < 0)
2114 : : return lpa;
2115 : :
2116 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2117 : 0 : phydev->lp_advertising, lpa & LPA_LPACK);
2118 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2119 : : phydev->lp_advertising, lpa & LPA_1000XFULL);
2120 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2121 : : phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2122 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2123 : : phydev->lp_advertising,
2124 : : lpa & LPA_1000XPAUSE_ASYM);
2125 : :
2126 : 0 : phy_resolve_aneg_linkmode(phydev);
2127 [ # # ]: 0 : } else if (phydev->autoneg == AUTONEG_DISABLE) {
2128 : 0 : int bmcr = phy_read(phydev, MII_BMCR);
2129 : :
2130 [ # # ]: 0 : if (bmcr < 0)
2131 : : return bmcr;
2132 : :
2133 [ # # ]: 0 : if (bmcr & BMCR_FULLDPLX)
2134 : 0 : phydev->duplex = DUPLEX_FULL;
2135 : : else
2136 : 0 : phydev->duplex = DUPLEX_HALF;
2137 : : }
2138 : :
2139 : : return 0;
2140 : : }
2141 : : EXPORT_SYMBOL(genphy_c37_read_status);
2142 : :
2143 : : /**
2144 : : * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
2145 : : * @phydev: target phy_device struct
2146 : : *
2147 : : * Description: Perform a software PHY reset using the standard
2148 : : * BMCR_RESET bit and poll for the reset bit to be cleared.
2149 : : *
2150 : : * Returns: 0 on success, < 0 on failure
2151 : : */
2152 : 0 : int genphy_soft_reset(struct phy_device *phydev)
2153 : : {
2154 : 0 : u16 res = BMCR_RESET;
2155 : 0 : int ret;
2156 : :
2157 [ # # ]: 0 : if (phydev->autoneg == AUTONEG_ENABLE)
2158 : 0 : res |= BMCR_ANRESTART;
2159 : :
2160 : 0 : ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2161 [ # # ]: 0 : if (ret < 0)
2162 : : return ret;
2163 : :
2164 : 0 : ret = phy_poll_reset(phydev);
2165 [ # # ]: 0 : if (ret)
2166 : : return ret;
2167 : :
2168 : : /* BMCR may be reset to defaults */
2169 [ # # ]: 0 : if (phydev->autoneg == AUTONEG_DISABLE)
2170 : 0 : ret = genphy_setup_forced(phydev);
2171 : :
2172 : : return ret;
2173 : : }
2174 : : EXPORT_SYMBOL(genphy_soft_reset);
2175 : :
2176 : : /**
2177 : : * genphy_read_abilities - read PHY abilities from Clause 22 registers
2178 : : * @phydev: target phy_device struct
2179 : : *
2180 : : * Description: Reads the PHY's abilities and populates
2181 : : * phydev->supported accordingly.
2182 : : *
2183 : : * Returns: 0 on success, < 0 on failure
2184 : : */
2185 : 0 : int genphy_read_abilities(struct phy_device *phydev)
2186 : : {
2187 : 0 : int val;
2188 : :
2189 : 0 : linkmode_set_bit_array(phy_basic_ports_array,
2190 : : ARRAY_SIZE(phy_basic_ports_array),
2191 : 0 : phydev->supported);
2192 : :
2193 : 0 : val = phy_read(phydev, MII_BMSR);
2194 [ # # ]: 0 : if (val < 0)
2195 : : return val;
2196 : :
2197 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2198 : : val & BMSR_ANEGCAPABLE);
2199 : :
2200 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2201 : : val & BMSR_100FULL);
2202 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2203 : : val & BMSR_100HALF);
2204 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2205 : : val & BMSR_10FULL);
2206 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2207 : : val & BMSR_10HALF);
2208 : :
2209 [ # # ]: 0 : if (val & BMSR_ESTATEN) {
2210 : 0 : val = phy_read(phydev, MII_ESTATUS);
2211 [ # # ]: 0 : if (val < 0)
2212 : : return val;
2213 : :
2214 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2215 : : phydev->supported, val & ESTATUS_1000_TFULL);
2216 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2217 : : phydev->supported, val & ESTATUS_1000_THALF);
2218 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2219 : : phydev->supported, val & ESTATUS_1000_XFULL);
2220 : : }
2221 : :
2222 : : return 0;
2223 : : }
2224 : : EXPORT_SYMBOL(genphy_read_abilities);
2225 : :
2226 : : /* This is used for the phy device which doesn't support the MMD extended
2227 : : * register access, but it does have side effect when we are trying to access
2228 : : * the MMD register via indirect method.
2229 : : */
2230 : 0 : int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
2231 : : {
2232 : 0 : return -EOPNOTSUPP;
2233 : : }
2234 : : EXPORT_SYMBOL(genphy_read_mmd_unsupported);
2235 : :
2236 : 0 : int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
2237 : : u16 regnum, u16 val)
2238 : : {
2239 : 0 : return -EOPNOTSUPP;
2240 : : }
2241 : : EXPORT_SYMBOL(genphy_write_mmd_unsupported);
2242 : :
2243 : 0 : int genphy_suspend(struct phy_device *phydev)
2244 : : {
2245 : 0 : return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2246 : : }
2247 : : EXPORT_SYMBOL(genphy_suspend);
2248 : :
2249 : 0 : int genphy_resume(struct phy_device *phydev)
2250 : : {
2251 : 0 : return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2252 : : }
2253 : : EXPORT_SYMBOL(genphy_resume);
2254 : :
2255 : 0 : int genphy_loopback(struct phy_device *phydev, bool enable)
2256 : : {
2257 [ # # ]: 0 : return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
2258 : : enable ? BMCR_LOOPBACK : 0);
2259 : : }
2260 : : EXPORT_SYMBOL(genphy_loopback);
2261 : :
2262 : : /**
2263 : : * phy_remove_link_mode - Remove a supported link mode
2264 : : * @phydev: phy_device structure to remove link mode from
2265 : : * @link_mode: Link mode to be removed
2266 : : *
2267 : : * Description: Some MACs don't support all link modes which the PHY
2268 : : * does. e.g. a 1G MAC often does not support 1000Half. Add a helper
2269 : : * to remove a link mode.
2270 : : */
2271 : 0 : void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2272 : : {
2273 : 0 : linkmode_clear_bit(link_mode, phydev->supported);
2274 : 0 : phy_advertise_supported(phydev);
2275 : 0 : }
2276 : : EXPORT_SYMBOL(phy_remove_link_mode);
2277 : :
2278 : 0 : static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2279 : : {
2280 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2281 : : linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2282 : 0 : linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2283 : : linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2284 : 0 : }
2285 : :
2286 : : /**
2287 : : * phy_advertise_supported - Advertise all supported modes
2288 : : * @phydev: target phy_device struct
2289 : : *
2290 : : * Description: Called to advertise all supported modes, doesn't touch
2291 : : * pause mode advertising.
2292 : : */
2293 : 0 : void phy_advertise_supported(struct phy_device *phydev)
2294 : : {
2295 : 0 : __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2296 : :
2297 : 0 : linkmode_copy(new, phydev->supported);
2298 : 0 : phy_copy_pause_bits(new, phydev->advertising);
2299 : 0 : linkmode_copy(phydev->advertising, new);
2300 : 0 : }
2301 : : EXPORT_SYMBOL(phy_advertise_supported);
2302 : :
2303 : : /**
2304 : : * phy_support_sym_pause - Enable support of symmetrical pause
2305 : : * @phydev: target phy_device struct
2306 : : *
2307 : : * Description: Called by the MAC to indicate is supports symmetrical
2308 : : * Pause, but not asym pause.
2309 : : */
2310 : 0 : void phy_support_sym_pause(struct phy_device *phydev)
2311 : : {
2312 : 0 : linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2313 : 0 : phy_copy_pause_bits(phydev->advertising, phydev->supported);
2314 : 0 : }
2315 : : EXPORT_SYMBOL(phy_support_sym_pause);
2316 : :
2317 : : /**
2318 : : * phy_support_asym_pause - Enable support of asym pause
2319 : : * @phydev: target phy_device struct
2320 : : *
2321 : : * Description: Called by the MAC to indicate is supports Asym Pause.
2322 : : */
2323 : 0 : void phy_support_asym_pause(struct phy_device *phydev)
2324 : : {
2325 : 0 : phy_copy_pause_bits(phydev->advertising, phydev->supported);
2326 : 0 : }
2327 : : EXPORT_SYMBOL(phy_support_asym_pause);
2328 : :
2329 : : /**
2330 : : * phy_set_sym_pause - Configure symmetric Pause
2331 : : * @phydev: target phy_device struct
2332 : : * @rx: Receiver Pause is supported
2333 : : * @tx: Transmit Pause is supported
2334 : : * @autoneg: Auto neg should be used
2335 : : *
2336 : : * Description: Configure advertised Pause support depending on if
2337 : : * receiver pause and pause auto neg is supported. Generally called
2338 : : * from the set_pauseparam .ndo.
2339 : : */
2340 : 0 : void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2341 : : bool autoneg)
2342 : : {
2343 : 0 : linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2344 : :
2345 [ # # # # ]: 0 : if (rx && tx && autoneg)
2346 : 0 : linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2347 : : phydev->supported);
2348 : :
2349 : 0 : linkmode_copy(phydev->advertising, phydev->supported);
2350 : 0 : }
2351 : : EXPORT_SYMBOL(phy_set_sym_pause);
2352 : :
2353 : : /**
2354 : : * phy_set_asym_pause - Configure Pause and Asym Pause
2355 : : * @phydev: target phy_device struct
2356 : : * @rx: Receiver Pause is supported
2357 : : * @tx: Transmit Pause is supported
2358 : : *
2359 : : * Description: Configure advertised Pause support depending on if
2360 : : * transmit and receiver pause is supported. If there has been a
2361 : : * change in adverting, trigger a new autoneg. Generally called from
2362 : : * the set_pauseparam .ndo.
2363 : : */
2364 : 0 : void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
2365 : : {
2366 : 0 : __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
2367 : :
2368 : 0 : linkmode_copy(oldadv, phydev->advertising);
2369 : :
2370 : 0 : linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2371 : 0 : phydev->advertising);
2372 : 0 : linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2373 : : phydev->advertising);
2374 : :
2375 [ # # ]: 0 : if (rx) {
2376 : 0 : linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2377 : : phydev->advertising);
2378 : 0 : linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2379 : : phydev->advertising);
2380 : : }
2381 : :
2382 [ # # ]: 0 : if (tx)
2383 : 0 : linkmode_change_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2384 : : phydev->advertising);
2385 : :
2386 [ # # # # ]: 0 : if (!linkmode_equal(oldadv, phydev->advertising) &&
2387 : : phydev->autoneg)
2388 : 0 : phy_start_aneg(phydev);
2389 : 0 : }
2390 : : EXPORT_SYMBOL(phy_set_asym_pause);
2391 : :
2392 : : /**
2393 : : * phy_validate_pause - Test if the PHY/MAC support the pause configuration
2394 : : * @phydev: phy_device struct
2395 : : * @pp: requested pause configuration
2396 : : *
2397 : : * Description: Test if the PHY/MAC combination supports the Pause
2398 : : * configuration the user is requesting. Returns True if it is
2399 : : * supported, false otherwise.
2400 : : */
2401 : 0 : bool phy_validate_pause(struct phy_device *phydev,
2402 : : struct ethtool_pauseparam *pp)
2403 : : {
2404 [ # # ]: 0 : if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2405 [ # # ]: 0 : phydev->supported) && pp->rx_pause)
2406 : : return false;
2407 : :
2408 [ # # ]: 0 : if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2409 : 0 : phydev->supported) &&
2410 [ # # ]: 0 : pp->rx_pause != pp->tx_pause)
2411 : 0 : return false;
2412 : :
2413 : : return true;
2414 : : }
2415 : : EXPORT_SYMBOL(phy_validate_pause);
2416 : :
2417 : 0 : static bool phy_drv_supports_irq(struct phy_driver *phydrv)
2418 : : {
2419 [ # # ]: 0 : return phydrv->config_intr && phydrv->ack_interrupt;
2420 : : }
2421 : :
2422 : : /**
2423 : : * phy_probe - probe and init a PHY device
2424 : : * @dev: device to probe and init
2425 : : *
2426 : : * Description: Take care of setting up the phy_device structure,
2427 : : * set the state to READY (the driver's init function should
2428 : : * set it to STARTING if needed).
2429 : : */
2430 : 0 : static int phy_probe(struct device *dev)
2431 : : {
2432 : 0 : struct phy_device *phydev = to_phy_device(dev);
2433 : 0 : struct device_driver *drv = phydev->mdio.dev.driver;
2434 : 0 : struct phy_driver *phydrv = to_phy_driver(drv);
2435 : 0 : int err = 0;
2436 : :
2437 : 0 : phydev->drv = phydrv;
2438 : :
2439 : : /* Disable the interrupt if the PHY doesn't support it
2440 : : * but the interrupt is still a valid one
2441 : : */
2442 [ # # # # : 0 : if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
# # ]
2443 : 0 : phydev->irq = PHY_POLL;
2444 : :
2445 [ # # ]: 0 : if (phydrv->flags & PHY_IS_INTERNAL)
2446 : 0 : phydev->is_internal = true;
2447 : :
2448 : 0 : mutex_lock(&phydev->lock);
2449 : :
2450 [ # # ]: 0 : if (phydev->drv->probe) {
2451 : : /* Deassert the reset signal */
2452 : 0 : phy_device_reset(phydev, 0);
2453 : :
2454 : 0 : err = phydev->drv->probe(phydev);
2455 [ # # ]: 0 : if (err) {
2456 : : /* Assert the reset signal */
2457 : 0 : phy_device_reset(phydev, 1);
2458 : 0 : goto out;
2459 : : }
2460 : : }
2461 : :
2462 : : /* Start out supporting everything. Eventually,
2463 : : * a controller will attach, and may modify one
2464 : : * or both of these values
2465 : : */
2466 [ # # ]: 0 : if (phydrv->features) {
2467 : 0 : linkmode_copy(phydev->supported, phydrv->features);
2468 [ # # ]: 0 : } else if (phydrv->get_features) {
2469 : 0 : err = phydrv->get_features(phydev);
2470 [ # # ]: 0 : } else if (phydev->is_c45) {
2471 : 0 : err = genphy_c45_pma_read_abilities(phydev);
2472 : : } else {
2473 : 0 : err = genphy_read_abilities(phydev);
2474 : : }
2475 : :
2476 [ # # ]: 0 : if (err)
2477 : 0 : goto out;
2478 : :
2479 [ # # ]: 0 : if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2480 : 0 : phydev->supported))
2481 : 0 : phydev->autoneg = 0;
2482 : :
2483 [ # # ]: 0 : if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2484 : : phydev->supported))
2485 : 0 : phydev->is_gigabit_capable = 1;
2486 [ # # ]: 0 : if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2487 : : phydev->supported))
2488 : 0 : phydev->is_gigabit_capable = 1;
2489 : :
2490 : 0 : of_set_phy_supported(phydev);
2491 : 0 : phy_advertise_supported(phydev);
2492 : :
2493 : : /* Get the EEE modes we want to prohibit. We will ask
2494 : : * the PHY stop advertising these mode later on
2495 : : */
2496 : 0 : of_set_phy_eee_broken(phydev);
2497 : :
2498 : : /* The Pause Frame bits indicate that the PHY can support passing
2499 : : * pause frames. During autonegotiation, the PHYs will determine if
2500 : : * they should allow pause frames to pass. The MAC driver should then
2501 : : * use that result to determine whether to enable flow control via
2502 : : * pause frames.
2503 : : *
2504 : : * Normally, PHY drivers should not set the Pause bits, and instead
2505 : : * allow phylib to do that. However, there may be some situations
2506 : : * (e.g. hardware erratum) where the driver wants to set only one
2507 : : * of these bits.
2508 : : */
2509 [ # # # # ]: 0 : if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
2510 : : !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
2511 : 0 : linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2512 : : phydev->supported);
2513 : 0 : linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2514 : : phydev->supported);
2515 : : }
2516 : :
2517 : : /* Set the state to READY by default */
2518 : 0 : phydev->state = PHY_READY;
2519 : :
2520 : 0 : out:
2521 : 0 : mutex_unlock(&phydev->lock);
2522 : :
2523 : 0 : return err;
2524 : : }
2525 : :
2526 : 0 : static int phy_remove(struct device *dev)
2527 : : {
2528 : 0 : struct phy_device *phydev = to_phy_device(dev);
2529 : :
2530 : 0 : cancel_delayed_work_sync(&phydev->state_queue);
2531 : :
2532 : 0 : mutex_lock(&phydev->lock);
2533 : 0 : phydev->state = PHY_DOWN;
2534 : 0 : mutex_unlock(&phydev->lock);
2535 : :
2536 [ # # ]: 0 : sfp_bus_del_upstream(phydev->sfp_bus);
2537 : 0 : phydev->sfp_bus = NULL;
2538 : :
2539 [ # # # # ]: 0 : if (phydev->drv && phydev->drv->remove) {
2540 : 0 : phydev->drv->remove(phydev);
2541 : :
2542 : : /* Assert the reset signal */
2543 : 0 : phy_device_reset(phydev, 1);
2544 : : }
2545 : 0 : phydev->drv = NULL;
2546 : :
2547 : 0 : return 0;
2548 : : }
2549 : :
2550 : : /**
2551 : : * phy_driver_register - register a phy_driver with the PHY layer
2552 : : * @new_driver: new phy_driver to register
2553 : : * @owner: module owning this PHY
2554 : : */
2555 : 42 : int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
2556 : : {
2557 : 42 : int retval;
2558 : :
2559 : : /* Either the features are hard coded, or dynamically
2560 : : * determined. It cannot be both.
2561 : : */
2562 [ - + - - : 84 : if (WARN_ON(new_driver->features && new_driver->get_features)) {
- + - + ]
2563 : 0 : pr_err("%s: features and get_features must not both be set\n",
2564 : : new_driver->name);
2565 : 0 : return -EINVAL;
2566 : : }
2567 : :
2568 : 42 : new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
2569 : 42 : new_driver->mdiodrv.driver.name = new_driver->name;
2570 : 42 : new_driver->mdiodrv.driver.bus = &mdio_bus_type;
2571 : 42 : new_driver->mdiodrv.driver.probe = phy_probe;
2572 : 42 : new_driver->mdiodrv.driver.remove = phy_remove;
2573 : 42 : new_driver->mdiodrv.driver.owner = owner;
2574 : :
2575 : 42 : retval = driver_register(&new_driver->mdiodrv.driver);
2576 [ - + ]: 42 : if (retval) {
2577 : 0 : pr_err("%s: Error %d in registering driver\n",
2578 : : new_driver->name, retval);
2579 : :
2580 : 0 : return retval;
2581 : : }
2582 : :
2583 : : pr_debug("%s: Registered new driver\n", new_driver->name);
2584 : :
2585 : : return 0;
2586 : : }
2587 : : EXPORT_SYMBOL(phy_driver_register);
2588 : :
2589 : 3 : int phy_drivers_register(struct phy_driver *new_driver, int n,
2590 : : struct module *owner)
2591 : : {
2592 : 3 : int i, ret = 0;
2593 : :
2594 [ + + ]: 39 : for (i = 0; i < n; i++) {
2595 : 36 : ret = phy_driver_register(new_driver + i, owner);
2596 [ - + ]: 36 : if (ret) {
2597 [ # # ]: 0 : while (i-- > 0)
2598 : 0 : phy_driver_unregister(new_driver + i);
2599 : : break;
2600 : : }
2601 : : }
2602 : 3 : return ret;
2603 : : }
2604 : : EXPORT_SYMBOL(phy_drivers_register);
2605 : :
2606 : 0 : void phy_driver_unregister(struct phy_driver *drv)
2607 : : {
2608 : 0 : driver_unregister(&drv->mdiodrv.driver);
2609 : 0 : }
2610 : : EXPORT_SYMBOL(phy_driver_unregister);
2611 : :
2612 : 0 : void phy_drivers_unregister(struct phy_driver *drv, int n)
2613 : : {
2614 : 0 : int i;
2615 : :
2616 [ # # ]: 0 : for (i = 0; i < n; i++)
2617 : 0 : phy_driver_unregister(drv + i);
2618 : 0 : }
2619 : : EXPORT_SYMBOL(phy_drivers_unregister);
2620 : :
2621 : : static struct phy_driver genphy_driver = {
2622 : : .phy_id = 0xffffffff,
2623 : : .phy_id_mask = 0xffffffff,
2624 : : .name = "Generic PHY",
2625 : : .soft_reset = genphy_no_soft_reset,
2626 : : .get_features = genphy_read_abilities,
2627 : : .suspend = genphy_suspend,
2628 : : .resume = genphy_resume,
2629 : : .set_loopback = genphy_loopback,
2630 : : };
2631 : :
2632 : 3 : static int __init phy_init(void)
2633 : : {
2634 : 3 : int rc;
2635 : :
2636 : 3 : rc = mdio_bus_init();
2637 [ + - ]: 3 : if (rc)
2638 : : return rc;
2639 : :
2640 : 3 : features_init();
2641 : :
2642 : 3 : rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
2643 [ - + ]: 3 : if (rc)
2644 : 0 : goto err_c45;
2645 : :
2646 : 3 : rc = phy_driver_register(&genphy_driver, THIS_MODULE);
2647 [ - + ]: 3 : if (rc) {
2648 : 0 : phy_driver_unregister(&genphy_c45_driver);
2649 : 0 : err_c45:
2650 : 0 : mdio_bus_exit();
2651 : : }
2652 : :
2653 : : return rc;
2654 : : }
2655 : :
2656 : 0 : static void __exit phy_exit(void)
2657 : : {
2658 : 0 : phy_driver_unregister(&genphy_c45_driver);
2659 : 0 : phy_driver_unregister(&genphy_driver);
2660 : 0 : mdio_bus_exit();
2661 : 0 : }
2662 : :
2663 : : subsys_initcall(phy_init);
2664 : : module_exit(phy_exit);
|
