1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Core PHY library, taken from phy.c
4 */
5 #include <linux/export.h>
6 #include <linux/phy.h>
7 #include <linux/of.h>
8
9 /**
10 * phy_speed_to_str - Return a string representing the PHY link speed
11 *
12 * @speed: Speed of the link
13 */
phy_speed_to_str(int speed)14 const char *phy_speed_to_str(int speed)
15 {
16 BUILD_BUG_ON_MSG(__ETHTOOL_LINK_MODE_MASK_NBITS != 93,
17 "Enum ethtool_link_mode_bit_indices and phylib are out of sync. "
18 "If a speed or mode has been added please update phy_speed_to_str "
19 "and the PHY settings array.\n");
20
21 switch (speed) {
22 case SPEED_10:
23 return "10Mbps";
24 case SPEED_100:
25 return "100Mbps";
26 case SPEED_1000:
27 return "1Gbps";
28 case SPEED_2500:
29 return "2.5Gbps";
30 case SPEED_5000:
31 return "5Gbps";
32 case SPEED_10000:
33 return "10Gbps";
34 case SPEED_14000:
35 return "14Gbps";
36 case SPEED_20000:
37 return "20Gbps";
38 case SPEED_25000:
39 return "25Gbps";
40 case SPEED_40000:
41 return "40Gbps";
42 case SPEED_50000:
43 return "50Gbps";
44 case SPEED_56000:
45 return "56Gbps";
46 case SPEED_100000:
47 return "100Gbps";
48 case SPEED_200000:
49 return "200Gbps";
50 case SPEED_400000:
51 return "400Gbps";
52 case SPEED_UNKNOWN:
53 return "Unknown";
54 default:
55 return "Unsupported (update phy-core.c)";
56 }
57 }
58 EXPORT_SYMBOL_GPL(phy_speed_to_str);
59
60 /**
61 * phy_duplex_to_str - Return string describing the duplex
62 *
63 * @duplex: Duplex setting to describe
64 */
phy_duplex_to_str(unsigned int duplex)65 const char *phy_duplex_to_str(unsigned int duplex)
66 {
67 if (duplex == DUPLEX_HALF)
68 return "Half";
69 if (duplex == DUPLEX_FULL)
70 return "Full";
71 if (duplex == DUPLEX_UNKNOWN)
72 return "Unknown";
73 return "Unsupported (update phy-core.c)";
74 }
75 EXPORT_SYMBOL_GPL(phy_duplex_to_str);
76
77 /* A mapping of all SUPPORTED settings to speed/duplex. This table
78 * must be grouped by speed and sorted in descending match priority
79 * - iow, descending speed.
80 */
81
82 #define PHY_SETTING(s, d, b) { .speed = SPEED_ ## s, .duplex = DUPLEX_ ## d, \
83 .bit = ETHTOOL_LINK_MODE_ ## b ## _BIT}
84
85 static const struct phy_setting settings[] = {
86 /* 400G */
87 PHY_SETTING( 400000, FULL, 400000baseCR8_Full ),
88 PHY_SETTING( 400000, FULL, 400000baseKR8_Full ),
89 PHY_SETTING( 400000, FULL, 400000baseLR8_ER8_FR8_Full ),
90 PHY_SETTING( 400000, FULL, 400000baseDR8_Full ),
91 PHY_SETTING( 400000, FULL, 400000baseSR8_Full ),
92 PHY_SETTING( 400000, FULL, 400000baseCR4_Full ),
93 PHY_SETTING( 400000, FULL, 400000baseKR4_Full ),
94 PHY_SETTING( 400000, FULL, 400000baseLR4_ER4_FR4_Full ),
95 PHY_SETTING( 400000, FULL, 400000baseDR4_Full ),
96 PHY_SETTING( 400000, FULL, 400000baseSR4_Full ),
97 /* 200G */
98 PHY_SETTING( 200000, FULL, 200000baseCR4_Full ),
99 PHY_SETTING( 200000, FULL, 200000baseKR4_Full ),
100 PHY_SETTING( 200000, FULL, 200000baseLR4_ER4_FR4_Full ),
101 PHY_SETTING( 200000, FULL, 200000baseDR4_Full ),
102 PHY_SETTING( 200000, FULL, 200000baseSR4_Full ),
103 PHY_SETTING( 200000, FULL, 200000baseCR2_Full ),
104 PHY_SETTING( 200000, FULL, 200000baseKR2_Full ),
105 PHY_SETTING( 200000, FULL, 200000baseLR2_ER2_FR2_Full ),
106 PHY_SETTING( 200000, FULL, 200000baseDR2_Full ),
107 PHY_SETTING( 200000, FULL, 200000baseSR2_Full ),
108 /* 100G */
109 PHY_SETTING( 100000, FULL, 100000baseCR4_Full ),
110 PHY_SETTING( 100000, FULL, 100000baseKR4_Full ),
111 PHY_SETTING( 100000, FULL, 100000baseLR4_ER4_Full ),
112 PHY_SETTING( 100000, FULL, 100000baseSR4_Full ),
113 PHY_SETTING( 100000, FULL, 100000baseCR2_Full ),
114 PHY_SETTING( 100000, FULL, 100000baseKR2_Full ),
115 PHY_SETTING( 100000, FULL, 100000baseLR2_ER2_FR2_Full ),
116 PHY_SETTING( 100000, FULL, 100000baseDR2_Full ),
117 PHY_SETTING( 100000, FULL, 100000baseSR2_Full ),
118 PHY_SETTING( 100000, FULL, 100000baseCR_Full ),
119 PHY_SETTING( 100000, FULL, 100000baseKR_Full ),
120 PHY_SETTING( 100000, FULL, 100000baseLR_ER_FR_Full ),
121 PHY_SETTING( 100000, FULL, 100000baseDR_Full ),
122 PHY_SETTING( 100000, FULL, 100000baseSR_Full ),
123 /* 56G */
124 PHY_SETTING( 56000, FULL, 56000baseCR4_Full ),
125 PHY_SETTING( 56000, FULL, 56000baseKR4_Full ),
126 PHY_SETTING( 56000, FULL, 56000baseLR4_Full ),
127 PHY_SETTING( 56000, FULL, 56000baseSR4_Full ),
128 /* 50G */
129 PHY_SETTING( 50000, FULL, 50000baseCR2_Full ),
130 PHY_SETTING( 50000, FULL, 50000baseKR2_Full ),
131 PHY_SETTING( 50000, FULL, 50000baseSR2_Full ),
132 PHY_SETTING( 50000, FULL, 50000baseCR_Full ),
133 PHY_SETTING( 50000, FULL, 50000baseKR_Full ),
134 PHY_SETTING( 50000, FULL, 50000baseLR_ER_FR_Full ),
135 PHY_SETTING( 50000, FULL, 50000baseDR_Full ),
136 PHY_SETTING( 50000, FULL, 50000baseSR_Full ),
137 /* 40G */
138 PHY_SETTING( 40000, FULL, 40000baseCR4_Full ),
139 PHY_SETTING( 40000, FULL, 40000baseKR4_Full ),
140 PHY_SETTING( 40000, FULL, 40000baseLR4_Full ),
141 PHY_SETTING( 40000, FULL, 40000baseSR4_Full ),
142 /* 25G */
143 PHY_SETTING( 25000, FULL, 25000baseCR_Full ),
144 PHY_SETTING( 25000, FULL, 25000baseKR_Full ),
145 PHY_SETTING( 25000, FULL, 25000baseSR_Full ),
146 /* 20G */
147 PHY_SETTING( 20000, FULL, 20000baseKR2_Full ),
148 PHY_SETTING( 20000, FULL, 20000baseMLD2_Full ),
149 /* 10G */
150 PHY_SETTING( 10000, FULL, 10000baseCR_Full ),
151 PHY_SETTING( 10000, FULL, 10000baseER_Full ),
152 PHY_SETTING( 10000, FULL, 10000baseKR_Full ),
153 PHY_SETTING( 10000, FULL, 10000baseKX4_Full ),
154 PHY_SETTING( 10000, FULL, 10000baseLR_Full ),
155 PHY_SETTING( 10000, FULL, 10000baseLRM_Full ),
156 PHY_SETTING( 10000, FULL, 10000baseR_FEC ),
157 PHY_SETTING( 10000, FULL, 10000baseSR_Full ),
158 PHY_SETTING( 10000, FULL, 10000baseT_Full ),
159 /* 5G */
160 PHY_SETTING( 5000, FULL, 5000baseT_Full ),
161 /* 2.5G */
162 PHY_SETTING( 2500, FULL, 2500baseT_Full ),
163 PHY_SETTING( 2500, FULL, 2500baseX_Full ),
164 /* 1G */
165 PHY_SETTING( 1000, FULL, 1000baseT_Full ),
166 PHY_SETTING( 1000, HALF, 1000baseT_Half ),
167 PHY_SETTING( 1000, FULL, 1000baseT1_Full ),
168 PHY_SETTING( 1000, FULL, 1000baseX_Full ),
169 PHY_SETTING( 1000, FULL, 1000baseKX_Full ),
170 /* 100M */
171 PHY_SETTING( 100, FULL, 100baseT_Full ),
172 PHY_SETTING( 100, FULL, 100baseT1_Full ),
173 PHY_SETTING( 100, HALF, 100baseT_Half ),
174 PHY_SETTING( 100, HALF, 100baseFX_Half ),
175 PHY_SETTING( 100, FULL, 100baseFX_Full ),
176 /* 10M */
177 PHY_SETTING( 10, FULL, 10baseT_Full ),
178 PHY_SETTING( 10, HALF, 10baseT_Half ),
179 PHY_SETTING( 10, FULL, 10baseT1L_Full ),
180 };
181 #undef PHY_SETTING
182
183 /**
184 * phy_lookup_setting - lookup a PHY setting
185 * @speed: speed to match
186 * @duplex: duplex to match
187 * @mask: allowed link modes
188 * @exact: an exact match is required
189 *
190 * Search the settings array for a setting that matches the speed and
191 * duplex, and which is supported.
192 *
193 * If @exact is unset, either an exact match or %NULL for no match will
194 * be returned.
195 *
196 * If @exact is set, an exact match, the fastest supported setting at
197 * or below the specified speed, the slowest supported setting, or if
198 * they all fail, %NULL will be returned.
199 */
200 const struct phy_setting *
phy_lookup_setting(int speed,int duplex,const unsigned long * mask,bool exact)201 phy_lookup_setting(int speed, int duplex, const unsigned long *mask, bool exact)
202 {
203 const struct phy_setting *p, *match = NULL, *last = NULL;
204 int i;
205
206 for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) {
207 if (p->bit < __ETHTOOL_LINK_MODE_MASK_NBITS &&
208 test_bit(p->bit, mask)) {
209 last = p;
210 if (p->speed == speed && p->duplex == duplex) {
211 /* Exact match for speed and duplex */
212 match = p;
213 break;
214 } else if (!exact) {
215 if (!match && p->speed <= speed)
216 /* Candidate */
217 match = p;
218
219 if (p->speed < speed)
220 break;
221 }
222 }
223 }
224
225 if (!match && !exact)
226 match = last;
227
228 return match;
229 }
230 EXPORT_SYMBOL_GPL(phy_lookup_setting);
231
phy_speeds(unsigned int * speeds,size_t size,unsigned long * mask)232 size_t phy_speeds(unsigned int *speeds, size_t size,
233 unsigned long *mask)
234 {
235 size_t count;
236 int i;
237
238 for (i = 0, count = 0; i < ARRAY_SIZE(settings) && count < size; i++)
239 if (settings[i].bit < __ETHTOOL_LINK_MODE_MASK_NBITS &&
240 test_bit(settings[i].bit, mask) &&
241 (count == 0 || speeds[count - 1] != settings[i].speed))
242 speeds[count++] = settings[i].speed;
243
244 return count;
245 }
246
__set_linkmode_max_speed(u32 max_speed,unsigned long * addr)247 static void __set_linkmode_max_speed(u32 max_speed, unsigned long *addr)
248 {
249 const struct phy_setting *p;
250 int i;
251
252 for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) {
253 if (p->speed > max_speed)
254 linkmode_clear_bit(p->bit, addr);
255 else
256 break;
257 }
258 }
259
__set_phy_supported(struct phy_device * phydev,u32 max_speed)260 static void __set_phy_supported(struct phy_device *phydev, u32 max_speed)
261 {
262 __set_linkmode_max_speed(max_speed, phydev->supported);
263 }
264
265 /**
266 * phy_set_max_speed - Set the maximum speed the PHY should support
267 *
268 * @phydev: The phy_device struct
269 * @max_speed: Maximum speed
270 *
271 * The PHY might be more capable than the MAC. For example a Fast Ethernet
272 * is connected to a 1G PHY. This function allows the MAC to indicate its
273 * maximum speed, and so limit what the PHY will advertise.
274 */
phy_set_max_speed(struct phy_device * phydev,u32 max_speed)275 void phy_set_max_speed(struct phy_device *phydev, u32 max_speed)
276 {
277 __set_phy_supported(phydev, max_speed);
278
279 phy_advertise_supported(phydev);
280 }
281 EXPORT_SYMBOL(phy_set_max_speed);
282
of_set_phy_supported(struct phy_device * phydev)283 void of_set_phy_supported(struct phy_device *phydev)
284 {
285 struct device_node *node = phydev->mdio.dev.of_node;
286 u32 max_speed;
287
288 if (!IS_ENABLED(CONFIG_OF_MDIO))
289 return;
290
291 if (!node)
292 return;
293
294 if (!of_property_read_u32(node, "max-speed", &max_speed))
295 __set_phy_supported(phydev, max_speed);
296 }
297
of_set_phy_eee_broken(struct phy_device * phydev)298 void of_set_phy_eee_broken(struct phy_device *phydev)
299 {
300 struct device_node *node = phydev->mdio.dev.of_node;
301 u32 broken = 0;
302
303 if (!IS_ENABLED(CONFIG_OF_MDIO))
304 return;
305
306 if (!node)
307 return;
308
309 if (of_property_read_bool(node, "eee-broken-100tx"))
310 broken |= MDIO_EEE_100TX;
311 if (of_property_read_bool(node, "eee-broken-1000t"))
312 broken |= MDIO_EEE_1000T;
313 if (of_property_read_bool(node, "eee-broken-10gt"))
314 broken |= MDIO_EEE_10GT;
315 if (of_property_read_bool(node, "eee-broken-1000kx"))
316 broken |= MDIO_EEE_1000KX;
317 if (of_property_read_bool(node, "eee-broken-10gkx4"))
318 broken |= MDIO_EEE_10GKX4;
319 if (of_property_read_bool(node, "eee-broken-10gkr"))
320 broken |= MDIO_EEE_10GKR;
321
322 phydev->eee_broken_modes = broken;
323 }
324
325 /**
326 * phy_resolve_aneg_pause - Determine pause autoneg results
327 *
328 * @phydev: The phy_device struct
329 *
330 * Once autoneg has completed the local pause settings can be
331 * resolved. Determine if pause and asymmetric pause should be used
332 * by the MAC.
333 */
334
phy_resolve_aneg_pause(struct phy_device * phydev)335 void phy_resolve_aneg_pause(struct phy_device *phydev)
336 {
337 if (phydev->duplex == DUPLEX_FULL) {
338 phydev->pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
339 phydev->lp_advertising);
340 phydev->asym_pause = linkmode_test_bit(
341 ETHTOOL_LINK_MODE_Asym_Pause_BIT,
342 phydev->lp_advertising);
343 }
344 }
345 EXPORT_SYMBOL_GPL(phy_resolve_aneg_pause);
346
347 /**
348 * phy_resolve_aneg_linkmode - resolve the advertisements into PHY settings
349 * @phydev: The phy_device struct
350 *
351 * Resolve our and the link partner advertisements into their corresponding
352 * speed and duplex. If full duplex was negotiated, extract the pause mode
353 * from the link partner mask.
354 */
phy_resolve_aneg_linkmode(struct phy_device * phydev)355 void phy_resolve_aneg_linkmode(struct phy_device *phydev)
356 {
357 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
358 int i;
359
360 linkmode_and(common, phydev->lp_advertising, phydev->advertising);
361
362 for (i = 0; i < ARRAY_SIZE(settings); i++)
363 if (test_bit(settings[i].bit, common)) {
364 phydev->speed = settings[i].speed;
365 phydev->duplex = settings[i].duplex;
366 break;
367 }
368
369 phy_resolve_aneg_pause(phydev);
370 }
371 EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode);
372
373 /**
374 * phy_check_downshift - check whether downshift occurred
375 * @phydev: The phy_device struct
376 *
377 * Check whether a downshift to a lower speed occurred. If this should be the
378 * case warn the user.
379 * Prerequisite for detecting downshift is that PHY driver implements the
380 * read_status callback and sets phydev->speed to the actual link speed.
381 */
phy_check_downshift(struct phy_device * phydev)382 void phy_check_downshift(struct phy_device *phydev)
383 {
384 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
385 int i, speed = SPEED_UNKNOWN;
386
387 phydev->downshifted_rate = 0;
388
389 if (phydev->autoneg == AUTONEG_DISABLE ||
390 phydev->speed == SPEED_UNKNOWN)
391 return;
392
393 linkmode_and(common, phydev->lp_advertising, phydev->advertising);
394
395 for (i = 0; i < ARRAY_SIZE(settings); i++)
396 if (test_bit(settings[i].bit, common)) {
397 speed = settings[i].speed;
398 break;
399 }
400
401 if (speed == SPEED_UNKNOWN || phydev->speed >= speed)
402 return;
403
404 phydev_warn(phydev, "Downshift occurred from negotiated speed %s to actual speed %s, check cabling!\n",
405 phy_speed_to_str(speed), phy_speed_to_str(phydev->speed));
406
407 phydev->downshifted_rate = 1;
408 }
409 EXPORT_SYMBOL_GPL(phy_check_downshift);
410
phy_resolve_min_speed(struct phy_device * phydev,bool fdx_only)411 static int phy_resolve_min_speed(struct phy_device *phydev, bool fdx_only)
412 {
413 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
414 int i = ARRAY_SIZE(settings);
415
416 linkmode_and(common, phydev->lp_advertising, phydev->advertising);
417
418 while (--i >= 0) {
419 if (test_bit(settings[i].bit, common)) {
420 if (fdx_only && settings[i].duplex != DUPLEX_FULL)
421 continue;
422 return settings[i].speed;
423 }
424 }
425
426 return SPEED_UNKNOWN;
427 }
428
phy_speed_down_core(struct phy_device * phydev)429 int phy_speed_down_core(struct phy_device *phydev)
430 {
431 int min_common_speed = phy_resolve_min_speed(phydev, true);
432
433 if (min_common_speed == SPEED_UNKNOWN)
434 return -EINVAL;
435
436 __set_linkmode_max_speed(min_common_speed, phydev->advertising);
437
438 return 0;
439 }
440
mmd_phy_indirect(struct mii_bus * bus,int phy_addr,int devad,u16 regnum)441 static void mmd_phy_indirect(struct mii_bus *bus, int phy_addr, int devad,
442 u16 regnum)
443 {
444 /* Write the desired MMD Devad */
445 __mdiobus_write(bus, phy_addr, MII_MMD_CTRL, devad);
446
447 /* Write the desired MMD register address */
448 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, regnum);
449
450 /* Select the Function : DATA with no post increment */
451 __mdiobus_write(bus, phy_addr, MII_MMD_CTRL,
452 devad | MII_MMD_CTRL_NOINCR);
453 }
454
455 /**
456 * __phy_read_mmd - Convenience function for reading a register
457 * from an MMD on a given PHY.
458 * @phydev: The phy_device struct
459 * @devad: The MMD to read from (0..31)
460 * @regnum: The register on the MMD to read (0..65535)
461 *
462 * Same rules as for __phy_read();
463 */
__phy_read_mmd(struct phy_device * phydev,int devad,u32 regnum)464 int __phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
465 {
466 int val;
467
468 if (regnum > (u16)~0 || devad > 32)
469 return -EINVAL;
470
471 if (phydev->drv && phydev->drv->read_mmd) {
472 val = phydev->drv->read_mmd(phydev, devad, regnum);
473 } else if (phydev->is_c45) {
474 val = __mdiobus_c45_read(phydev->mdio.bus, phydev->mdio.addr,
475 devad, regnum);
476 } else {
477 struct mii_bus *bus = phydev->mdio.bus;
478 int phy_addr = phydev->mdio.addr;
479
480 mmd_phy_indirect(bus, phy_addr, devad, regnum);
481
482 /* Read the content of the MMD's selected register */
483 val = __mdiobus_read(bus, phy_addr, MII_MMD_DATA);
484 }
485 return val;
486 }
487 EXPORT_SYMBOL(__phy_read_mmd);
488
489 /**
490 * phy_read_mmd - Convenience function for reading a register
491 * from an MMD on a given PHY.
492 * @phydev: The phy_device struct
493 * @devad: The MMD to read from
494 * @regnum: The register on the MMD to read
495 *
496 * Same rules as for phy_read();
497 */
phy_read_mmd(struct phy_device * phydev,int devad,u32 regnum)498 int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
499 {
500 int ret;
501
502 phy_lock_mdio_bus(phydev);
503 ret = __phy_read_mmd(phydev, devad, regnum);
504 phy_unlock_mdio_bus(phydev);
505
506 return ret;
507 }
508 EXPORT_SYMBOL(phy_read_mmd);
509
510 /**
511 * __phy_write_mmd - Convenience function for writing a register
512 * on an MMD on a given PHY.
513 * @phydev: The phy_device struct
514 * @devad: The MMD to read from
515 * @regnum: The register on the MMD to read
516 * @val: value to write to @regnum
517 *
518 * Same rules as for __phy_write();
519 */
__phy_write_mmd(struct phy_device * phydev,int devad,u32 regnum,u16 val)520 int __phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
521 {
522 int ret;
523
524 if (regnum > (u16)~0 || devad > 32)
525 return -EINVAL;
526
527 if (phydev->drv && phydev->drv->write_mmd) {
528 ret = phydev->drv->write_mmd(phydev, devad, regnum, val);
529 } else if (phydev->is_c45) {
530 ret = __mdiobus_c45_write(phydev->mdio.bus, phydev->mdio.addr,
531 devad, regnum, val);
532 } else {
533 struct mii_bus *bus = phydev->mdio.bus;
534 int phy_addr = phydev->mdio.addr;
535
536 mmd_phy_indirect(bus, phy_addr, devad, regnum);
537
538 /* Write the data into MMD's selected register */
539 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, val);
540
541 ret = 0;
542 }
543 return ret;
544 }
545 EXPORT_SYMBOL(__phy_write_mmd);
546
547 /**
548 * phy_write_mmd - Convenience function for writing a register
549 * on an MMD on a given PHY.
550 * @phydev: The phy_device struct
551 * @devad: The MMD to read from
552 * @regnum: The register on the MMD to read
553 * @val: value to write to @regnum
554 *
555 * Same rules as for phy_write();
556 */
phy_write_mmd(struct phy_device * phydev,int devad,u32 regnum,u16 val)557 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
558 {
559 int ret;
560
561 phy_lock_mdio_bus(phydev);
562 ret = __phy_write_mmd(phydev, devad, regnum, val);
563 phy_unlock_mdio_bus(phydev);
564
565 return ret;
566 }
567 EXPORT_SYMBOL(phy_write_mmd);
568
569 /**
570 * phy_modify_changed - Function for modifying a PHY register
571 * @phydev: the phy_device struct
572 * @regnum: register number to modify
573 * @mask: bit mask of bits to clear
574 * @set: new value of bits set in mask to write to @regnum
575 *
576 * NOTE: MUST NOT be called from interrupt context,
577 * because the bus read/write functions may wait for an interrupt
578 * to conclude the operation.
579 *
580 * Returns negative errno, 0 if there was no change, and 1 in case of change
581 */
phy_modify_changed(struct phy_device * phydev,u32 regnum,u16 mask,u16 set)582 int phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
583 {
584 int ret;
585
586 phy_lock_mdio_bus(phydev);
587 ret = __phy_modify_changed(phydev, regnum, mask, set);
588 phy_unlock_mdio_bus(phydev);
589
590 return ret;
591 }
592 EXPORT_SYMBOL_GPL(phy_modify_changed);
593
594 /**
595 * __phy_modify - Convenience function for modifying a PHY register
596 * @phydev: the phy_device struct
597 * @regnum: register number to modify
598 * @mask: bit mask of bits to clear
599 * @set: new value of bits set in mask to write to @regnum
600 *
601 * NOTE: MUST NOT be called from interrupt context,
602 * because the bus read/write functions may wait for an interrupt
603 * to conclude the operation.
604 */
__phy_modify(struct phy_device * phydev,u32 regnum,u16 mask,u16 set)605 int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
606 {
607 int ret;
608
609 ret = __phy_modify_changed(phydev, regnum, mask, set);
610
611 return ret < 0 ? ret : 0;
612 }
613 EXPORT_SYMBOL_GPL(__phy_modify);
614
615 /**
616 * phy_modify - Convenience function for modifying a given PHY register
617 * @phydev: the phy_device struct
618 * @regnum: register number to write
619 * @mask: bit mask of bits to clear
620 * @set: new value of bits set in mask to write to @regnum
621 *
622 * NOTE: MUST NOT be called from interrupt context,
623 * because the bus read/write functions may wait for an interrupt
624 * to conclude the operation.
625 */
phy_modify(struct phy_device * phydev,u32 regnum,u16 mask,u16 set)626 int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
627 {
628 int ret;
629
630 phy_lock_mdio_bus(phydev);
631 ret = __phy_modify(phydev, regnum, mask, set);
632 phy_unlock_mdio_bus(phydev);
633
634 return ret;
635 }
636 EXPORT_SYMBOL_GPL(phy_modify);
637
638 /**
639 * __phy_modify_mmd_changed - Function for modifying a register on MMD
640 * @phydev: the phy_device struct
641 * @devad: the MMD containing register to modify
642 * @regnum: register number to modify
643 * @mask: bit mask of bits to clear
644 * @set: new value of bits set in mask to write to @regnum
645 *
646 * Unlocked helper function which allows a MMD register to be modified as
647 * new register value = (old register value & ~mask) | set
648 *
649 * Returns negative errno, 0 if there was no change, and 1 in case of change
650 */
__phy_modify_mmd_changed(struct phy_device * phydev,int devad,u32 regnum,u16 mask,u16 set)651 int __phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
652 u16 mask, u16 set)
653 {
654 int new, ret;
655
656 ret = __phy_read_mmd(phydev, devad, regnum);
657 if (ret < 0)
658 return ret;
659
660 new = (ret & ~mask) | set;
661 if (new == ret)
662 return 0;
663
664 ret = __phy_write_mmd(phydev, devad, regnum, new);
665
666 return ret < 0 ? ret : 1;
667 }
668 EXPORT_SYMBOL_GPL(__phy_modify_mmd_changed);
669
670 /**
671 * phy_modify_mmd_changed - Function for modifying a register on MMD
672 * @phydev: the phy_device struct
673 * @devad: the MMD containing register to modify
674 * @regnum: register number to modify
675 * @mask: bit mask of bits to clear
676 * @set: new value of bits set in mask to write to @regnum
677 *
678 * NOTE: MUST NOT be called from interrupt context,
679 * because the bus read/write functions may wait for an interrupt
680 * to conclude the operation.
681 *
682 * Returns negative errno, 0 if there was no change, and 1 in case of change
683 */
phy_modify_mmd_changed(struct phy_device * phydev,int devad,u32 regnum,u16 mask,u16 set)684 int phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
685 u16 mask, u16 set)
686 {
687 int ret;
688
689 phy_lock_mdio_bus(phydev);
690 ret = __phy_modify_mmd_changed(phydev, devad, regnum, mask, set);
691 phy_unlock_mdio_bus(phydev);
692
693 return ret;
694 }
695 EXPORT_SYMBOL_GPL(phy_modify_mmd_changed);
696
697 /**
698 * __phy_modify_mmd - Convenience function for modifying a register on MMD
699 * @phydev: the phy_device struct
700 * @devad: the MMD containing register to modify
701 * @regnum: register number to modify
702 * @mask: bit mask of bits to clear
703 * @set: new value of bits set in mask to write to @regnum
704 *
705 * NOTE: MUST NOT be called from interrupt context,
706 * because the bus read/write functions may wait for an interrupt
707 * to conclude the operation.
708 */
__phy_modify_mmd(struct phy_device * phydev,int devad,u32 regnum,u16 mask,u16 set)709 int __phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
710 u16 mask, u16 set)
711 {
712 int ret;
713
714 ret = __phy_modify_mmd_changed(phydev, devad, regnum, mask, set);
715
716 return ret < 0 ? ret : 0;
717 }
718 EXPORT_SYMBOL_GPL(__phy_modify_mmd);
719
720 /**
721 * phy_modify_mmd - Convenience function for modifying a register on MMD
722 * @phydev: the phy_device struct
723 * @devad: the MMD containing register to modify
724 * @regnum: register number to modify
725 * @mask: bit mask of bits to clear
726 * @set: new value of bits set in mask to write to @regnum
727 *
728 * NOTE: MUST NOT be called from interrupt context,
729 * because the bus read/write functions may wait for an interrupt
730 * to conclude the operation.
731 */
phy_modify_mmd(struct phy_device * phydev,int devad,u32 regnum,u16 mask,u16 set)732 int phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
733 u16 mask, u16 set)
734 {
735 int ret;
736
737 phy_lock_mdio_bus(phydev);
738 ret = __phy_modify_mmd(phydev, devad, regnum, mask, set);
739 phy_unlock_mdio_bus(phydev);
740
741 return ret;
742 }
743 EXPORT_SYMBOL_GPL(phy_modify_mmd);
744
__phy_read_page(struct phy_device * phydev)745 static int __phy_read_page(struct phy_device *phydev)
746 {
747 if (WARN_ONCE(!phydev->drv->read_page, "read_page callback not available, PHY driver not loaded?\n"))
748 return -EOPNOTSUPP;
749
750 return phydev->drv->read_page(phydev);
751 }
752
__phy_write_page(struct phy_device * phydev,int page)753 static int __phy_write_page(struct phy_device *phydev, int page)
754 {
755 if (WARN_ONCE(!phydev->drv->write_page, "write_page callback not available, PHY driver not loaded?\n"))
756 return -EOPNOTSUPP;
757
758 return phydev->drv->write_page(phydev, page);
759 }
760
761 /**
762 * phy_save_page() - take the bus lock and save the current page
763 * @phydev: a pointer to a &struct phy_device
764 *
765 * Take the MDIO bus lock, and return the current page number. On error,
766 * returns a negative errno. phy_restore_page() must always be called
767 * after this, irrespective of success or failure of this call.
768 */
phy_save_page(struct phy_device * phydev)769 int phy_save_page(struct phy_device *phydev)
770 {
771 phy_lock_mdio_bus(phydev);
772 return __phy_read_page(phydev);
773 }
774 EXPORT_SYMBOL_GPL(phy_save_page);
775
776 /**
777 * phy_select_page() - take the bus lock, save the current page, and set a page
778 * @phydev: a pointer to a &struct phy_device
779 * @page: desired page
780 *
781 * Take the MDIO bus lock to protect against concurrent access, save the
782 * current PHY page, and set the current page. On error, returns a
783 * negative errno, otherwise returns the previous page number.
784 * phy_restore_page() must always be called after this, irrespective
785 * of success or failure of this call.
786 */
phy_select_page(struct phy_device * phydev,int page)787 int phy_select_page(struct phy_device *phydev, int page)
788 {
789 int ret, oldpage;
790
791 oldpage = ret = phy_save_page(phydev);
792 if (ret < 0)
793 return ret;
794
795 if (oldpage != page) {
796 ret = __phy_write_page(phydev, page);
797 if (ret < 0)
798 return ret;
799 }
800
801 return oldpage;
802 }
803 EXPORT_SYMBOL_GPL(phy_select_page);
804
805 /**
806 * phy_restore_page() - restore the page register and release the bus lock
807 * @phydev: a pointer to a &struct phy_device
808 * @oldpage: the old page, return value from phy_save_page() or phy_select_page()
809 * @ret: operation's return code
810 *
811 * Release the MDIO bus lock, restoring @oldpage if it is a valid page.
812 * This function propagates the earliest error code from the group of
813 * operations.
814 *
815 * Returns:
816 * @oldpage if it was a negative value, otherwise
817 * @ret if it was a negative errno value, otherwise
818 * phy_write_page()'s negative value if it were in error, otherwise
819 * @ret.
820 */
phy_restore_page(struct phy_device * phydev,int oldpage,int ret)821 int phy_restore_page(struct phy_device *phydev, int oldpage, int ret)
822 {
823 int r;
824
825 if (oldpage >= 0) {
826 r = __phy_write_page(phydev, oldpage);
827
828 /* Propagate the operation return code if the page write
829 * was successful.
830 */
831 if (ret >= 0 && r < 0)
832 ret = r;
833 } else {
834 /* Propagate the phy page selection error code */
835 ret = oldpage;
836 }
837
838 phy_unlock_mdio_bus(phydev);
839
840 return ret;
841 }
842 EXPORT_SYMBOL_GPL(phy_restore_page);
843
844 /**
845 * phy_read_paged() - Convenience function for reading a paged register
846 * @phydev: a pointer to a &struct phy_device
847 * @page: the page for the phy
848 * @regnum: register number
849 *
850 * Same rules as for phy_read().
851 */
phy_read_paged(struct phy_device * phydev,int page,u32 regnum)852 int phy_read_paged(struct phy_device *phydev, int page, u32 regnum)
853 {
854 int ret = 0, oldpage;
855
856 oldpage = phy_select_page(phydev, page);
857 if (oldpage >= 0)
858 ret = __phy_read(phydev, regnum);
859
860 return phy_restore_page(phydev, oldpage, ret);
861 }
862 EXPORT_SYMBOL(phy_read_paged);
863
864 /**
865 * phy_write_paged() - Convenience function for writing a paged register
866 * @phydev: a pointer to a &struct phy_device
867 * @page: the page for the phy
868 * @regnum: register number
869 * @val: value to write
870 *
871 * Same rules as for phy_write().
872 */
phy_write_paged(struct phy_device * phydev,int page,u32 regnum,u16 val)873 int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val)
874 {
875 int ret = 0, oldpage;
876
877 oldpage = phy_select_page(phydev, page);
878 if (oldpage >= 0)
879 ret = __phy_write(phydev, regnum, val);
880
881 return phy_restore_page(phydev, oldpage, ret);
882 }
883 EXPORT_SYMBOL(phy_write_paged);
884
885 /**
886 * phy_modify_paged_changed() - Function for modifying a paged register
887 * @phydev: a pointer to a &struct phy_device
888 * @page: the page for the phy
889 * @regnum: register number
890 * @mask: bit mask of bits to clear
891 * @set: bit mask of bits to set
892 *
893 * Returns negative errno, 0 if there was no change, and 1 in case of change
894 */
phy_modify_paged_changed(struct phy_device * phydev,int page,u32 regnum,u16 mask,u16 set)895 int phy_modify_paged_changed(struct phy_device *phydev, int page, u32 regnum,
896 u16 mask, u16 set)
897 {
898 int ret = 0, oldpage;
899
900 oldpage = phy_select_page(phydev, page);
901 if (oldpage >= 0)
902 ret = __phy_modify_changed(phydev, regnum, mask, set);
903
904 return phy_restore_page(phydev, oldpage, ret);
905 }
906 EXPORT_SYMBOL(phy_modify_paged_changed);
907
908 /**
909 * phy_modify_paged() - Convenience function for modifying a paged register
910 * @phydev: a pointer to a &struct phy_device
911 * @page: the page for the phy
912 * @regnum: register number
913 * @mask: bit mask of bits to clear
914 * @set: bit mask of bits to set
915 *
916 * Same rules as for phy_read() and phy_write().
917 */
phy_modify_paged(struct phy_device * phydev,int page,u32 regnum,u16 mask,u16 set)918 int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
919 u16 mask, u16 set)
920 {
921 int ret = phy_modify_paged_changed(phydev, page, regnum, mask, set);
922
923 return ret < 0 ? ret : 0;
924 }
925 EXPORT_SYMBOL(phy_modify_paged);
926