cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

phy.c (38171B)


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