1 // SPDX-License-Identifier: GPL-2.0+
2 /* Framework for configuring and reading PHY devices
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.
8 * Copyright (c) 2006, 2007 Maciej W. Rozycki
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/string.h>
13 #include <linux/errno.h>
14 #include <linux/unistd.h>
15 #include <linux/interrupt.h>
16 #include <linux/delay.h>
17 #include <linux/netdevice.h>
18 #include <linux/netlink.h>
19 #include <linux/etherdevice.h>
20 #include <linux/skbuff.h>
21 #include <linux/mm.h>
22 #include <linux/module.h>
23 #include <linux/mii.h>
24 #include <linux/ethtool.h>
25 #include <linux/ethtool_netlink.h>
26 #include <linux/phy.h>
27 #include <linux/phy_led_triggers.h>
28 #include <linux/sfp.h>
29 #include <linux/workqueue.h>
30 #include <linux/mdio.h>
31 #include <linux/io.h>
32 #include <linux/uaccess.h>
33 #include <linux/atomic.h>
34 #include <net/netlink.h>
35 #include <net/genetlink.h>
36 #include <net/sock.h>
37
38 #define PHY_STATE_TIME HZ
39
40 #define PHY_STATE_STR(_state) \
41 case PHY_##_state: \
42 return __stringify(_state); \
43
phy_state_to_str(enum phy_state st)44 static const char *phy_state_to_str(enum phy_state st)
45 {
46 switch (st) {
47 PHY_STATE_STR(DOWN)
48 PHY_STATE_STR(READY)
49 PHY_STATE_STR(UP)
50 PHY_STATE_STR(RUNNING)
51 PHY_STATE_STR(NOLINK)
52 PHY_STATE_STR(CABLETEST)
53 PHY_STATE_STR(HALTED)
54 }
55
56 return NULL;
57 }
58
phy_link_up(struct phy_device * phydev)59 static void phy_link_up(struct phy_device *phydev)
60 {
61 phydev->phy_link_change(phydev, true);
62 phy_led_trigger_change_speed(phydev);
63 }
64
phy_link_down(struct phy_device * phydev)65 static void phy_link_down(struct phy_device *phydev)
66 {
67 phydev->phy_link_change(phydev, false);
68 phy_led_trigger_change_speed(phydev);
69 }
70
phy_pause_str(struct phy_device * phydev)71 static const char *phy_pause_str(struct phy_device *phydev)
72 {
73 bool local_pause, local_asym_pause;
74
75 if (phydev->autoneg == AUTONEG_DISABLE)
76 goto no_pause;
77
78 local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
79 phydev->advertising);
80 local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
81 phydev->advertising);
82
83 if (local_pause && phydev->pause)
84 return "rx/tx";
85
86 if (local_asym_pause && phydev->asym_pause) {
87 if (local_pause)
88 return "rx";
89 if (phydev->pause)
90 return "tx";
91 }
92
93 no_pause:
94 return "off";
95 }
96
97 /**
98 * phy_print_status - Convenience function to print out the current phy status
99 * @phydev: the phy_device struct
100 */
phy_print_status(struct phy_device * phydev)101 void phy_print_status(struct phy_device *phydev)
102 {
103 if (phydev->link) {
104 netdev_info(phydev->attached_dev,
105 "Link is Up - %s/%s %s- flow control %s\n",
106 phy_speed_to_str(phydev->speed),
107 phy_duplex_to_str(phydev->duplex),
108 phydev->downshifted_rate ? "(downshifted) " : "",
109 phy_pause_str(phydev));
110 } else {
111 netdev_info(phydev->attached_dev, "Link is Down\n");
112 }
113 }
114 EXPORT_SYMBOL(phy_print_status);
115
116 /**
117 * phy_config_interrupt - configure the PHY device for the requested interrupts
118 * @phydev: the phy_device struct
119 * @interrupts: interrupt flags to configure for this @phydev
120 *
121 * Returns 0 on success or < 0 on error.
122 */
phy_config_interrupt(struct phy_device * phydev,bool interrupts)123 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
124 {
125 phydev->interrupts = interrupts ? 1 : 0;
126 if (phydev->drv->config_intr)
127 return phydev->drv->config_intr(phydev);
128
129 return 0;
130 }
131
132 /**
133 * phy_restart_aneg - restart auto-negotiation
134 * @phydev: target phy_device struct
135 *
136 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
137 * negative errno on error.
138 */
phy_restart_aneg(struct phy_device * phydev)139 int phy_restart_aneg(struct phy_device *phydev)
140 {
141 int ret;
142
143 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
144 ret = genphy_c45_restart_aneg(phydev);
145 else
146 ret = genphy_restart_aneg(phydev);
147
148 return ret;
149 }
150 EXPORT_SYMBOL_GPL(phy_restart_aneg);
151
152 /**
153 * phy_aneg_done - return auto-negotiation status
154 * @phydev: target phy_device struct
155 *
156 * Description: Return the auto-negotiation status from this @phydev
157 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
158 * is still pending.
159 */
phy_aneg_done(struct phy_device * phydev)160 int phy_aneg_done(struct phy_device *phydev)
161 {
162 if (phydev->drv && phydev->drv->aneg_done)
163 return phydev->drv->aneg_done(phydev);
164 else if (phydev->is_c45)
165 return genphy_c45_aneg_done(phydev);
166 else
167 return genphy_aneg_done(phydev);
168 }
169 EXPORT_SYMBOL(phy_aneg_done);
170
171 /**
172 * phy_find_valid - find a PHY setting that matches the requested parameters
173 * @speed: desired speed
174 * @duplex: desired duplex
175 * @supported: mask of supported link modes
176 *
177 * Locate a supported phy setting that is, in priority order:
178 * - an exact match for the specified speed and duplex mode
179 * - a match for the specified speed, or slower speed
180 * - the slowest supported speed
181 * Returns the matched phy_setting entry, or %NULL if no supported phy
182 * settings were found.
183 */
184 static const struct phy_setting *
phy_find_valid(int speed,int duplex,unsigned long * supported)185 phy_find_valid(int speed, int duplex, unsigned long *supported)
186 {
187 return phy_lookup_setting(speed, duplex, supported, false);
188 }
189
190 /**
191 * phy_supported_speeds - return all speeds currently supported by a phy device
192 * @phy: The phy device to return supported speeds of.
193 * @speeds: buffer to store supported speeds in.
194 * @size: size of speeds buffer.
195 *
196 * Description: Returns the number of supported speeds, and fills the speeds
197 * buffer with the supported speeds. If speeds buffer is too small to contain
198 * all currently supported speeds, will return as many speeds as can fit.
199 */
phy_supported_speeds(struct phy_device * phy,unsigned int * speeds,unsigned int size)200 unsigned int phy_supported_speeds(struct phy_device *phy,
201 unsigned int *speeds,
202 unsigned int size)
203 {
204 return phy_speeds(speeds, size, phy->supported);
205 }
206
207 /**
208 * phy_check_valid - check if there is a valid PHY setting which matches
209 * speed, duplex, and feature mask
210 * @speed: speed to match
211 * @duplex: duplex to match
212 * @features: A mask of the valid settings
213 *
214 * Description: Returns true if there is a valid setting, false otherwise.
215 */
phy_check_valid(int speed,int duplex,unsigned long * features)216 static inline bool phy_check_valid(int speed, int duplex,
217 unsigned long *features)
218 {
219 return !!phy_lookup_setting(speed, duplex, features, true);
220 }
221
222 /**
223 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
224 * @phydev: the target phy_device struct
225 *
226 * Description: Make sure the PHY is set to supported speeds and
227 * duplexes. Drop down by one in this order: 1000/FULL,
228 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
229 */
phy_sanitize_settings(struct phy_device * phydev)230 static void phy_sanitize_settings(struct phy_device *phydev)
231 {
232 const struct phy_setting *setting;
233
234 setting = phy_find_valid(phydev->speed, phydev->duplex,
235 phydev->supported);
236 if (setting) {
237 phydev->speed = setting->speed;
238 phydev->duplex = setting->duplex;
239 } else {
240 /* We failed to find anything (no supported speeds?) */
241 phydev->speed = SPEED_UNKNOWN;
242 phydev->duplex = DUPLEX_UNKNOWN;
243 }
244 }
245
phy_ethtool_ksettings_set(struct phy_device * phydev,const struct ethtool_link_ksettings * cmd)246 int phy_ethtool_ksettings_set(struct phy_device *phydev,
247 const struct ethtool_link_ksettings *cmd)
248 {
249 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
250 u8 autoneg = cmd->base.autoneg;
251 u8 duplex = cmd->base.duplex;
252 u32 speed = cmd->base.speed;
253
254 if (cmd->base.phy_address != phydev->mdio.addr)
255 return -EINVAL;
256
257 linkmode_copy(advertising, cmd->link_modes.advertising);
258
259 /* We make sure that we don't pass unsupported values in to the PHY */
260 linkmode_and(advertising, advertising, phydev->supported);
261
262 /* Verify the settings we care about. */
263 if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
264 return -EINVAL;
265
266 if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising))
267 return -EINVAL;
268
269 if (autoneg == AUTONEG_DISABLE &&
270 ((speed != SPEED_1000 &&
271 speed != SPEED_100 &&
272 speed != SPEED_10) ||
273 (duplex != DUPLEX_HALF &&
274 duplex != DUPLEX_FULL)))
275 return -EINVAL;
276
277 phydev->autoneg = autoneg;
278
279 if (autoneg == AUTONEG_DISABLE) {
280 phydev->speed = speed;
281 phydev->duplex = duplex;
282 }
283
284 linkmode_copy(phydev->advertising, advertising);
285
286 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
287 phydev->advertising, autoneg == AUTONEG_ENABLE);
288
289 phydev->master_slave_set = cmd->base.master_slave_cfg;
290 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
291
292 /* Restart the PHY */
293 phy_start_aneg(phydev);
294
295 return 0;
296 }
297 EXPORT_SYMBOL(phy_ethtool_ksettings_set);
298
phy_ethtool_ksettings_get(struct phy_device * phydev,struct ethtool_link_ksettings * cmd)299 void phy_ethtool_ksettings_get(struct phy_device *phydev,
300 struct ethtool_link_ksettings *cmd)
301 {
302 linkmode_copy(cmd->link_modes.supported, phydev->supported);
303 linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
304 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
305
306 cmd->base.speed = phydev->speed;
307 cmd->base.duplex = phydev->duplex;
308 cmd->base.master_slave_cfg = phydev->master_slave_get;
309 cmd->base.master_slave_state = phydev->master_slave_state;
310 if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
311 cmd->base.port = PORT_BNC;
312 else
313 cmd->base.port = phydev->port;
314 cmd->base.transceiver = phy_is_internal(phydev) ?
315 XCVR_INTERNAL : XCVR_EXTERNAL;
316 cmd->base.phy_address = phydev->mdio.addr;
317 cmd->base.autoneg = phydev->autoneg;
318 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
319 cmd->base.eth_tp_mdix = phydev->mdix;
320 }
321 EXPORT_SYMBOL(phy_ethtool_ksettings_get);
322
323 /**
324 * phy_mii_ioctl - generic PHY MII ioctl interface
325 * @phydev: the phy_device struct
326 * @ifr: &struct ifreq for socket ioctl's
327 * @cmd: ioctl cmd to execute
328 *
329 * Note that this function is currently incompatible with the
330 * PHYCONTROL layer. It changes registers without regard to
331 * current state. Use at own risk.
332 */
phy_mii_ioctl(struct phy_device * phydev,struct ifreq * ifr,int cmd)333 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
334 {
335 struct mii_ioctl_data *mii_data = if_mii(ifr);
336 u16 val = mii_data->val_in;
337 bool change_autoneg = false;
338 int prtad, devad;
339
340 switch (cmd) {
341 case SIOCGMIIPHY:
342 mii_data->phy_id = phydev->mdio.addr;
343 fallthrough;
344
345 case SIOCGMIIREG:
346 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
347 prtad = mdio_phy_id_prtad(mii_data->phy_id);
348 devad = mdio_phy_id_devad(mii_data->phy_id);
349 devad = mdiobus_c45_addr(devad, mii_data->reg_num);
350 } else {
351 prtad = mii_data->phy_id;
352 devad = mii_data->reg_num;
353 }
354 mii_data->val_out = mdiobus_read(phydev->mdio.bus, prtad,
355 devad);
356 return 0;
357
358 case SIOCSMIIREG:
359 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
360 prtad = mdio_phy_id_prtad(mii_data->phy_id);
361 devad = mdio_phy_id_devad(mii_data->phy_id);
362 devad = mdiobus_c45_addr(devad, mii_data->reg_num);
363 } else {
364 prtad = mii_data->phy_id;
365 devad = mii_data->reg_num;
366 }
367 if (prtad == phydev->mdio.addr) {
368 switch (devad) {
369 case MII_BMCR:
370 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
371 if (phydev->autoneg == AUTONEG_ENABLE)
372 change_autoneg = true;
373 phydev->autoneg = AUTONEG_DISABLE;
374 if (val & BMCR_FULLDPLX)
375 phydev->duplex = DUPLEX_FULL;
376 else
377 phydev->duplex = DUPLEX_HALF;
378 if (val & BMCR_SPEED1000)
379 phydev->speed = SPEED_1000;
380 else if (val & BMCR_SPEED100)
381 phydev->speed = SPEED_100;
382 else phydev->speed = SPEED_10;
383 }
384 else {
385 if (phydev->autoneg == AUTONEG_DISABLE)
386 change_autoneg = true;
387 phydev->autoneg = AUTONEG_ENABLE;
388 }
389 break;
390 case MII_ADVERTISE:
391 mii_adv_mod_linkmode_adv_t(phydev->advertising,
392 val);
393 change_autoneg = true;
394 break;
395 case MII_CTRL1000:
396 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
397 val);
398 change_autoneg = true;
399 break;
400 default:
401 /* do nothing */
402 break;
403 }
404 }
405
406 mdiobus_write(phydev->mdio.bus, prtad, devad, val);
407
408 if (prtad == phydev->mdio.addr &&
409 devad == MII_BMCR &&
410 val & BMCR_RESET)
411 return phy_init_hw(phydev);
412
413 if (change_autoneg)
414 return phy_start_aneg(phydev);
415
416 return 0;
417
418 case SIOCSHWTSTAMP:
419 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
420 return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
421 fallthrough;
422
423 default:
424 return -EOPNOTSUPP;
425 }
426 }
427 EXPORT_SYMBOL(phy_mii_ioctl);
428
429 /**
430 * phy_do_ioctl - generic ndo_do_ioctl implementation
431 * @dev: the net_device struct
432 * @ifr: &struct ifreq for socket ioctl's
433 * @cmd: ioctl cmd to execute
434 */
phy_do_ioctl(struct net_device * dev,struct ifreq * ifr,int cmd)435 int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
436 {
437 if (!dev->phydev)
438 return -ENODEV;
439
440 return phy_mii_ioctl(dev->phydev, ifr, cmd);
441 }
442 EXPORT_SYMBOL(phy_do_ioctl);
443
444 /**
445 * phy_do_ioctl_running - generic ndo_do_ioctl implementation but test first
446 *
447 * @dev: the net_device struct
448 * @ifr: &struct ifreq for socket ioctl's
449 * @cmd: ioctl cmd to execute
450 *
451 * Same as phy_do_ioctl, but ensures that net_device is running before
452 * handling the ioctl.
453 */
phy_do_ioctl_running(struct net_device * dev,struct ifreq * ifr,int cmd)454 int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
455 {
456 if (!netif_running(dev))
457 return -ENODEV;
458
459 return phy_do_ioctl(dev, ifr, cmd);
460 }
461 EXPORT_SYMBOL(phy_do_ioctl_running);
462
463 /**
464 * phy_queue_state_machine - Trigger the state machine to run soon
465 *
466 * @phydev: the phy_device struct
467 * @jiffies: Run the state machine after these jiffies
468 */
phy_queue_state_machine(struct phy_device * phydev,unsigned long jiffies)469 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
470 {
471 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
472 jiffies);
473 }
474 EXPORT_SYMBOL(phy_queue_state_machine);
475
476 /**
477 * phy_trigger_machine - Trigger the state machine to run now
478 *
479 * @phydev: the phy_device struct
480 */
phy_trigger_machine(struct phy_device * phydev)481 void phy_trigger_machine(struct phy_device *phydev)
482 {
483 phy_queue_state_machine(phydev, 0);
484 }
485 EXPORT_SYMBOL(phy_trigger_machine);
486
phy_abort_cable_test(struct phy_device * phydev)487 static void phy_abort_cable_test(struct phy_device *phydev)
488 {
489 int err;
490
491 ethnl_cable_test_finished(phydev);
492
493 err = phy_init_hw(phydev);
494 if (err)
495 phydev_err(phydev, "Error while aborting cable test");
496 }
497
498 /**
499 * phy_ethtool_get_strings - Get the statistic counter names
500 *
501 * @phydev: the phy_device struct
502 * @data: Where to put the strings
503 */
phy_ethtool_get_strings(struct phy_device * phydev,u8 * data)504 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
505 {
506 if (!phydev->drv)
507 return -EIO;
508
509 mutex_lock(&phydev->lock);
510 phydev->drv->get_strings(phydev, data);
511 mutex_unlock(&phydev->lock);
512
513 return 0;
514 }
515 EXPORT_SYMBOL(phy_ethtool_get_strings);
516
517 /**
518 * phy_ethtool_get_sset_count - Get the number of statistic counters
519 *
520 * @phydev: the phy_device struct
521 */
phy_ethtool_get_sset_count(struct phy_device * phydev)522 int phy_ethtool_get_sset_count(struct phy_device *phydev)
523 {
524 int ret;
525
526 if (!phydev->drv)
527 return -EIO;
528
529 if (phydev->drv->get_sset_count &&
530 phydev->drv->get_strings &&
531 phydev->drv->get_stats) {
532 mutex_lock(&phydev->lock);
533 ret = phydev->drv->get_sset_count(phydev);
534 mutex_unlock(&phydev->lock);
535
536 return ret;
537 }
538
539 return -EOPNOTSUPP;
540 }
541 EXPORT_SYMBOL(phy_ethtool_get_sset_count);
542
543 /**
544 * phy_ethtool_get_stats - Get the statistic counters
545 *
546 * @phydev: the phy_device struct
547 * @stats: What counters to get
548 * @data: Where to store the counters
549 */
phy_ethtool_get_stats(struct phy_device * phydev,struct ethtool_stats * stats,u64 * data)550 int phy_ethtool_get_stats(struct phy_device *phydev,
551 struct ethtool_stats *stats, u64 *data)
552 {
553 if (!phydev->drv)
554 return -EIO;
555
556 mutex_lock(&phydev->lock);
557 phydev->drv->get_stats(phydev, stats, data);
558 mutex_unlock(&phydev->lock);
559
560 return 0;
561 }
562 EXPORT_SYMBOL(phy_ethtool_get_stats);
563
564 /**
565 * phy_start_cable_test - Start a cable test
566 *
567 * @phydev: the phy_device struct
568 * @extack: extack for reporting useful error messages
569 */
phy_start_cable_test(struct phy_device * phydev,struct netlink_ext_ack * extack)570 int phy_start_cable_test(struct phy_device *phydev,
571 struct netlink_ext_ack *extack)
572 {
573 struct net_device *dev = phydev->attached_dev;
574 int err = -ENOMEM;
575
576 if (!(phydev->drv &&
577 phydev->drv->cable_test_start &&
578 phydev->drv->cable_test_get_status)) {
579 NL_SET_ERR_MSG(extack,
580 "PHY driver does not support cable testing");
581 return -EOPNOTSUPP;
582 }
583
584 mutex_lock(&phydev->lock);
585 if (phydev->state == PHY_CABLETEST) {
586 NL_SET_ERR_MSG(extack,
587 "PHY already performing a test");
588 err = -EBUSY;
589 goto out;
590 }
591
592 if (phydev->state < PHY_UP ||
593 phydev->state > PHY_CABLETEST) {
594 NL_SET_ERR_MSG(extack,
595 "PHY not configured. Try setting interface up");
596 err = -EBUSY;
597 goto out;
598 }
599
600 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
601 if (err)
602 goto out;
603
604 /* Mark the carrier down until the test is complete */
605 phy_link_down(phydev);
606
607 netif_testing_on(dev);
608 err = phydev->drv->cable_test_start(phydev);
609 if (err) {
610 netif_testing_off(dev);
611 phy_link_up(phydev);
612 goto out_free;
613 }
614
615 phydev->state = PHY_CABLETEST;
616
617 if (phy_polling_mode(phydev))
618 phy_trigger_machine(phydev);
619
620 mutex_unlock(&phydev->lock);
621
622 return 0;
623
624 out_free:
625 ethnl_cable_test_free(phydev);
626 out:
627 mutex_unlock(&phydev->lock);
628
629 return err;
630 }
631 EXPORT_SYMBOL(phy_start_cable_test);
632
633 /**
634 * phy_start_cable_test_tdr - Start a raw TDR cable test
635 *
636 * @phydev: the phy_device struct
637 * @extack: extack for reporting useful error messages
638 * @config: Configuration of the test to run
639 */
phy_start_cable_test_tdr(struct phy_device * phydev,struct netlink_ext_ack * extack,const struct phy_tdr_config * config)640 int phy_start_cable_test_tdr(struct phy_device *phydev,
641 struct netlink_ext_ack *extack,
642 const struct phy_tdr_config *config)
643 {
644 struct net_device *dev = phydev->attached_dev;
645 int err = -ENOMEM;
646
647 if (!(phydev->drv &&
648 phydev->drv->cable_test_tdr_start &&
649 phydev->drv->cable_test_get_status)) {
650 NL_SET_ERR_MSG(extack,
651 "PHY driver does not support cable test TDR");
652 return -EOPNOTSUPP;
653 }
654
655 mutex_lock(&phydev->lock);
656 if (phydev->state == PHY_CABLETEST) {
657 NL_SET_ERR_MSG(extack,
658 "PHY already performing a test");
659 err = -EBUSY;
660 goto out;
661 }
662
663 if (phydev->state < PHY_UP ||
664 phydev->state > PHY_CABLETEST) {
665 NL_SET_ERR_MSG(extack,
666 "PHY not configured. Try setting interface up");
667 err = -EBUSY;
668 goto out;
669 }
670
671 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
672 if (err)
673 goto out;
674
675 /* Mark the carrier down until the test is complete */
676 phy_link_down(phydev);
677
678 netif_testing_on(dev);
679 err = phydev->drv->cable_test_tdr_start(phydev, config);
680 if (err) {
681 netif_testing_off(dev);
682 phy_link_up(phydev);
683 goto out_free;
684 }
685
686 phydev->state = PHY_CABLETEST;
687
688 if (phy_polling_mode(phydev))
689 phy_trigger_machine(phydev);
690
691 mutex_unlock(&phydev->lock);
692
693 return 0;
694
695 out_free:
696 ethnl_cable_test_free(phydev);
697 out:
698 mutex_unlock(&phydev->lock);
699
700 return err;
701 }
702 EXPORT_SYMBOL(phy_start_cable_test_tdr);
703
phy_config_aneg(struct phy_device * phydev)704 int phy_config_aneg(struct phy_device *phydev)
705 {
706 if (phydev->drv->config_aneg)
707 return phydev->drv->config_aneg(phydev);
708
709 /* Clause 45 PHYs that don't implement Clause 22 registers are not
710 * allowed to call genphy_config_aneg()
711 */
712 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
713 return genphy_c45_config_aneg(phydev);
714
715 return genphy_config_aneg(phydev);
716 }
717 EXPORT_SYMBOL(phy_config_aneg);
718
719 /**
720 * phy_check_link_status - check link status and set state accordingly
721 * @phydev: the phy_device struct
722 *
723 * Description: Check for link and whether autoneg was triggered / is running
724 * and set state accordingly
725 */
phy_check_link_status(struct phy_device * phydev)726 static int phy_check_link_status(struct phy_device *phydev)
727 {
728 int err;
729
730 lockdep_assert_held(&phydev->lock);
731
732 /* Keep previous state if loopback is enabled because some PHYs
733 * report that Link is Down when loopback is enabled.
734 */
735 if (phydev->loopback_enabled)
736 return 0;
737
738 err = phy_read_status(phydev);
739 if (err)
740 return err;
741
742 if (phydev->link && phydev->state != PHY_RUNNING) {
743 phy_check_downshift(phydev);
744 phydev->state = PHY_RUNNING;
745 phy_link_up(phydev);
746 } else if (!phydev->link && phydev->state != PHY_NOLINK) {
747 phydev->state = PHY_NOLINK;
748 phy_link_down(phydev);
749 }
750
751 return 0;
752 }
753
754 /**
755 * phy_start_aneg - start auto-negotiation for this PHY device
756 * @phydev: the phy_device struct
757 *
758 * Description: Sanitizes the settings (if we're not autonegotiating
759 * them), and then calls the driver's config_aneg function.
760 * If the PHYCONTROL Layer is operating, we change the state to
761 * reflect the beginning of Auto-negotiation or forcing.
762 */
phy_start_aneg(struct phy_device * phydev)763 int phy_start_aneg(struct phy_device *phydev)
764 {
765 int err;
766
767 if (!phydev->drv)
768 return -EIO;
769
770 mutex_lock(&phydev->lock);
771
772 if (AUTONEG_DISABLE == phydev->autoneg)
773 phy_sanitize_settings(phydev);
774
775 err = phy_config_aneg(phydev);
776 if (err < 0)
777 goto out_unlock;
778
779 if (phy_is_started(phydev))
780 err = phy_check_link_status(phydev);
781 out_unlock:
782 mutex_unlock(&phydev->lock);
783
784 return err;
785 }
786 EXPORT_SYMBOL(phy_start_aneg);
787
phy_poll_aneg_done(struct phy_device * phydev)788 static int phy_poll_aneg_done(struct phy_device *phydev)
789 {
790 unsigned int retries = 100;
791 int ret;
792
793 do {
794 msleep(100);
795 ret = phy_aneg_done(phydev);
796 } while (!ret && --retries);
797
798 if (!ret)
799 return -ETIMEDOUT;
800
801 return ret < 0 ? ret : 0;
802 }
803
804 /**
805 * phy_speed_down - set speed to lowest speed supported by both link partners
806 * @phydev: the phy_device struct
807 * @sync: perform action synchronously
808 *
809 * Description: Typically used to save energy when waiting for a WoL packet
810 *
811 * WARNING: Setting sync to false may cause the system being unable to suspend
812 * in case the PHY generates an interrupt when finishing the autonegotiation.
813 * This interrupt may wake up the system immediately after suspend.
814 * Therefore use sync = false only if you're sure it's safe with the respective
815 * network chip.
816 */
phy_speed_down(struct phy_device * phydev,bool sync)817 int phy_speed_down(struct phy_device *phydev, bool sync)
818 {
819 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
820 int ret;
821
822 if (phydev->autoneg != AUTONEG_ENABLE)
823 return 0;
824
825 linkmode_copy(adv_tmp, phydev->advertising);
826
827 ret = phy_speed_down_core(phydev);
828 if (ret)
829 return ret;
830
831 linkmode_copy(phydev->adv_old, adv_tmp);
832
833 if (linkmode_equal(phydev->advertising, adv_tmp))
834 return 0;
835
836 ret = phy_config_aneg(phydev);
837 if (ret)
838 return ret;
839
840 return sync ? phy_poll_aneg_done(phydev) : 0;
841 }
842 EXPORT_SYMBOL_GPL(phy_speed_down);
843
844 /**
845 * phy_speed_up - (re)set advertised speeds to all supported speeds
846 * @phydev: the phy_device struct
847 *
848 * Description: Used to revert the effect of phy_speed_down
849 */
phy_speed_up(struct phy_device * phydev)850 int phy_speed_up(struct phy_device *phydev)
851 {
852 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
853
854 if (phydev->autoneg != AUTONEG_ENABLE)
855 return 0;
856
857 if (linkmode_empty(phydev->adv_old))
858 return 0;
859
860 linkmode_copy(adv_tmp, phydev->advertising);
861 linkmode_copy(phydev->advertising, phydev->adv_old);
862 linkmode_zero(phydev->adv_old);
863
864 if (linkmode_equal(phydev->advertising, adv_tmp))
865 return 0;
866
867 return phy_config_aneg(phydev);
868 }
869 EXPORT_SYMBOL_GPL(phy_speed_up);
870
871 /**
872 * phy_start_machine - start PHY state machine tracking
873 * @phydev: the phy_device struct
874 *
875 * Description: The PHY infrastructure can run a state machine
876 * which tracks whether the PHY is starting up, negotiating,
877 * etc. This function starts the delayed workqueue which tracks
878 * the state of the PHY. If you want to maintain your own state machine,
879 * do not call this function.
880 */
phy_start_machine(struct phy_device * phydev)881 void phy_start_machine(struct phy_device *phydev)
882 {
883 phy_trigger_machine(phydev);
884 }
885 EXPORT_SYMBOL_GPL(phy_start_machine);
886
887 /**
888 * phy_stop_machine - stop the PHY state machine tracking
889 * @phydev: target phy_device struct
890 *
891 * Description: Stops the state machine delayed workqueue, sets the
892 * state to UP (unless it wasn't up yet). This function must be
893 * called BEFORE phy_detach.
894 */
phy_stop_machine(struct phy_device * phydev)895 void phy_stop_machine(struct phy_device *phydev)
896 {
897 cancel_delayed_work_sync(&phydev->state_queue);
898
899 mutex_lock(&phydev->lock);
900 if (phy_is_started(phydev))
901 phydev->state = PHY_UP;
902 mutex_unlock(&phydev->lock);
903 }
904
905 /**
906 * phy_error - enter HALTED state for this PHY device
907 * @phydev: target phy_device struct
908 *
909 * Moves the PHY to the HALTED state in response to a read
910 * or write error, and tells the controller the link is down.
911 * Must not be called from interrupt context, or while the
912 * phydev->lock is held.
913 */
phy_error(struct phy_device * phydev)914 void phy_error(struct phy_device *phydev)
915 {
916 WARN_ON(1);
917
918 mutex_lock(&phydev->lock);
919 phydev->state = PHY_HALTED;
920 mutex_unlock(&phydev->lock);
921
922 phy_trigger_machine(phydev);
923 }
924 EXPORT_SYMBOL(phy_error);
925
926 /**
927 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
928 * @phydev: target phy_device struct
929 */
phy_disable_interrupts(struct phy_device * phydev)930 int phy_disable_interrupts(struct phy_device *phydev)
931 {
932 /* Disable PHY interrupts */
933 return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
934 }
935
936 /**
937 * phy_interrupt - PHY interrupt handler
938 * @irq: interrupt line
939 * @phy_dat: phy_device pointer
940 *
941 * Description: Handle PHY interrupt
942 */
phy_interrupt(int irq,void * phy_dat)943 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
944 {
945 struct phy_device *phydev = phy_dat;
946 struct phy_driver *drv = phydev->drv;
947
948 return drv->handle_interrupt(phydev);
949 }
950
951 /**
952 * phy_enable_interrupts - Enable the interrupts from the PHY side
953 * @phydev: target phy_device struct
954 */
phy_enable_interrupts(struct phy_device * phydev)955 static int phy_enable_interrupts(struct phy_device *phydev)
956 {
957 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
958 }
959
960 /**
961 * phy_request_interrupt - request and enable interrupt for a PHY device
962 * @phydev: target phy_device struct
963 *
964 * Description: Request and enable the interrupt for the given PHY.
965 * If this fails, then we set irq to PHY_POLL.
966 * This should only be called with a valid IRQ number.
967 */
phy_request_interrupt(struct phy_device * phydev)968 void phy_request_interrupt(struct phy_device *phydev)
969 {
970 int err;
971
972 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
973 IRQF_ONESHOT | IRQF_SHARED,
974 phydev_name(phydev), phydev);
975 if (err) {
976 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
977 err, phydev->irq);
978 phydev->irq = PHY_POLL;
979 } else {
980 if (phy_enable_interrupts(phydev)) {
981 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
982 phy_free_interrupt(phydev);
983 phydev->irq = PHY_POLL;
984 }
985 }
986 }
987 EXPORT_SYMBOL(phy_request_interrupt);
988
989 /**
990 * phy_free_interrupt - disable and free interrupt for a PHY device
991 * @phydev: target phy_device struct
992 *
993 * Description: Disable and free the interrupt for the given PHY.
994 * This should only be called with a valid IRQ number.
995 */
phy_free_interrupt(struct phy_device * phydev)996 void phy_free_interrupt(struct phy_device *phydev)
997 {
998 phy_disable_interrupts(phydev);
999 free_irq(phydev->irq, phydev);
1000 }
1001 EXPORT_SYMBOL(phy_free_interrupt);
1002
1003 /**
1004 * phy_stop - Bring down the PHY link, and stop checking the status
1005 * @phydev: target phy_device struct
1006 */
phy_stop(struct phy_device * phydev)1007 void phy_stop(struct phy_device *phydev)
1008 {
1009 struct net_device *dev = phydev->attached_dev;
1010
1011 if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1012 WARN(1, "called from state %s\n",
1013 phy_state_to_str(phydev->state));
1014 return;
1015 }
1016
1017 mutex_lock(&phydev->lock);
1018
1019 if (phydev->state == PHY_CABLETEST) {
1020 phy_abort_cable_test(phydev);
1021 netif_testing_off(dev);
1022 }
1023
1024 if (phydev->sfp_bus)
1025 sfp_upstream_stop(phydev->sfp_bus);
1026
1027 phydev->state = PHY_HALTED;
1028
1029 mutex_unlock(&phydev->lock);
1030
1031 phy_state_machine(&phydev->state_queue.work);
1032 phy_stop_machine(phydev);
1033
1034 /* Cannot call flush_scheduled_work() here as desired because
1035 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1036 * will not reenable interrupts.
1037 */
1038 }
1039 EXPORT_SYMBOL(phy_stop);
1040
1041 /**
1042 * phy_start - start or restart a PHY device
1043 * @phydev: target phy_device struct
1044 *
1045 * Description: Indicates the attached device's readiness to
1046 * handle PHY-related work. Used during startup to start the
1047 * PHY, and after a call to phy_stop() to resume operation.
1048 * Also used to indicate the MDIO bus has cleared an error
1049 * condition.
1050 */
phy_start(struct phy_device * phydev)1051 void phy_start(struct phy_device *phydev)
1052 {
1053 mutex_lock(&phydev->lock);
1054
1055 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1056 WARN(1, "called from state %s\n",
1057 phy_state_to_str(phydev->state));
1058 goto out;
1059 }
1060
1061 if (phydev->sfp_bus)
1062 sfp_upstream_start(phydev->sfp_bus);
1063
1064 /* if phy was suspended, bring the physical link up again */
1065 __phy_resume(phydev);
1066
1067 phydev->state = PHY_UP;
1068
1069 phy_start_machine(phydev);
1070 out:
1071 mutex_unlock(&phydev->lock);
1072 }
1073 EXPORT_SYMBOL(phy_start);
1074
1075 /**
1076 * phy_state_machine - Handle the state machine
1077 * @work: work_struct that describes the work to be done
1078 */
phy_state_machine(struct work_struct * work)1079 void phy_state_machine(struct work_struct *work)
1080 {
1081 struct delayed_work *dwork = to_delayed_work(work);
1082 struct phy_device *phydev =
1083 container_of(dwork, struct phy_device, state_queue);
1084 struct net_device *dev = phydev->attached_dev;
1085 bool needs_aneg = false, do_suspend = false;
1086 enum phy_state old_state;
1087 bool finished = false;
1088 int err = 0;
1089
1090 mutex_lock(&phydev->lock);
1091
1092 old_state = phydev->state;
1093
1094 switch (phydev->state) {
1095 case PHY_DOWN:
1096 case PHY_READY:
1097 break;
1098 case PHY_UP:
1099 needs_aneg = true;
1100
1101 break;
1102 case PHY_NOLINK:
1103 case PHY_RUNNING:
1104 err = phy_check_link_status(phydev);
1105 break;
1106 case PHY_CABLETEST:
1107 err = phydev->drv->cable_test_get_status(phydev, &finished);
1108 if (err) {
1109 phy_abort_cable_test(phydev);
1110 netif_testing_off(dev);
1111 needs_aneg = true;
1112 phydev->state = PHY_UP;
1113 break;
1114 }
1115
1116 if (finished) {
1117 ethnl_cable_test_finished(phydev);
1118 netif_testing_off(dev);
1119 needs_aneg = true;
1120 phydev->state = PHY_UP;
1121 }
1122 break;
1123 case PHY_HALTED:
1124 if (phydev->link) {
1125 phydev->link = 0;
1126 phy_link_down(phydev);
1127 }
1128 do_suspend = true;
1129 break;
1130 }
1131
1132 mutex_unlock(&phydev->lock);
1133
1134 if (needs_aneg)
1135 err = phy_start_aneg(phydev);
1136 else if (do_suspend)
1137 phy_suspend(phydev);
1138
1139 if (err < 0)
1140 phy_error(phydev);
1141
1142 if (old_state != phydev->state) {
1143 phydev_dbg(phydev, "PHY state change %s -> %s\n",
1144 phy_state_to_str(old_state),
1145 phy_state_to_str(phydev->state));
1146 if (phydev->drv && phydev->drv->link_change_notify)
1147 phydev->drv->link_change_notify(phydev);
1148 }
1149
1150 /* Only re-schedule a PHY state machine change if we are polling the
1151 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving
1152 * between states from phy_mac_interrupt().
1153 *
1154 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1155 * state machine would be pointless and possibly error prone when
1156 * called from phy_disconnect() synchronously.
1157 */
1158 mutex_lock(&phydev->lock);
1159 if (phy_polling_mode(phydev) && phy_is_started(phydev))
1160 phy_queue_state_machine(phydev, PHY_STATE_TIME);
1161 mutex_unlock(&phydev->lock);
1162 }
1163
1164 /**
1165 * phy_mac_interrupt - MAC says the link has changed
1166 * @phydev: phy_device struct with changed link
1167 *
1168 * The MAC layer is able to indicate there has been a change in the PHY link
1169 * status. Trigger the state machine and work a work queue.
1170 */
phy_mac_interrupt(struct phy_device * phydev)1171 void phy_mac_interrupt(struct phy_device *phydev)
1172 {
1173 /* Trigger a state machine change */
1174 phy_trigger_machine(phydev);
1175 }
1176 EXPORT_SYMBOL(phy_mac_interrupt);
1177
mmd_eee_adv_to_linkmode(unsigned long * advertising,u16 eee_adv)1178 static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
1179 {
1180 linkmode_zero(advertising);
1181
1182 if (eee_adv & MDIO_EEE_100TX)
1183 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1184 advertising);
1185 if (eee_adv & MDIO_EEE_1000T)
1186 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1187 advertising);
1188 if (eee_adv & MDIO_EEE_10GT)
1189 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1190 advertising);
1191 if (eee_adv & MDIO_EEE_1000KX)
1192 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
1193 advertising);
1194 if (eee_adv & MDIO_EEE_10GKX4)
1195 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
1196 advertising);
1197 if (eee_adv & MDIO_EEE_10GKR)
1198 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
1199 advertising);
1200 }
1201
1202 /**
1203 * phy_init_eee - init and check the EEE feature
1204 * @phydev: target phy_device struct
1205 * @clk_stop_enable: PHY may stop the clock during LPI
1206 *
1207 * Description: it checks if the Energy-Efficient Ethernet (EEE)
1208 * is supported by looking at the MMD registers 3.20 and 7.60/61
1209 * and it programs the MMD register 3.0 setting the "Clock stop enable"
1210 * bit if required.
1211 */
phy_init_eee(struct phy_device * phydev,bool clk_stop_enable)1212 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1213 {
1214 if (!phydev->drv)
1215 return -EIO;
1216
1217 /* According to 802.3az,the EEE is supported only in full duplex-mode.
1218 */
1219 if (phydev->duplex == DUPLEX_FULL) {
1220 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
1221 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
1222 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
1223 int eee_lp, eee_cap, eee_adv;
1224 int status;
1225 u32 cap;
1226
1227 /* Read phy status to properly get the right settings */
1228 status = phy_read_status(phydev);
1229 if (status)
1230 return status;
1231
1232 /* First check if the EEE ability is supported */
1233 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1234 if (eee_cap <= 0)
1235 goto eee_exit_err;
1236
1237 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1238 if (!cap)
1239 goto eee_exit_err;
1240
1241 /* Check which link settings negotiated and verify it in
1242 * the EEE advertising registers.
1243 */
1244 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1245 if (eee_lp <= 0)
1246 goto eee_exit_err;
1247
1248 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1249 if (eee_adv <= 0)
1250 goto eee_exit_err;
1251
1252 mmd_eee_adv_to_linkmode(adv, eee_adv);
1253 mmd_eee_adv_to_linkmode(lp, eee_lp);
1254 linkmode_and(common, adv, lp);
1255
1256 if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1257 goto eee_exit_err;
1258
1259 if (clk_stop_enable)
1260 /* Configure the PHY to stop receiving xMII
1261 * clock while it is signaling LPI.
1262 */
1263 phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1264 MDIO_PCS_CTRL1_CLKSTOP_EN);
1265
1266 return 0; /* EEE supported */
1267 }
1268 eee_exit_err:
1269 return -EPROTONOSUPPORT;
1270 }
1271 EXPORT_SYMBOL(phy_init_eee);
1272
1273 /**
1274 * phy_get_eee_err - report the EEE wake error count
1275 * @phydev: target phy_device struct
1276 *
1277 * Description: it is to report the number of time where the PHY
1278 * failed to complete its normal wake sequence.
1279 */
phy_get_eee_err(struct phy_device * phydev)1280 int phy_get_eee_err(struct phy_device *phydev)
1281 {
1282 if (!phydev->drv)
1283 return -EIO;
1284
1285 return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1286 }
1287 EXPORT_SYMBOL(phy_get_eee_err);
1288
1289 /**
1290 * phy_ethtool_get_eee - get EEE supported and status
1291 * @phydev: target phy_device struct
1292 * @data: ethtool_eee data
1293 *
1294 * Description: it reportes the Supported/Advertisement/LP Advertisement
1295 * capabilities.
1296 */
phy_ethtool_get_eee(struct phy_device * phydev,struct ethtool_eee * data)1297 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1298 {
1299 int val;
1300
1301 if (!phydev->drv)
1302 return -EIO;
1303
1304 /* Get Supported EEE */
1305 val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1306 if (val < 0)
1307 return val;
1308 data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1309
1310 /* Get advertisement EEE */
1311 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1312 if (val < 0)
1313 return val;
1314 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1315 data->eee_enabled = !!data->advertised;
1316
1317 /* Get LP advertisement EEE */
1318 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1319 if (val < 0)
1320 return val;
1321 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1322
1323 data->eee_active = !!(data->advertised & data->lp_advertised);
1324
1325 return 0;
1326 }
1327 EXPORT_SYMBOL(phy_ethtool_get_eee);
1328
1329 /**
1330 * phy_ethtool_set_eee - set EEE supported and status
1331 * @phydev: target phy_device struct
1332 * @data: ethtool_eee data
1333 *
1334 * Description: it is to program the Advertisement EEE register.
1335 */
phy_ethtool_set_eee(struct phy_device * phydev,struct ethtool_eee * data)1336 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1337 {
1338 int cap, old_adv, adv = 0, ret;
1339
1340 if (!phydev->drv)
1341 return -EIO;
1342
1343 /* Get Supported EEE */
1344 cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1345 if (cap < 0)
1346 return cap;
1347
1348 old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1349 if (old_adv < 0)
1350 return old_adv;
1351
1352 if (data->eee_enabled) {
1353 adv = !data->advertised ? cap :
1354 ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1355 /* Mask prohibited EEE modes */
1356 adv &= ~phydev->eee_broken_modes;
1357 }
1358
1359 if (old_adv != adv) {
1360 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1361 if (ret < 0)
1362 return ret;
1363
1364 /* Restart autonegotiation so the new modes get sent to the
1365 * link partner.
1366 */
1367 if (phydev->autoneg == AUTONEG_ENABLE) {
1368 ret = phy_restart_aneg(phydev);
1369 if (ret < 0)
1370 return ret;
1371 }
1372 }
1373
1374 return 0;
1375 }
1376 EXPORT_SYMBOL(phy_ethtool_set_eee);
1377
1378 /**
1379 * phy_ethtool_set_wol - Configure Wake On LAN
1380 *
1381 * @phydev: target phy_device struct
1382 * @wol: Configuration requested
1383 */
phy_ethtool_set_wol(struct phy_device * phydev,struct ethtool_wolinfo * wol)1384 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1385 {
1386 if (phydev->drv && phydev->drv->set_wol)
1387 return phydev->drv->set_wol(phydev, wol);
1388
1389 return -EOPNOTSUPP;
1390 }
1391 EXPORT_SYMBOL(phy_ethtool_set_wol);
1392
1393 /**
1394 * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1395 *
1396 * @phydev: target phy_device struct
1397 * @wol: Store the current configuration here
1398 */
phy_ethtool_get_wol(struct phy_device * phydev,struct ethtool_wolinfo * wol)1399 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1400 {
1401 if (phydev->drv && phydev->drv->get_wol)
1402 phydev->drv->get_wol(phydev, wol);
1403 }
1404 EXPORT_SYMBOL(phy_ethtool_get_wol);
1405
phy_ethtool_get_link_ksettings(struct net_device * ndev,struct ethtool_link_ksettings * cmd)1406 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1407 struct ethtool_link_ksettings *cmd)
1408 {
1409 struct phy_device *phydev = ndev->phydev;
1410
1411 if (!phydev)
1412 return -ENODEV;
1413
1414 phy_ethtool_ksettings_get(phydev, cmd);
1415
1416 return 0;
1417 }
1418 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1419
phy_ethtool_set_link_ksettings(struct net_device * ndev,const struct ethtool_link_ksettings * cmd)1420 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1421 const struct ethtool_link_ksettings *cmd)
1422 {
1423 struct phy_device *phydev = ndev->phydev;
1424
1425 if (!phydev)
1426 return -ENODEV;
1427
1428 return phy_ethtool_ksettings_set(phydev, cmd);
1429 }
1430 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1431
1432 /**
1433 * phy_ethtool_nway_reset - Restart auto negotiation
1434 * @ndev: Network device to restart autoneg for
1435 */
phy_ethtool_nway_reset(struct net_device * ndev)1436 int phy_ethtool_nway_reset(struct net_device *ndev)
1437 {
1438 struct phy_device *phydev = ndev->phydev;
1439
1440 if (!phydev)
1441 return -ENODEV;
1442
1443 if (!phydev->drv)
1444 return -EIO;
1445
1446 return phy_restart_aneg(phydev);
1447 }
1448 EXPORT_SYMBOL(phy_ethtool_nway_reset);
1449