]> git.ipfire.org Git - thirdparty/linux.git/blame - drivers/net/phy/phy.c
Merge tag 'io_uring-5.7-2020-05-22' of git://git.kernel.dk/linux-block
[thirdparty/linux.git] / drivers / net / phy / phy.c
CommitLineData
a2443fd1 1// SPDX-License-Identifier: GPL-2.0+
2f53e904 2/* Framework for configuring and reading PHY devices
00db8189
AF
3 * Based on code in sungem_phy.c and gianfar_phy.c
4 *
5 * Author: Andy Fleming
6 *
7 * Copyright (c) 2004 Freescale Semiconductor, Inc.
0ac49527 8 * Copyright (c) 2006, 2007 Maciej W. Rozycki
00db8189 9 */
8d242488 10
00db8189 11#include <linux/kernel.h>
00db8189
AF
12#include <linux/string.h>
13#include <linux/errno.h>
14#include <linux/unistd.h>
00db8189 15#include <linux/interrupt.h>
00db8189
AF
16#include <linux/delay.h>
17#include <linux/netdevice.h>
18#include <linux/etherdevice.h>
19#include <linux/skbuff.h>
00db8189
AF
20#include <linux/mm.h>
21#include <linux/module.h>
00db8189
AF
22#include <linux/mii.h>
23#include <linux/ethtool.h>
24#include <linux/phy.h>
d6f8cfa3 25#include <linux/phy_led_triggers.h>
298e54fa 26#include <linux/sfp.h>
3c3070d7 27#include <linux/workqueue.h>
a59a4d19 28#include <linux/mdio.h>
2f53e904
SS
29#include <linux/io.h>
30#include <linux/uaccess.h>
60063497 31#include <linux/atomic.h>
2f53e904 32
97b33bdf
HK
33#define PHY_STATE_TIME HZ
34
3e2186e0
FF
35#define PHY_STATE_STR(_state) \
36 case PHY_##_state: \
37 return __stringify(_state); \
38
39static const char *phy_state_to_str(enum phy_state st)
40{
41 switch (st) {
42 PHY_STATE_STR(DOWN)
3e2186e0 43 PHY_STATE_STR(READY)
3e2186e0 44 PHY_STATE_STR(UP)
3e2186e0
FF
45 PHY_STATE_STR(RUNNING)
46 PHY_STATE_STR(NOLINK)
3e2186e0 47 PHY_STATE_STR(HALTED)
3e2186e0
FF
48 }
49
50 return NULL;
51}
52
74a992b3
HK
53static void phy_link_up(struct phy_device *phydev)
54{
55 phydev->phy_link_change(phydev, true, true);
56 phy_led_trigger_change_speed(phydev);
57}
58
59static void phy_link_down(struct phy_device *phydev, bool do_carrier)
60{
61 phydev->phy_link_change(phydev, false, do_carrier);
62 phy_led_trigger_change_speed(phydev);
63}
3e2186e0 64
23bfaa59
HK
65static const char *phy_pause_str(struct phy_device *phydev)
66{
67 bool local_pause, local_asym_pause;
68
69 if (phydev->autoneg == AUTONEG_DISABLE)
70 goto no_pause;
71
72 local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
73 phydev->advertising);
74 local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
75 phydev->advertising);
76
77 if (local_pause && phydev->pause)
78 return "rx/tx";
79
80 if (local_asym_pause && phydev->asym_pause) {
81 if (local_pause)
82 return "rx";
83 if (phydev->pause)
84 return "tx";
85 }
86
87no_pause:
88 return "off";
89}
90
b3df0da8
RD
91/**
92 * phy_print_status - Convenience function to print out the current phy status
93 * @phydev: the phy_device struct
e1393456
AF
94 */
95void phy_print_status(struct phy_device *phydev)
96{
2f53e904 97 if (phydev->link) {
df40cc88 98 netdev_info(phydev->attached_dev,
5eee3bb7 99 "Link is Up - %s/%s %s- flow control %s\n",
766d1d38 100 phy_speed_to_str(phydev->speed),
da4625ac 101 phy_duplex_to_str(phydev->duplex),
5eee3bb7 102 phydev->downshifted_rate ? "(downshifted) " : "",
23bfaa59 103 phy_pause_str(phydev));
2f53e904 104 } else {
43b6329f 105 netdev_info(phydev->attached_dev, "Link is Down\n");
2f53e904 106 }
e1393456
AF
107}
108EXPORT_SYMBOL(phy_print_status);
00db8189 109
b3df0da8
RD
110/**
111 * phy_clear_interrupt - Ack the phy device's interrupt
112 * @phydev: the phy_device struct
113 *
114 * If the @phydev driver has an ack_interrupt function, call it to
115 * ack and clear the phy device's interrupt.
116 *
ad033506 117 * Returns 0 on success or < 0 on error.
b3df0da8 118 */
89ff05ec 119static int phy_clear_interrupt(struct phy_device *phydev)
00db8189 120{
00db8189 121 if (phydev->drv->ack_interrupt)
e62a768f 122 return phydev->drv->ack_interrupt(phydev);
00db8189 123
e62a768f 124 return 0;
00db8189
AF
125}
126
b3df0da8
RD
127/**
128 * phy_config_interrupt - configure the PHY device for the requested interrupts
129 * @phydev: the phy_device struct
130 * @interrupts: interrupt flags to configure for this @phydev
131 *
ad033506 132 * Returns 0 on success or < 0 on error.
b3df0da8 133 */
695bce8f 134static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
00db8189 135{
695bce8f 136 phydev->interrupts = interrupts ? 1 : 0;
00db8189 137 if (phydev->drv->config_intr)
e62a768f 138 return phydev->drv->config_intr(phydev);
00db8189 139
e62a768f 140 return 0;
00db8189
AF
141}
142
002ba705
RK
143/**
144 * phy_restart_aneg - restart auto-negotiation
145 * @phydev: target phy_device struct
146 *
147 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
148 * negative errno on error.
149 */
150int phy_restart_aneg(struct phy_device *phydev)
151{
152 int ret;
153
154 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
155 ret = genphy_c45_restart_aneg(phydev);
156 else
157 ret = genphy_restart_aneg(phydev);
158
159 return ret;
160}
161EXPORT_SYMBOL_GPL(phy_restart_aneg);
00db8189 162
b3df0da8
RD
163/**
164 * phy_aneg_done - return auto-negotiation status
165 * @phydev: target phy_device struct
00db8189 166 *
76a423a3
FF
167 * Description: Return the auto-negotiation status from this @phydev
168 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
169 * is still pending.
00db8189 170 */
372788f9 171int phy_aneg_done(struct phy_device *phydev)
00db8189 172{
65f2767a 173 if (phydev->drv && phydev->drv->aneg_done)
76a423a3 174 return phydev->drv->aneg_done(phydev);
d7bed825
HK
175 else if (phydev->is_c45)
176 return genphy_c45_aneg_done(phydev);
177 else
178 return genphy_aneg_done(phydev);
00db8189 179}
372788f9 180EXPORT_SYMBOL(phy_aneg_done);
00db8189 181
b3df0da8 182/**
d0613037
RK
183 * phy_find_valid - find a PHY setting that matches the requested parameters
184 * @speed: desired speed
185 * @duplex: desired duplex
186 * @supported: mask of supported link modes
00db8189 187 *
d0613037
RK
188 * Locate a supported phy setting that is, in priority order:
189 * - an exact match for the specified speed and duplex mode
190 * - a match for the specified speed, or slower speed
191 * - the slowest supported speed
192 * Returns the matched phy_setting entry, or %NULL if no supported phy
193 * settings were found.
00db8189 194 */
d0613037 195static const struct phy_setting *
3c1bcc86 196phy_find_valid(int speed, int duplex, unsigned long *supported)
00db8189 197{
3c1bcc86 198 return phy_lookup_setting(speed, duplex, supported, false);
00db8189
AF
199}
200
1f9127ca
ZB
201/**
202 * phy_supported_speeds - return all speeds currently supported by a phy device
203 * @phy: The phy device to return supported speeds of.
204 * @speeds: buffer to store supported speeds in.
205 * @size: size of speeds buffer.
206 *
207 * Description: Returns the number of supported speeds, and fills the speeds
208 * buffer with the supported speeds. If speeds buffer is too small to contain
209 * all currently supported speeds, will return as many speeds as can fit.
210 */
211unsigned int phy_supported_speeds(struct phy_device *phy,
212 unsigned int *speeds,
213 unsigned int size)
214{
3c1bcc86 215 return phy_speeds(speeds, size, phy->supported);
1f9127ca
ZB
216}
217
54da5a8b
GR
218/**
219 * phy_check_valid - check if there is a valid PHY setting which matches
220 * speed, duplex, and feature mask
221 * @speed: speed to match
222 * @duplex: duplex to match
223 * @features: A mask of the valid settings
224 *
225 * Description: Returns true if there is a valid setting, false otherwise.
226 */
3c1bcc86
AL
227static inline bool phy_check_valid(int speed, int duplex,
228 unsigned long *features)
54da5a8b 229{
3c1bcc86 230 return !!phy_lookup_setting(speed, duplex, features, true);
54da5a8b
GR
231}
232
b3df0da8
RD
233/**
234 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
235 * @phydev: the target phy_device struct
00db8189 236 *
b3df0da8 237 * Description: Make sure the PHY is set to supported speeds and
00db8189 238 * duplexes. Drop down by one in this order: 1000/FULL,
b3df0da8 239 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
00db8189 240 */
89ff05ec 241static void phy_sanitize_settings(struct phy_device *phydev)
00db8189 242{
d0613037 243 const struct phy_setting *setting;
00db8189 244
3c1bcc86
AL
245 setting = phy_find_valid(phydev->speed, phydev->duplex,
246 phydev->supported);
d0613037
RK
247 if (setting) {
248 phydev->speed = setting->speed;
249 phydev->duplex = setting->duplex;
250 } else {
251 /* We failed to find anything (no supported speeds?) */
252 phydev->speed = SPEED_UNKNOWN;
253 phydev->duplex = DUPLEX_UNKNOWN;
254 }
00db8189 255}
00db8189 256
2d55173e
PR
257int phy_ethtool_ksettings_set(struct phy_device *phydev,
258 const struct ethtool_link_ksettings *cmd)
259{
3c1bcc86 260 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
2d55173e
PR
261 u8 autoneg = cmd->base.autoneg;
262 u8 duplex = cmd->base.duplex;
263 u32 speed = cmd->base.speed;
2d55173e
PR
264
265 if (cmd->base.phy_address != phydev->mdio.addr)
266 return -EINVAL;
267
3c1bcc86 268 linkmode_copy(advertising, cmd->link_modes.advertising);
2d55173e
PR
269
270 /* We make sure that we don't pass unsupported values in to the PHY */
3c1bcc86 271 linkmode_and(advertising, advertising, phydev->supported);
2d55173e
PR
272
273 /* Verify the settings we care about. */
274 if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
275 return -EINVAL;
276
3e536cff 277 if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising))
2d55173e
PR
278 return -EINVAL;
279
280 if (autoneg == AUTONEG_DISABLE &&
281 ((speed != SPEED_1000 &&
282 speed != SPEED_100 &&
283 speed != SPEED_10) ||
284 (duplex != DUPLEX_HALF &&
285 duplex != DUPLEX_FULL)))
286 return -EINVAL;
287
288 phydev->autoneg = autoneg;
289
290 phydev->speed = speed;
291
3c1bcc86 292 linkmode_copy(phydev->advertising, advertising);
2d55173e 293
ccf355e5
FH
294 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
295 phydev->advertising, autoneg == AUTONEG_ENABLE);
2d55173e
PR
296
297 phydev->duplex = duplex;
298
1004ee61 299 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
2d55173e
PR
300
301 /* Restart the PHY */
302 phy_start_aneg(phydev);
303
304 return 0;
305}
306EXPORT_SYMBOL(phy_ethtool_ksettings_set);
307
5514174f 308void phy_ethtool_ksettings_get(struct phy_device *phydev,
309 struct ethtool_link_ksettings *cmd)
2d55173e 310{
3c1bcc86
AL
311 linkmode_copy(cmd->link_modes.supported, phydev->supported);
312 linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
c0ec3c27 313 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
2d55173e
PR
314
315 cmd->base.speed = phydev->speed;
316 cmd->base.duplex = phydev->duplex;
317 if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
318 cmd->base.port = PORT_BNC;
319 else
320 cmd->base.port = PORT_MII;
ceb62813
FF
321 cmd->base.transceiver = phy_is_internal(phydev) ?
322 XCVR_INTERNAL : XCVR_EXTERNAL;
2d55173e
PR
323 cmd->base.phy_address = phydev->mdio.addr;
324 cmd->base.autoneg = phydev->autoneg;
1004ee61
RL
325 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
326 cmd->base.eth_tp_mdix = phydev->mdix;
2d55173e
PR
327}
328EXPORT_SYMBOL(phy_ethtool_ksettings_get);
00db8189 329
b3df0da8
RD
330/**
331 * phy_mii_ioctl - generic PHY MII ioctl interface
332 * @phydev: the phy_device struct
00c7d920 333 * @ifr: &struct ifreq for socket ioctl's
b3df0da8
RD
334 * @cmd: ioctl cmd to execute
335 *
336 * Note that this function is currently incompatible with the
00db8189 337 * PHYCONTROL layer. It changes registers without regard to
b3df0da8 338 * current state. Use at own risk.
00db8189 339 */
2f53e904 340int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
00db8189 341{
28b04113 342 struct mii_ioctl_data *mii_data = if_mii(ifr);
00db8189 343 u16 val = mii_data->val_in;
79ce0477 344 bool change_autoneg = false;
cdea04c2 345 int prtad, devad;
00db8189
AF
346
347 switch (cmd) {
348 case SIOCGMIIPHY:
e5a03bfd 349 mii_data->phy_id = phydev->mdio.addr;
c6d6a511
LB
350 /* fall through */
351
00db8189 352 case SIOCGMIIREG:
cdea04c2
RK
353 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
354 prtad = mdio_phy_id_prtad(mii_data->phy_id);
355 devad = mdio_phy_id_devad(mii_data->phy_id);
356 devad = MII_ADDR_C45 | devad << 16 | mii_data->reg_num;
357 } else {
358 prtad = mii_data->phy_id;
359 devad = mii_data->reg_num;
360 }
361 mii_data->val_out = mdiobus_read(phydev->mdio.bus, prtad,
362 devad);
e62a768f 363 return 0;
00db8189
AF
364
365 case SIOCSMIIREG:
cdea04c2
RK
366 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
367 prtad = mdio_phy_id_prtad(mii_data->phy_id);
368 devad = mdio_phy_id_devad(mii_data->phy_id);
369 devad = MII_ADDR_C45 | devad << 16 | mii_data->reg_num;
370 } else {
371 prtad = mii_data->phy_id;
372 devad = mii_data->reg_num;
373 }
374 if (prtad == phydev->mdio.addr) {
375 switch (devad) {
00db8189 376 case MII_BMCR:
79ce0477
BH
377 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
378 if (phydev->autoneg == AUTONEG_ENABLE)
379 change_autoneg = true;
00db8189 380 phydev->autoneg = AUTONEG_DISABLE;
79ce0477
BH
381 if (val & BMCR_FULLDPLX)
382 phydev->duplex = DUPLEX_FULL;
383 else
384 phydev->duplex = DUPLEX_HALF;
385 if (val & BMCR_SPEED1000)
386 phydev->speed = SPEED_1000;
387 else if (val & BMCR_SPEED100)
388 phydev->speed = SPEED_100;
389 else phydev->speed = SPEED_10;
390 }
391 else {
392 if (phydev->autoneg == AUTONEG_DISABLE)
393 change_autoneg = true;
00db8189 394 phydev->autoneg = AUTONEG_ENABLE;
79ce0477 395 }
00db8189
AF
396 break;
397 case MII_ADVERTISE:
9db299c7
AL
398 mii_adv_mod_linkmode_adv_t(phydev->advertising,
399 val);
79ce0477 400 change_autoneg = true;
00db8189 401 break;
4cf6c57e
RK
402 case MII_CTRL1000:
403 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
404 val);
405 change_autoneg = true;
406 break;
00db8189
AF
407 default:
408 /* do nothing */
409 break;
410 }
411 }
412
cdea04c2 413 mdiobus_write(phydev->mdio.bus, prtad, devad, val);
af1dc13e 414
cdea04c2
RK
415 if (prtad == phydev->mdio.addr &&
416 devad == MII_BMCR &&
2613f95f 417 val & BMCR_RESET)
e62a768f 418 return phy_init_hw(phydev);
79ce0477
BH
419
420 if (change_autoneg)
421 return phy_start_aneg(phydev);
422
e62a768f 423 return 0;
dda93b48 424
c1f19b51 425 case SIOCSHWTSTAMP:
4715f65f
RC
426 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
427 return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
c1f19b51
RC
428 /* fall through */
429
dda93b48 430 default:
c6d6a511 431 return -EOPNOTSUPP;
00db8189 432 }
00db8189 433}
680e9fe9 434EXPORT_SYMBOL(phy_mii_ioctl);
00db8189 435
2ab1d925 436/**
bbbf8430 437 * phy_do_ioctl - generic ndo_do_ioctl implementation
2ab1d925
HK
438 * @dev: the net_device struct
439 * @ifr: &struct ifreq for socket ioctl's
440 * @cmd: ioctl cmd to execute
441 */
bbbf8430 442int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2ab1d925 443{
bbbf8430 444 if (!dev->phydev)
2ab1d925
HK
445 return -ENODEV;
446
447 return phy_mii_ioctl(dev->phydev, ifr, cmd);
448}
bbbf8430
HK
449EXPORT_SYMBOL(phy_do_ioctl);
450
451/* same as phy_do_ioctl, but ensures that net_device is running */
452int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
453{
454 if (!netif_running(dev))
455 return -ENODEV;
456
457 return phy_do_ioctl(dev, ifr, cmd);
458}
3231e5d2 459EXPORT_SYMBOL(phy_do_ioctl_running);
2ab1d925 460
97b33bdf 461void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
a3320bcf
HK
462{
463 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
97b33bdf 464 jiffies);
a3320bcf 465}
97b33bdf 466EXPORT_SYMBOL(phy_queue_state_machine);
a3320bcf
HK
467
468static void phy_trigger_machine(struct phy_device *phydev)
469{
470 phy_queue_state_machine(phydev, 0);
471}
472
76299580
HK
473static int phy_config_aneg(struct phy_device *phydev)
474{
475 if (phydev->drv->config_aneg)
476 return phydev->drv->config_aneg(phydev);
34786005
CG
477
478 /* Clause 45 PHYs that don't implement Clause 22 registers are not
479 * allowed to call genphy_config_aneg()
480 */
481 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
94acaeb5 482 return genphy_c45_config_aneg(phydev);
34786005
CG
483
484 return genphy_config_aneg(phydev);
76299580
HK
485}
486
74a992b3
HK
487/**
488 * phy_check_link_status - check link status and set state accordingly
489 * @phydev: the phy_device struct
490 *
491 * Description: Check for link and whether autoneg was triggered / is running
492 * and set state accordingly
493 */
494static int phy_check_link_status(struct phy_device *phydev)
495{
496 int err;
497
498 WARN_ON(!mutex_is_locked(&phydev->lock));
499
fe4a7a41
JA
500 /* Keep previous state if loopback is enabled because some PHYs
501 * report that Link is Down when loopback is enabled.
502 */
503 if (phydev->loopback_enabled)
504 return 0;
505
74a992b3
HK
506 err = phy_read_status(phydev);
507 if (err)
508 return err;
509
510 if (phydev->link && phydev->state != PHY_RUNNING) {
5eee3bb7 511 phy_check_downshift(phydev);
74a992b3
HK
512 phydev->state = PHY_RUNNING;
513 phy_link_up(phydev);
514 } else if (!phydev->link && phydev->state != PHY_NOLINK) {
515 phydev->state = PHY_NOLINK;
516 phy_link_down(phydev, true);
517 }
518
519 return 0;
520}
521
b3df0da8 522/**
c45d7150 523 * phy_start_aneg - start auto-negotiation for this PHY device
b3df0da8 524 * @phydev: the phy_device struct
e1393456 525 *
b3df0da8
RD
526 * Description: Sanitizes the settings (if we're not autonegotiating
527 * them), and then calls the driver's config_aneg function.
528 * If the PHYCONTROL Layer is operating, we change the state to
529 * reflect the beginning of Auto-negotiation or forcing.
e1393456 530 */
c45d7150 531int phy_start_aneg(struct phy_device *phydev)
e1393456
AF
532{
533 int err;
534
25149ef9
FF
535 if (!phydev->drv)
536 return -EIO;
537
35b5f6b1 538 mutex_lock(&phydev->lock);
e1393456
AF
539
540 if (AUTONEG_DISABLE == phydev->autoneg)
541 phy_sanitize_settings(phydev);
542
76299580 543 err = phy_config_aneg(phydev);
e1393456
AF
544 if (err < 0)
545 goto out_unlock;
546
2bd229df
HK
547 if (phy_is_started(phydev))
548 err = phy_check_link_status(phydev);
e1393456 549out_unlock:
35b5f6b1 550 mutex_unlock(&phydev->lock);
f555f34f 551
e1393456
AF
552 return err;
553}
554EXPORT_SYMBOL(phy_start_aneg);
555
2b9672dd
HK
556static int phy_poll_aneg_done(struct phy_device *phydev)
557{
558 unsigned int retries = 100;
559 int ret;
560
561 do {
562 msleep(100);
563 ret = phy_aneg_done(phydev);
564 } while (!ret && --retries);
565
566 if (!ret)
567 return -ETIMEDOUT;
568
569 return ret < 0 ? ret : 0;
570}
571
572/**
573 * phy_speed_down - set speed to lowest speed supported by both link partners
574 * @phydev: the phy_device struct
575 * @sync: perform action synchronously
576 *
577 * Description: Typically used to save energy when waiting for a WoL packet
578 *
579 * WARNING: Setting sync to false may cause the system being unable to suspend
580 * in case the PHY generates an interrupt when finishing the autonegotiation.
581 * This interrupt may wake up the system immediately after suspend.
582 * Therefore use sync = false only if you're sure it's safe with the respective
583 * network chip.
584 */
585int phy_speed_down(struct phy_device *phydev, bool sync)
586{
65b27995 587 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
2b9672dd
HK
588 int ret;
589
590 if (phydev->autoneg != AUTONEG_ENABLE)
591 return 0;
592
65b27995
HK
593 linkmode_copy(adv_tmp, phydev->advertising);
594
595 ret = phy_speed_down_core(phydev);
596 if (ret)
597 return ret;
2b9672dd 598
65b27995
HK
599 linkmode_copy(phydev->adv_old, adv_tmp);
600
601 if (linkmode_equal(phydev->advertising, adv_tmp))
2b9672dd
HK
602 return 0;
603
604 ret = phy_config_aneg(phydev);
605 if (ret)
606 return ret;
607
608 return sync ? phy_poll_aneg_done(phydev) : 0;
609}
610EXPORT_SYMBOL_GPL(phy_speed_down);
611
612/**
613 * phy_speed_up - (re)set advertised speeds to all supported speeds
614 * @phydev: the phy_device struct
615 *
616 * Description: Used to revert the effect of phy_speed_down
617 */
618int phy_speed_up(struct phy_device *phydev)
619{
65b27995 620 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
2b9672dd
HK
621
622 if (phydev->autoneg != AUTONEG_ENABLE)
623 return 0;
624
65b27995
HK
625 if (linkmode_empty(phydev->adv_old))
626 return 0;
2b9672dd 627
65b27995
HK
628 linkmode_copy(adv_tmp, phydev->advertising);
629 linkmode_copy(phydev->advertising, phydev->adv_old);
630 linkmode_zero(phydev->adv_old);
3c1bcc86 631
65b27995 632 if (linkmode_equal(phydev->advertising, adv_tmp))
2b9672dd
HK
633 return 0;
634
635 return phy_config_aneg(phydev);
636}
637EXPORT_SYMBOL_GPL(phy_speed_up);
638
b3df0da8
RD
639/**
640 * phy_start_machine - start PHY state machine tracking
641 * @phydev: the phy_device struct
00db8189 642 *
b3df0da8 643 * Description: The PHY infrastructure can run a state machine
00db8189 644 * which tracks whether the PHY is starting up, negotiating,
fb5e7606
FF
645 * etc. This function starts the delayed workqueue which tracks
646 * the state of the PHY. If you want to maintain your own state machine,
29935aeb 647 * do not call this function.
b3df0da8 648 */
29935aeb 649void phy_start_machine(struct phy_device *phydev)
00db8189 650{
6384e483 651 phy_trigger_machine(phydev);
00db8189 652}
5e5758d9 653EXPORT_SYMBOL_GPL(phy_start_machine);
00db8189 654
b3df0da8
RD
655/**
656 * phy_stop_machine - stop the PHY state machine tracking
657 * @phydev: target phy_device struct
00db8189 658 *
fb5e7606
FF
659 * Description: Stops the state machine delayed workqueue, sets the
660 * state to UP (unless it wasn't up yet). This function must be
661 * called BEFORE phy_detach.
00db8189
AF
662 */
663void phy_stop_machine(struct phy_device *phydev)
664{
a390d1f3 665 cancel_delayed_work_sync(&phydev->state_queue);
00db8189 666
35b5f6b1 667 mutex_lock(&phydev->lock);
a2fc9d7e 668 if (phy_is_started(phydev))
00db8189 669 phydev->state = PHY_UP;
35b5f6b1 670 mutex_unlock(&phydev->lock);
00db8189
AF
671}
672
b3df0da8
RD
673/**
674 * phy_error - enter HALTED state for this PHY device
675 * @phydev: target phy_device struct
00db8189
AF
676 *
677 * Moves the PHY to the HALTED state in response to a read
678 * or write error, and tells the controller the link is down.
679 * Must not be called from interrupt context, or while the
680 * phydev->lock is held.
681 */
9b9a8bfc 682static void phy_error(struct phy_device *phydev)
00db8189 683{
fa7b28c1
HK
684 WARN_ON(1);
685
35b5f6b1 686 mutex_lock(&phydev->lock);
00db8189 687 phydev->state = PHY_HALTED;
35b5f6b1 688 mutex_unlock(&phydev->lock);
3c293f4e 689
9f2959b6 690 phy_trigger_machine(phydev);
00db8189
AF
691}
692
a2c054a8
BM
693/**
694 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
695 * @phydev: target phy_device struct
696 */
697static int phy_disable_interrupts(struct phy_device *phydev)
698{
699 int err;
700
701 /* Disable PHY interrupts */
702 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
703 if (err)
03fe2deb 704 return err;
a2c054a8
BM
705
706 /* Clear the interrupt */
03fe2deb 707 return phy_clear_interrupt(phydev);
a2c054a8
BM
708}
709
710/**
34d884e3
HK
711 * phy_interrupt - PHY interrupt handler
712 * @irq: interrupt line
713 * @phy_dat: phy_device pointer
714 *
715 * Description: Handle PHY interrupt
a2c054a8 716 */
34d884e3 717static irqreturn_t phy_interrupt(int irq, void *phy_dat)
a2c054a8 718{
34d884e3 719 struct phy_device *phydev = phy_dat;
9010f9de 720 struct phy_driver *drv = phydev->drv;
a2c054a8 721
9010f9de
HK
722 if (drv->handle_interrupt)
723 return drv->handle_interrupt(phydev);
724
725 if (drv->did_interrupt && !drv->did_interrupt(phydev))
34d884e3 726 return IRQ_NONE;
a2c054a8 727
9010f9de
HK
728 /* reschedule state queue work to run as soon as possible */
729 phy_trigger_machine(phydev);
a2c054a8 730
249bc974 731 /* did_interrupt() may have cleared the interrupt already */
9010f9de
HK
732 if (!drv->did_interrupt && phy_clear_interrupt(phydev)) {
733 phy_error(phydev);
734 return IRQ_NONE;
735 }
a2c054a8 736
9010f9de 737 return IRQ_HANDLED;
a2c054a8
BM
738}
739
b3df0da8
RD
740/**
741 * phy_enable_interrupts - Enable the interrupts from the PHY side
742 * @phydev: target phy_device struct
743 */
89ff05ec 744static int phy_enable_interrupts(struct phy_device *phydev)
00db8189 745{
553fe92b 746 int err = phy_clear_interrupt(phydev);
00db8189 747
e1393456
AF
748 if (err < 0)
749 return err;
00db8189 750
553fe92b 751 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
00db8189 752}
00db8189 753
b3df0da8 754/**
07b09289 755 * phy_request_interrupt - request and enable interrupt for a PHY device
b3df0da8 756 * @phydev: target phy_device struct
e1393456 757 *
07b09289 758 * Description: Request and enable the interrupt for the given PHY.
b3df0da8 759 * If this fails, then we set irq to PHY_POLL.
e1393456
AF
760 * This should only be called with a valid IRQ number.
761 */
434a4315 762void phy_request_interrupt(struct phy_device *phydev)
e1393456 763{
434a4315
HK
764 int err;
765
766 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
767 IRQF_ONESHOT | IRQF_SHARED,
768 phydev_name(phydev), phydev);
769 if (err) {
770 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
771 err, phydev->irq);
e1393456 772 phydev->irq = PHY_POLL;
07b09289
HK
773 } else {
774 if (phy_enable_interrupts(phydev)) {
775 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
776 phy_free_interrupt(phydev);
777 phydev->irq = PHY_POLL;
778 }
e1393456 779 }
e1393456 780}
434a4315 781EXPORT_SYMBOL(phy_request_interrupt);
e1393456 782
07b09289
HK
783/**
784 * phy_free_interrupt - disable and free interrupt for a PHY device
785 * @phydev: target phy_device struct
786 *
787 * Description: Disable and free the interrupt for the given PHY.
788 * This should only be called with a valid IRQ number.
789 */
790void phy_free_interrupt(struct phy_device *phydev)
791{
792 phy_disable_interrupts(phydev);
793 free_irq(phydev->irq, phydev);
794}
795EXPORT_SYMBOL(phy_free_interrupt);
796
b3df0da8
RD
797/**
798 * phy_stop - Bring down the PHY link, and stop checking the status
799 * @phydev: target phy_device struct
800 */
e1393456
AF
801void phy_stop(struct phy_device *phydev)
802{
a2fc9d7e 803 if (!phy_is_started(phydev)) {
2b3e88ea
HK
804 WARN(1, "called from state %s\n",
805 phy_state_to_str(phydev->state));
2b3e88ea
HK
806 return;
807 }
e1393456 808
a2fc9d7e
HK
809 mutex_lock(&phydev->lock);
810
298e54fa
RK
811 if (phydev->sfp_bus)
812 sfp_upstream_stop(phydev->sfp_bus);
813
6daf6531
MR
814 phydev->state = PHY_HALTED;
815
35b5f6b1 816 mutex_unlock(&phydev->lock);
3c3070d7 817
e8cfd9d6 818 phy_state_machine(&phydev->state_queue.work);
cbfd12b3 819 phy_stop_machine(phydev);
e8cfd9d6 820
2f53e904 821 /* Cannot call flush_scheduled_work() here as desired because
34d884e3 822 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
3c3070d7
MR
823 * will not reenable interrupts.
824 */
e1393456 825}
2f53e904 826EXPORT_SYMBOL(phy_stop);
e1393456 827
b3df0da8
RD
828/**
829 * phy_start - start or restart a PHY device
830 * @phydev: target phy_device struct
e1393456 831 *
b3df0da8 832 * Description: Indicates the attached device's readiness to
e1393456
AF
833 * handle PHY-related work. Used during startup to start the
834 * PHY, and after a call to phy_stop() to resume operation.
835 * Also used to indicate the MDIO bus has cleared an error
836 * condition.
837 */
838void phy_start(struct phy_device *phydev)
839{
35b5f6b1 840 mutex_lock(&phydev->lock);
e1393456 841
21796261
HK
842 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
843 WARN(1, "called from state %s\n",
844 phy_state_to_str(phydev->state));
845 goto out;
846 }
847
298e54fa
RK
848 if (phydev->sfp_bus)
849 sfp_upstream_start(phydev->sfp_bus);
850
9e573cfc
HK
851 /* if phy was suspended, bring the physical link up again */
852 __phy_resume(phydev);
c15e10e7 853
f24098f8 854 phydev->state = PHY_UP;
9e573cfc
HK
855
856 phy_start_machine(phydev);
21796261 857out:
35b5f6b1 858 mutex_unlock(&phydev->lock);
e1393456 859}
e1393456 860EXPORT_SYMBOL(phy_start);
67c4f3fa 861
35b5f6b1
NC
862/**
863 * phy_state_machine - Handle the state machine
864 * @work: work_struct that describes the work to be done
35b5f6b1 865 */
4f9c85a1 866void phy_state_machine(struct work_struct *work)
00db8189 867{
bf6aede7 868 struct delayed_work *dwork = to_delayed_work(work);
35b5f6b1 869 struct phy_device *phydev =
a390d1f3 870 container_of(dwork, struct phy_device, state_queue);
c15e10e7 871 bool needs_aneg = false, do_suspend = false;
3e2186e0 872 enum phy_state old_state;
00db8189
AF
873 int err = 0;
874
35b5f6b1 875 mutex_lock(&phydev->lock);
00db8189 876
3e2186e0
FF
877 old_state = phydev->state;
878
e109374f
FF
879 switch (phydev->state) {
880 case PHY_DOWN:
e109374f 881 case PHY_READY:
e109374f
FF
882 break;
883 case PHY_UP:
6e14a5ee 884 needs_aneg = true;
00db8189 885
e109374f
FF
886 break;
887 case PHY_NOLINK:
c8e977ba 888 case PHY_RUNNING:
c8e977ba 889 err = phy_check_link_status(phydev);
e109374f 890 break;
e109374f
FF
891 case PHY_HALTED:
892 if (phydev->link) {
893 phydev->link = 0;
a81497be 894 phy_link_down(phydev, true);
e109374f 895 }
95fb8bb3 896 do_suspend = true;
e109374f 897 break;
00db8189
AF
898 }
899
35b5f6b1 900 mutex_unlock(&phydev->lock);
00db8189
AF
901
902 if (needs_aneg)
c45d7150 903 err = phy_start_aneg(phydev);
6e14a5ee 904 else if (do_suspend)
be9dad1f
SH
905 phy_suspend(phydev);
906
00db8189
AF
907 if (err < 0)
908 phy_error(phydev);
909
5c5f626b 910 if (old_state != phydev->state) {
6a95befc
MG
911 phydev_dbg(phydev, "PHY state change %s -> %s\n",
912 phy_state_to_str(old_state),
913 phy_state_to_str(phydev->state));
5c5f626b
HK
914 if (phydev->drv && phydev->drv->link_change_notify)
915 phydev->drv->link_change_notify(phydev);
916 }
3e2186e0 917
d5c3d846
FF
918 /* Only re-schedule a PHY state machine change if we are polling the
919 * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving
075ddebc
HK
920 * between states from phy_mac_interrupt().
921 *
922 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
923 * state machine would be pointless and possibly error prone when
924 * called from phy_disconnect() synchronously.
d5c3d846 925 */
a2004907 926 mutex_lock(&phydev->lock);
2b3e88ea 927 if (phy_polling_mode(phydev) && phy_is_started(phydev))
9f2959b6 928 phy_queue_state_machine(phydev, PHY_STATE_TIME);
a2004907 929 mutex_unlock(&phydev->lock);
35b5f6b1 930}
a59a4d19 931
664fcf12
AL
932/**
933 * phy_mac_interrupt - MAC says the link has changed
934 * @phydev: phy_device struct with changed link
664fcf12 935 *
28b2e0d2
HK
936 * The MAC layer is able to indicate there has been a change in the PHY link
937 * status. Trigger the state machine and work a work queue.
664fcf12 938 */
28b2e0d2 939void phy_mac_interrupt(struct phy_device *phydev)
5ea94e76 940{
deccd16f 941 /* Trigger a state machine change */
d73a2156 942 phy_trigger_machine(phydev);
5ea94e76
FF
943}
944EXPORT_SYMBOL(phy_mac_interrupt);
945
3c1bcc86
AL
946static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
947{
948 linkmode_zero(advertising);
949
950 if (eee_adv & MDIO_EEE_100TX)
951 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
952 advertising);
953 if (eee_adv & MDIO_EEE_1000T)
954 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
955 advertising);
956 if (eee_adv & MDIO_EEE_10GT)
957 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
958 advertising);
959 if (eee_adv & MDIO_EEE_1000KX)
960 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
961 advertising);
962 if (eee_adv & MDIO_EEE_10GKX4)
963 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
964 advertising);
965 if (eee_adv & MDIO_EEE_10GKR)
966 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
967 advertising);
968}
969
a59a4d19
GC
970/**
971 * phy_init_eee - init and check the EEE feature
972 * @phydev: target phy_device struct
973 * @clk_stop_enable: PHY may stop the clock during LPI
974 *
975 * Description: it checks if the Energy-Efficient Ethernet (EEE)
976 * is supported by looking at the MMD registers 3.20 and 7.60/61
977 * and it programs the MMD register 3.0 setting the "Clock stop enable"
978 * bit if required.
979 */
980int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
981{
25149ef9
FF
982 if (!phydev->drv)
983 return -EIO;
984
a59a4d19 985 /* According to 802.3az,the EEE is supported only in full duplex-mode.
a59a4d19 986 */
32d75141 987 if (phydev->duplex == DUPLEX_FULL) {
3c1bcc86
AL
988 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
989 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
990 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
a59a4d19 991 int eee_lp, eee_cap, eee_adv;
4ae6e50c 992 int status;
3c1bcc86 993 u32 cap;
a59a4d19
GC
994
995 /* Read phy status to properly get the right settings */
996 status = phy_read_status(phydev);
997 if (status)
998 return status;
999
1000 /* First check if the EEE ability is supported */
a6d99fcd 1001 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
7a4cecf7
GC
1002 if (eee_cap <= 0)
1003 goto eee_exit_err;
a59a4d19 1004
b32607dd 1005 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
a59a4d19 1006 if (!cap)
7a4cecf7 1007 goto eee_exit_err;
a59a4d19
GC
1008
1009 /* Check which link settings negotiated and verify it in
1010 * the EEE advertising registers.
1011 */
a6d99fcd 1012 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
7a4cecf7
GC
1013 if (eee_lp <= 0)
1014 goto eee_exit_err;
a59a4d19 1015
a6d99fcd 1016 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
7a4cecf7
GC
1017 if (eee_adv <= 0)
1018 goto eee_exit_err;
a59a4d19 1019
3c1bcc86
AL
1020 mmd_eee_adv_to_linkmode(adv, eee_adv);
1021 mmd_eee_adv_to_linkmode(lp, eee_lp);
1022 linkmode_and(common, adv, lp);
1023
1024 if (!phy_check_valid(phydev->speed, phydev->duplex, common))
7a4cecf7 1025 goto eee_exit_err;
a59a4d19 1026
b52c018d 1027 if (clk_stop_enable)
a59a4d19
GC
1028 /* Configure the PHY to stop receiving xMII
1029 * clock while it is signaling LPI.
1030 */
b52c018d
HK
1031 phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1032 MDIO_PCS_CTRL1_CLKSTOP_EN);
a59a4d19 1033
e62a768f 1034 return 0; /* EEE supported */
a59a4d19 1035 }
7a4cecf7 1036eee_exit_err:
e62a768f 1037 return -EPROTONOSUPPORT;
a59a4d19
GC
1038}
1039EXPORT_SYMBOL(phy_init_eee);
1040
1041/**
1042 * phy_get_eee_err - report the EEE wake error count
1043 * @phydev: target phy_device struct
1044 *
1045 * Description: it is to report the number of time where the PHY
1046 * failed to complete its normal wake sequence.
1047 */
1048int phy_get_eee_err(struct phy_device *phydev)
1049{
25149ef9
FF
1050 if (!phydev->drv)
1051 return -EIO;
1052
a6d99fcd 1053 return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
a59a4d19
GC
1054}
1055EXPORT_SYMBOL(phy_get_eee_err);
1056
1057/**
1058 * phy_ethtool_get_eee - get EEE supported and status
1059 * @phydev: target phy_device struct
1060 * @data: ethtool_eee data
1061 *
1062 * Description: it reportes the Supported/Advertisement/LP Advertisement
1063 * capabilities.
1064 */
1065int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1066{
1067 int val;
1068
25149ef9
FF
1069 if (!phydev->drv)
1070 return -EIO;
1071
a59a4d19 1072 /* Get Supported EEE */
a6d99fcd 1073 val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
a59a4d19
GC
1074 if (val < 0)
1075 return val;
b32607dd 1076 data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
a59a4d19
GC
1077
1078 /* Get advertisement EEE */
a6d99fcd 1079 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
a59a4d19
GC
1080 if (val < 0)
1081 return val;
b32607dd 1082 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
d1420bb9 1083 data->eee_enabled = !!data->advertised;
a59a4d19
GC
1084
1085 /* Get LP advertisement EEE */
a6d99fcd 1086 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
a59a4d19
GC
1087 if (val < 0)
1088 return val;
b32607dd 1089 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
a59a4d19 1090
d1420bb9
HK
1091 data->eee_active = !!(data->advertised & data->lp_advertised);
1092
a59a4d19
GC
1093 return 0;
1094}
1095EXPORT_SYMBOL(phy_ethtool_get_eee);
1096
1097/**
1098 * phy_ethtool_set_eee - set EEE supported and status
1099 * @phydev: target phy_device struct
1100 * @data: ethtool_eee data
1101 *
1102 * Description: it is to program the Advertisement EEE register.
1103 */
1104int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1105{
d1420bb9 1106 int cap, old_adv, adv = 0, ret;
a59a4d19 1107
25149ef9
FF
1108 if (!phydev->drv)
1109 return -EIO;
1110
83ea067f
RK
1111 /* Get Supported EEE */
1112 cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1113 if (cap < 0)
1114 return cap;
d853d145 1115
f75abeb8
RK
1116 old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1117 if (old_adv < 0)
1118 return old_adv;
1119
d1420bb9
HK
1120 if (data->eee_enabled) {
1121 adv = !data->advertised ? cap :
1122 ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1123 /* Mask prohibited EEE modes */
1124 adv &= ~phydev->eee_broken_modes;
1125 }
83ea067f 1126
f75abeb8
RK
1127 if (old_adv != adv) {
1128 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1129 if (ret < 0)
1130 return ret;
1131
1132 /* Restart autonegotiation so the new modes get sent to the
1133 * link partner.
1134 */
9de5d235
HK
1135 if (phydev->autoneg == AUTONEG_ENABLE) {
1136 ret = phy_restart_aneg(phydev);
1137 if (ret < 0)
1138 return ret;
1139 }
f75abeb8
RK
1140 }
1141
1142 return 0;
a59a4d19
GC
1143}
1144EXPORT_SYMBOL(phy_ethtool_set_eee);
42e836eb
MS
1145
1146int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1147{
25149ef9 1148 if (phydev->drv && phydev->drv->set_wol)
42e836eb
MS
1149 return phydev->drv->set_wol(phydev, wol);
1150
1151 return -EOPNOTSUPP;
1152}
1153EXPORT_SYMBOL(phy_ethtool_set_wol);
1154
1155void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1156{
25149ef9 1157 if (phydev->drv && phydev->drv->get_wol)
42e836eb
MS
1158 phydev->drv->get_wol(phydev, wol);
1159}
1160EXPORT_SYMBOL(phy_ethtool_get_wol);
9d9a77ce
PR
1161
1162int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1163 struct ethtool_link_ksettings *cmd)
1164{
1165 struct phy_device *phydev = ndev->phydev;
1166
1167 if (!phydev)
1168 return -ENODEV;
1169
5514174f 1170 phy_ethtool_ksettings_get(phydev, cmd);
1171
1172 return 0;
9d9a77ce
PR
1173}
1174EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1175
1176int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1177 const struct ethtool_link_ksettings *cmd)
1178{
1179 struct phy_device *phydev = ndev->phydev;
1180
1181 if (!phydev)
1182 return -ENODEV;
1183
1184 return phy_ethtool_ksettings_set(phydev, cmd);
1185}
1186EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
e86a8987
FF
1187
1188int phy_ethtool_nway_reset(struct net_device *ndev)
1189{
1190 struct phy_device *phydev = ndev->phydev;
1191
1192 if (!phydev)
1193 return -ENODEV;
1194
25149ef9
FF
1195 if (!phydev->drv)
1196 return -EIO;
1197
002ba705 1198 return phy_restart_aneg(phydev);
e86a8987
FF
1199}
1200EXPORT_SYMBOL(phy_ethtool_nway_reset);