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	PHY_STATE_STR(ERROR)
  56	}
  57
  58	return NULL;
  59}
  60
  61static void phy_process_state_change(struct phy_device *phydev,
  62				     enum phy_state old_state)
  63{
  64	if (old_state != phydev->state) {
  65		phydev_dbg(phydev, "PHY state change %s -> %s\n",
  66			   phy_state_to_str(old_state),
  67			   phy_state_to_str(phydev->state));
  68		if (phydev->drv && phydev->drv->link_change_notify)
  69			phydev->drv->link_change_notify(phydev);
  70	}
  71}
  72
  73static void phy_link_up(struct phy_device *phydev)
  74{
  75	phydev->phy_link_change(phydev, true);
  76	phy_led_trigger_change_speed(phydev);
  77}
  78
  79static void phy_link_down(struct phy_device *phydev)
  80{
  81	phydev->phy_link_change(phydev, false);
  82	phy_led_trigger_change_speed(phydev);
  83	WRITE_ONCE(phydev->link_down_events, phydev->link_down_events + 1);
  84}
  85
  86static const char *phy_pause_str(struct phy_device *phydev)
  87{
  88	bool local_pause, local_asym_pause;
  89
  90	if (phydev->autoneg == AUTONEG_DISABLE)
  91		goto no_pause;
  92
  93	local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
  94					phydev->advertising);
  95	local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
  96					     phydev->advertising);
  97
  98	if (local_pause && phydev->pause)
  99		return "rx/tx";
 100
 101	if (local_asym_pause && phydev->asym_pause) {
 102		if (local_pause)
 103			return "rx";
 104		if (phydev->pause)
 105			return "tx";
 106	}
 107
 108no_pause:
 109	return "off";
 110}
 111
 112/**
 113 * phy_print_status - Convenience function to print out the current phy status
 114 * @phydev: the phy_device struct
 115 */
 116void phy_print_status(struct phy_device *phydev)
 117{
 118	if (phydev->link) {
 119		netdev_info(phydev->attached_dev,
 120			"Link is Up - %s/%s %s- flow control %s\n",
 121			phy_speed_to_str(phydev->speed),
 122			phy_duplex_to_str(phydev->duplex),
 123			phydev->downshifted_rate ? "(downshifted) " : "",
 124			phy_pause_str(phydev));
 125	} else	{
 126		netdev_info(phydev->attached_dev, "Link is Down\n");
 127	}
 128}
 129EXPORT_SYMBOL(phy_print_status);
 130
 131/**
 132 * phy_get_rate_matching - determine if rate matching is supported
 133 * @phydev: The phy device to return rate matching for
 134 * @iface: The interface mode to use
 135 *
 136 * This determines the type of rate matching (if any) that @phy supports
 137 * using @iface. @iface may be %PHY_INTERFACE_MODE_NA to determine if any
 138 * interface supports rate matching.
 139 *
 140 * Return: The type of rate matching @phy supports for @iface, or
 141 *         %RATE_MATCH_NONE.
 142 */
 143int phy_get_rate_matching(struct phy_device *phydev,
 144			  phy_interface_t iface)
 145{
 146	int ret = RATE_MATCH_NONE;
 147
 148	if (phydev->drv->get_rate_matching) {
 149		mutex_lock(&phydev->lock);
 150		ret = phydev->drv->get_rate_matching(phydev, iface);
 151		mutex_unlock(&phydev->lock);
 152	}
 153
 154	return ret;
 155}
 156EXPORT_SYMBOL_GPL(phy_get_rate_matching);
 157
 158/**
 159 * phy_config_interrupt - configure the PHY device for the requested interrupts
 160 * @phydev: the phy_device struct
 161 * @interrupts: interrupt flags to configure for this @phydev
 162 *
 163 * Returns 0 on success or < 0 on error.
 164 */
 165static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
 166{
 167	phydev->interrupts = interrupts ? 1 : 0;
 168	if (phydev->drv->config_intr)
 169		return phydev->drv->config_intr(phydev);
 170
 171	return 0;
 172}
 173
 174/**
 175 * phy_restart_aneg - restart auto-negotiation
 176 * @phydev: target phy_device struct
 177 *
 178 * Restart the autonegotiation on @phydev.  Returns >= 0 on success or
 179 * negative errno on error.
 180 */
 181int phy_restart_aneg(struct phy_device *phydev)
 182{
 183	int ret;
 184
 185	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
 186		ret = genphy_c45_restart_aneg(phydev);
 187	else
 188		ret = genphy_restart_aneg(phydev);
 189
 190	return ret;
 191}
 192EXPORT_SYMBOL_GPL(phy_restart_aneg);
 193
 194/**
 195 * phy_aneg_done - return auto-negotiation status
 196 * @phydev: target phy_device struct
 197 *
 198 * Description: Return the auto-negotiation status from this @phydev
 199 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
 200 * is still pending.
 201 */
 202int phy_aneg_done(struct phy_device *phydev)
 203{
 204	if (phydev->drv && phydev->drv->aneg_done)
 205		return phydev->drv->aneg_done(phydev);
 206	else if (phydev->is_c45)
 207		return genphy_c45_aneg_done(phydev);
 208	else
 209		return genphy_aneg_done(phydev);
 210}
 211EXPORT_SYMBOL(phy_aneg_done);
 212
 213/**
 214 * phy_find_valid - find a PHY setting that matches the requested parameters
 215 * @speed: desired speed
 216 * @duplex: desired duplex
 217 * @supported: mask of supported link modes
 218 *
 219 * Locate a supported phy setting that is, in priority order:
 220 * - an exact match for the specified speed and duplex mode
 221 * - a match for the specified speed, or slower speed
 222 * - the slowest supported speed
 223 * Returns the matched phy_setting entry, or %NULL if no supported phy
 224 * settings were found.
 225 */
 226static const struct phy_setting *
 227phy_find_valid(int speed, int duplex, unsigned long *supported)
 228{
 229	return phy_lookup_setting(speed, duplex, supported, false);
 230}
 231
 232/**
 233 * phy_supported_speeds - return all speeds currently supported by a phy device
 234 * @phy: The phy device to return supported speeds of.
 235 * @speeds: buffer to store supported speeds in.
 236 * @size:   size of speeds buffer.
 237 *
 238 * Description: Returns the number of supported speeds, and fills the speeds
 239 * buffer with the supported speeds. If speeds buffer is too small to contain
 240 * all currently supported speeds, will return as many speeds as can fit.
 241 */
 242unsigned int phy_supported_speeds(struct phy_device *phy,
 243				  unsigned int *speeds,
 244				  unsigned int size)
 245{
 246	return phy_speeds(speeds, size, phy->supported);
 247}
 248
 249/**
 250 * phy_check_valid - check if there is a valid PHY setting which matches
 251 *		     speed, duplex, and feature mask
 252 * @speed: speed to match
 253 * @duplex: duplex to match
 254 * @features: A mask of the valid settings
 255 *
 256 * Description: Returns true if there is a valid setting, false otherwise.
 257 */
 258bool phy_check_valid(int speed, int duplex, unsigned long *features)
 
 259{
 260	return !!phy_lookup_setting(speed, duplex, features, true);
 261}
 262EXPORT_SYMBOL(phy_check_valid);
 263
 264/**
 265 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
 266 * @phydev: the target phy_device struct
 267 *
 268 * Description: Make sure the PHY is set to supported speeds and
 269 *   duplexes.  Drop down by one in this order:  1000/FULL,
 270 *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
 271 */
 272static void phy_sanitize_settings(struct phy_device *phydev)
 273{
 274	const struct phy_setting *setting;
 275
 276	setting = phy_find_valid(phydev->speed, phydev->duplex,
 277				 phydev->supported);
 278	if (setting) {
 279		phydev->speed = setting->speed;
 280		phydev->duplex = setting->duplex;
 281	} else {
 282		/* We failed to find anything (no supported speeds?) */
 283		phydev->speed = SPEED_UNKNOWN;
 284		phydev->duplex = DUPLEX_UNKNOWN;
 285	}
 286}
 287
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 288void phy_ethtool_ksettings_get(struct phy_device *phydev,
 289			       struct ethtool_link_ksettings *cmd)
 290{
 291	mutex_lock(&phydev->lock);
 292	linkmode_copy(cmd->link_modes.supported, phydev->supported);
 293	linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
 294	linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
 295
 296	cmd->base.speed = phydev->speed;
 297	cmd->base.duplex = phydev->duplex;
 298	cmd->base.master_slave_cfg = phydev->master_slave_get;
 299	cmd->base.master_slave_state = phydev->master_slave_state;
 300	cmd->base.rate_matching = phydev->rate_matching;
 301	if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
 302		cmd->base.port = PORT_BNC;
 303	else
 304		cmd->base.port = phydev->port;
 305	cmd->base.transceiver = phy_is_internal(phydev) ?
 306				XCVR_INTERNAL : XCVR_EXTERNAL;
 307	cmd->base.phy_address = phydev->mdio.addr;
 308	cmd->base.autoneg = phydev->autoneg;
 309	cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
 310	cmd->base.eth_tp_mdix = phydev->mdix;
 311	mutex_unlock(&phydev->lock);
 312}
 313EXPORT_SYMBOL(phy_ethtool_ksettings_get);
 314
 315/**
 316 * phy_mii_ioctl - generic PHY MII ioctl interface
 317 * @phydev: the phy_device struct
 318 * @ifr: &struct ifreq for socket ioctl's
 319 * @cmd: ioctl cmd to execute
 320 *
 321 * Note that this function is currently incompatible with the
 322 * PHYCONTROL layer.  It changes registers without regard to
 323 * current state.  Use at own risk.
 324 */
 325int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
 326{
 327	struct mii_ioctl_data *mii_data = if_mii(ifr);
 328	struct kernel_hwtstamp_config kernel_cfg;
 329	struct netlink_ext_ack extack = {};
 330	u16 val = mii_data->val_in;
 331	bool change_autoneg = false;
 332	struct hwtstamp_config cfg;
 333	int prtad, devad;
 334	int ret;
 335
 336	switch (cmd) {
 337	case SIOCGMIIPHY:
 338		mii_data->phy_id = phydev->mdio.addr;
 339		fallthrough;
 340
 341	case SIOCGMIIREG:
 342		if (mdio_phy_id_is_c45(mii_data->phy_id)) {
 343			prtad = mdio_phy_id_prtad(mii_data->phy_id);
 344			devad = mdio_phy_id_devad(mii_data->phy_id);
 345			ret = mdiobus_c45_read(phydev->mdio.bus, prtad, devad,
 346					       mii_data->reg_num);
 347
 348		} else {
 349			ret = mdiobus_read(phydev->mdio.bus, mii_data->phy_id,
 350					   mii_data->reg_num);
 351		}
 352
 353		if (ret < 0)
 354			return ret;
 355
 356		mii_data->val_out = ret;
 357
 358		return 0;
 359
 360	case SIOCSMIIREG:
 361		if (mdio_phy_id_is_c45(mii_data->phy_id)) {
 362			prtad = mdio_phy_id_prtad(mii_data->phy_id);
 363			devad = mdio_phy_id_devad(mii_data->phy_id);
 
 364		} else {
 365			prtad = mii_data->phy_id;
 366			devad = mii_data->reg_num;
 367		}
 368		if (prtad == phydev->mdio.addr) {
 369			switch (devad) {
 370			case MII_BMCR:
 371				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
 372					if (phydev->autoneg == AUTONEG_ENABLE)
 373						change_autoneg = true;
 374					phydev->autoneg = AUTONEG_DISABLE;
 375					if (val & BMCR_FULLDPLX)
 376						phydev->duplex = DUPLEX_FULL;
 377					else
 378						phydev->duplex = DUPLEX_HALF;
 379					if (val & BMCR_SPEED1000)
 380						phydev->speed = SPEED_1000;
 381					else if (val & BMCR_SPEED100)
 382						phydev->speed = SPEED_100;
 383					else phydev->speed = SPEED_10;
 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		if (mdio_phy_id_is_c45(mii_data->phy_id))
 407			mdiobus_c45_write(phydev->mdio.bus, prtad, devad,
 408					  mii_data->reg_num, val);
 409		else
 410			mdiobus_write(phydev->mdio.bus, prtad, devad, val);
 411
 412		if (prtad == phydev->mdio.addr &&
 413		    devad == MII_BMCR &&
 414		    val & BMCR_RESET)
 415			return phy_init_hw(phydev);
 416
 417		if (change_autoneg)
 418			return phy_start_aneg(phydev);
 419
 420		return 0;
 421
 422	case SIOCSHWTSTAMP:
 423		if (phydev->mii_ts && phydev->mii_ts->hwtstamp) {
 424			if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
 425				return -EFAULT;
 426
 427			hwtstamp_config_to_kernel(&kernel_cfg, &cfg);
 428			ret = phydev->mii_ts->hwtstamp(phydev->mii_ts, &kernel_cfg, &extack);
 429			if (ret)
 430				return ret;
 431
 432			hwtstamp_config_from_kernel(&cfg, &kernel_cfg);
 433			if (copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)))
 434				return -EFAULT;
 435
 436			return 0;
 437		}
 438		fallthrough;
 439
 440	default:
 441		return -EOPNOTSUPP;
 442	}
 443}
 444EXPORT_SYMBOL(phy_mii_ioctl);
 445
 446/**
 447 * phy_do_ioctl - generic ndo_eth_ioctl implementation
 448 * @dev: the net_device struct
 449 * @ifr: &struct ifreq for socket ioctl's
 450 * @cmd: ioctl cmd to execute
 451 */
 452int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 453{
 454	if (!dev->phydev)
 455		return -ENODEV;
 456
 457	return phy_mii_ioctl(dev->phydev, ifr, cmd);
 458}
 459EXPORT_SYMBOL(phy_do_ioctl);
 460
 461/**
 462 * phy_do_ioctl_running - generic ndo_eth_ioctl implementation but test first
 463 *
 464 * @dev: the net_device struct
 465 * @ifr: &struct ifreq for socket ioctl's
 466 * @cmd: ioctl cmd to execute
 467 *
 468 * Same as phy_do_ioctl, but ensures that net_device is running before
 469 * handling the ioctl.
 470 */
 471int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
 472{
 473	if (!netif_running(dev))
 474		return -ENODEV;
 475
 476	return phy_do_ioctl(dev, ifr, cmd);
 477}
 478EXPORT_SYMBOL(phy_do_ioctl_running);
 479
 480/**
 481 * __phy_hwtstamp_get - Get hardware timestamping configuration from PHY
 482 *
 483 * @phydev: the PHY device structure
 484 * @config: structure holding the timestamping configuration
 485 *
 486 * Query the PHY device for its current hardware timestamping configuration.
 487 */
 488int __phy_hwtstamp_get(struct phy_device *phydev,
 489		       struct kernel_hwtstamp_config *config)
 490{
 491	if (!phydev)
 492		return -ENODEV;
 493
 494	return -EOPNOTSUPP;
 495}
 496
 497/**
 498 * __phy_hwtstamp_set - Modify PHY hardware timestamping configuration
 499 *
 500 * @phydev: the PHY device structure
 501 * @config: structure holding the timestamping configuration
 502 * @extack: netlink extended ack structure, for error reporting
 503 */
 504int __phy_hwtstamp_set(struct phy_device *phydev,
 505		       struct kernel_hwtstamp_config *config,
 506		       struct netlink_ext_ack *extack)
 507{
 508	if (!phydev)
 509		return -ENODEV;
 510
 511	if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
 512		return phydev->mii_ts->hwtstamp(phydev->mii_ts, config, extack);
 513
 514	return -EOPNOTSUPP;
 515}
 516
 517/**
 518 * phy_queue_state_machine - Trigger the state machine to run soon
 519 *
 520 * @phydev: the phy_device struct
 521 * @jiffies: Run the state machine after these jiffies
 522 */
 523void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
 524{
 525	mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
 526			 jiffies);
 527}
 528EXPORT_SYMBOL(phy_queue_state_machine);
 529
 530/**
 531 * phy_trigger_machine - Trigger the state machine to run now
 532 *
 533 * @phydev: the phy_device struct
 534 */
 535void phy_trigger_machine(struct phy_device *phydev)
 536{
 537	phy_queue_state_machine(phydev, 0);
 538}
 539EXPORT_SYMBOL(phy_trigger_machine);
 540
 541static void phy_abort_cable_test(struct phy_device *phydev)
 542{
 543	int err;
 544
 545	ethnl_cable_test_finished(phydev);
 546
 547	err = phy_init_hw(phydev);
 548	if (err)
 549		phydev_err(phydev, "Error while aborting cable test");
 550}
 551
 552/**
 553 * phy_ethtool_get_strings - Get the statistic counter names
 554 *
 555 * @phydev: the phy_device struct
 556 * @data: Where to put the strings
 557 */
 558int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
 559{
 560	if (!phydev->drv)
 561		return -EIO;
 562
 563	mutex_lock(&phydev->lock);
 564	phydev->drv->get_strings(phydev, data);
 565	mutex_unlock(&phydev->lock);
 566
 567	return 0;
 568}
 569EXPORT_SYMBOL(phy_ethtool_get_strings);
 570
 571/**
 572 * phy_ethtool_get_sset_count - Get the number of statistic counters
 573 *
 574 * @phydev: the phy_device struct
 575 */
 576int phy_ethtool_get_sset_count(struct phy_device *phydev)
 577{
 578	int ret;
 579
 580	if (!phydev->drv)
 581		return -EIO;
 582
 583	if (phydev->drv->get_sset_count &&
 584	    phydev->drv->get_strings &&
 585	    phydev->drv->get_stats) {
 586		mutex_lock(&phydev->lock);
 587		ret = phydev->drv->get_sset_count(phydev);
 588		mutex_unlock(&phydev->lock);
 589
 590		return ret;
 591	}
 592
 593	return -EOPNOTSUPP;
 594}
 595EXPORT_SYMBOL(phy_ethtool_get_sset_count);
 596
 597/**
 598 * phy_ethtool_get_stats - Get the statistic counters
 599 *
 600 * @phydev: the phy_device struct
 601 * @stats: What counters to get
 602 * @data: Where to store the counters
 603 */
 604int phy_ethtool_get_stats(struct phy_device *phydev,
 605			  struct ethtool_stats *stats, u64 *data)
 606{
 607	if (!phydev->drv)
 608		return -EIO;
 609
 610	mutex_lock(&phydev->lock);
 611	phydev->drv->get_stats(phydev, stats, data);
 612	mutex_unlock(&phydev->lock);
 613
 614	return 0;
 615}
 616EXPORT_SYMBOL(phy_ethtool_get_stats);
 617
 618/**
 619 * __phy_ethtool_get_phy_stats - Retrieve standardized PHY statistics
 620 * @phydev: Pointer to the PHY device
 621 * @phy_stats: Pointer to ethtool_eth_phy_stats structure
 622 * @phydev_stats: Pointer to ethtool_phy_stats structure
 623 *
 624 * Fetches PHY statistics using a kernel-defined interface for consistent
 625 * diagnostics. Unlike phy_ethtool_get_stats(), which allows custom stats,
 626 * this function enforces a standardized format for better interoperability.
 627 */
 628void __phy_ethtool_get_phy_stats(struct phy_device *phydev,
 629				 struct ethtool_eth_phy_stats *phy_stats,
 630				 struct ethtool_phy_stats *phydev_stats)
 631{
 632	if (!phydev->drv || !phydev->drv->get_phy_stats)
 633		return;
 634
 635	mutex_lock(&phydev->lock);
 636	phydev->drv->get_phy_stats(phydev, phy_stats, phydev_stats);
 637	mutex_unlock(&phydev->lock);
 638}
 639
 640/**
 641 * __phy_ethtool_get_link_ext_stats - Retrieve extended link statistics for a PHY
 642 * @phydev: Pointer to the PHY device
 643 * @link_stats: Pointer to the structure to store extended link statistics
 644 *
 645 * Populates the ethtool_link_ext_stats structure with link down event counts
 646 * and additional driver-specific link statistics, if available.
 647 */
 648void __phy_ethtool_get_link_ext_stats(struct phy_device *phydev,
 649				      struct ethtool_link_ext_stats *link_stats)
 650{
 651	link_stats->link_down_events = READ_ONCE(phydev->link_down_events);
 652
 653	if (!phydev->drv || !phydev->drv->get_link_stats)
 654		return;
 655
 656	mutex_lock(&phydev->lock);
 657	phydev->drv->get_link_stats(phydev, link_stats);
 658	mutex_unlock(&phydev->lock);
 659}
 660
 661/**
 662 * phy_ethtool_get_plca_cfg - Get PLCA RS configuration
 663 * @phydev: the phy_device struct
 664 * @plca_cfg: where to store the retrieved configuration
 665 *
 666 * Retrieve the PLCA configuration from the PHY. Return 0 on success or a
 667 * negative value if an error occurred.
 668 */
 669int phy_ethtool_get_plca_cfg(struct phy_device *phydev,
 670			     struct phy_plca_cfg *plca_cfg)
 671{
 672	int ret;
 673
 674	if (!phydev->drv) {
 675		ret = -EIO;
 676		goto out;
 677	}
 678
 679	if (!phydev->drv->get_plca_cfg) {
 680		ret = -EOPNOTSUPP;
 681		goto out;
 682	}
 683
 684	mutex_lock(&phydev->lock);
 685	ret = phydev->drv->get_plca_cfg(phydev, plca_cfg);
 686
 687	mutex_unlock(&phydev->lock);
 688out:
 689	return ret;
 690}
 691
 692/**
 693 * plca_check_valid - Check PLCA configuration before enabling
 694 * @phydev: the phy_device struct
 695 * @plca_cfg: current PLCA configuration
 696 * @extack: extack for reporting useful error messages
 697 *
 698 * Checks whether the PLCA and PHY configuration are consistent and it is safe
 699 * to enable PLCA. Returns 0 on success or a negative value if the PLCA or PHY
 700 * configuration is not consistent.
 701 */
 702static int plca_check_valid(struct phy_device *phydev,
 703			    const struct phy_plca_cfg *plca_cfg,
 704			    struct netlink_ext_ack *extack)
 705{
 706	int ret = 0;
 707
 708	if (!linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT,
 709			       phydev->advertising)) {
 710		ret = -EOPNOTSUPP;
 711		NL_SET_ERR_MSG(extack,
 712			       "Point to Multi-Point mode is not enabled");
 713	} else if (plca_cfg->node_id >= 255) {
 714		NL_SET_ERR_MSG(extack, "PLCA node ID is not set");
 715		ret = -EINVAL;
 716	}
 717
 718	return ret;
 719}
 720
 721/**
 722 * phy_ethtool_set_plca_cfg - Set PLCA RS configuration
 723 * @phydev: the phy_device struct
 724 * @plca_cfg: new PLCA configuration to apply
 725 * @extack: extack for reporting useful error messages
 726 *
 727 * Sets the PLCA configuration in the PHY. Return 0 on success or a
 728 * negative value if an error occurred.
 729 */
 730int phy_ethtool_set_plca_cfg(struct phy_device *phydev,
 731			     const struct phy_plca_cfg *plca_cfg,
 732			     struct netlink_ext_ack *extack)
 733{
 734	struct phy_plca_cfg *curr_plca_cfg;
 735	int ret;
 736
 737	if (!phydev->drv) {
 738		ret = -EIO;
 739		goto out;
 740	}
 741
 742	if (!phydev->drv->set_plca_cfg ||
 743	    !phydev->drv->get_plca_cfg) {
 744		ret = -EOPNOTSUPP;
 745		goto out;
 746	}
 747
 748	curr_plca_cfg = kmalloc(sizeof(*curr_plca_cfg), GFP_KERNEL);
 749	if (!curr_plca_cfg) {
 750		ret = -ENOMEM;
 751		goto out;
 752	}
 753
 754	mutex_lock(&phydev->lock);
 755
 756	ret = phydev->drv->get_plca_cfg(phydev, curr_plca_cfg);
 757	if (ret)
 758		goto out_drv;
 759
 760	if (curr_plca_cfg->enabled < 0 && plca_cfg->enabled >= 0) {
 761		NL_SET_ERR_MSG(extack,
 762			       "PHY does not support changing the PLCA 'enable' attribute");
 763		ret = -EINVAL;
 764		goto out_drv;
 765	}
 766
 767	if (curr_plca_cfg->node_id < 0 && plca_cfg->node_id >= 0) {
 768		NL_SET_ERR_MSG(extack,
 769			       "PHY does not support changing the PLCA 'local node ID' attribute");
 770		ret = -EINVAL;
 771		goto out_drv;
 772	}
 773
 774	if (curr_plca_cfg->node_cnt < 0 && plca_cfg->node_cnt >= 0) {
 775		NL_SET_ERR_MSG(extack,
 776			       "PHY does not support changing the PLCA 'node count' attribute");
 777		ret = -EINVAL;
 778		goto out_drv;
 779	}
 780
 781	if (curr_plca_cfg->to_tmr < 0 && plca_cfg->to_tmr >= 0) {
 782		NL_SET_ERR_MSG(extack,
 783			       "PHY does not support changing the PLCA 'TO timer' attribute");
 784		ret = -EINVAL;
 785		goto out_drv;
 786	}
 787
 788	if (curr_plca_cfg->burst_cnt < 0 && plca_cfg->burst_cnt >= 0) {
 789		NL_SET_ERR_MSG(extack,
 790			       "PHY does not support changing the PLCA 'burst count' attribute");
 791		ret = -EINVAL;
 792		goto out_drv;
 793	}
 794
 795	if (curr_plca_cfg->burst_tmr < 0 && plca_cfg->burst_tmr >= 0) {
 796		NL_SET_ERR_MSG(extack,
 797			       "PHY does not support changing the PLCA 'burst timer' attribute");
 798		ret = -EINVAL;
 799		goto out_drv;
 800	}
 801
 802	// if enabling PLCA, perform a few sanity checks
 803	if (plca_cfg->enabled > 0) {
 804		// allow setting node_id concurrently with enabled
 805		if (plca_cfg->node_id >= 0)
 806			curr_plca_cfg->node_id = plca_cfg->node_id;
 807
 808		ret = plca_check_valid(phydev, curr_plca_cfg, extack);
 809		if (ret)
 810			goto out_drv;
 811	}
 812
 813	ret = phydev->drv->set_plca_cfg(phydev, plca_cfg);
 814
 815out_drv:
 816	kfree(curr_plca_cfg);
 817	mutex_unlock(&phydev->lock);
 818out:
 819	return ret;
 820}
 821
 822/**
 823 * phy_ethtool_get_plca_status - Get PLCA RS status information
 824 * @phydev: the phy_device struct
 825 * @plca_st: where to store the retrieved status information
 826 *
 827 * Retrieve the PLCA status information from the PHY. Return 0 on success or a
 828 * negative value if an error occurred.
 829 */
 830int phy_ethtool_get_plca_status(struct phy_device *phydev,
 831				struct phy_plca_status *plca_st)
 832{
 833	int ret;
 834
 835	if (!phydev->drv) {
 836		ret = -EIO;
 837		goto out;
 838	}
 839
 840	if (!phydev->drv->get_plca_status) {
 841		ret = -EOPNOTSUPP;
 842		goto out;
 843	}
 844
 845	mutex_lock(&phydev->lock);
 846	ret = phydev->drv->get_plca_status(phydev, plca_st);
 847
 848	mutex_unlock(&phydev->lock);
 849out:
 850	return ret;
 851}
 852
 853/**
 854 * phy_start_cable_test - Start a cable test
 855 *
 856 * @phydev: the phy_device struct
 857 * @extack: extack for reporting useful error messages
 858 */
 859int phy_start_cable_test(struct phy_device *phydev,
 860			 struct netlink_ext_ack *extack)
 861{
 862	struct net_device *dev = phydev->attached_dev;
 863	int err = -ENOMEM;
 864
 865	if (!(phydev->drv &&
 866	      phydev->drv->cable_test_start &&
 867	      phydev->drv->cable_test_get_status)) {
 868		NL_SET_ERR_MSG(extack,
 869			       "PHY driver does not support cable testing");
 870		return -EOPNOTSUPP;
 871	}
 872
 873	mutex_lock(&phydev->lock);
 874	if (phydev->state == PHY_CABLETEST) {
 875		NL_SET_ERR_MSG(extack,
 876			       "PHY already performing a test");
 877		err = -EBUSY;
 878		goto out;
 879	}
 880
 881	if (phydev->state < PHY_UP ||
 882	    phydev->state > PHY_CABLETEST) {
 883		NL_SET_ERR_MSG(extack,
 884			       "PHY not configured. Try setting interface up");
 885		err = -EBUSY;
 886		goto out;
 887	}
 888
 889	err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
 890	if (err)
 891		goto out;
 892
 893	/* Mark the carrier down until the test is complete */
 894	phy_link_down(phydev);
 895
 896	netif_testing_on(dev);
 897	err = phydev->drv->cable_test_start(phydev);
 898	if (err) {
 899		netif_testing_off(dev);
 900		phy_link_up(phydev);
 901		goto out_free;
 902	}
 903
 904	phydev->state = PHY_CABLETEST;
 905
 906	if (phy_polling_mode(phydev))
 907		phy_trigger_machine(phydev);
 908
 909	mutex_unlock(&phydev->lock);
 910
 911	return 0;
 912
 913out_free:
 914	ethnl_cable_test_free(phydev);
 915out:
 916	mutex_unlock(&phydev->lock);
 917
 918	return err;
 919}
 920EXPORT_SYMBOL(phy_start_cable_test);
 921
 922/**
 923 * phy_start_cable_test_tdr - Start a raw TDR cable test
 924 *
 925 * @phydev: the phy_device struct
 926 * @extack: extack for reporting useful error messages
 927 * @config: Configuration of the test to run
 928 */
 929int phy_start_cable_test_tdr(struct phy_device *phydev,
 930			     struct netlink_ext_ack *extack,
 931			     const struct phy_tdr_config *config)
 932{
 933	struct net_device *dev = phydev->attached_dev;
 934	int err = -ENOMEM;
 935
 936	if (!(phydev->drv &&
 937	      phydev->drv->cable_test_tdr_start &&
 938	      phydev->drv->cable_test_get_status)) {
 939		NL_SET_ERR_MSG(extack,
 940			       "PHY driver does not support cable test TDR");
 941		return -EOPNOTSUPP;
 942	}
 943
 944	mutex_lock(&phydev->lock);
 945	if (phydev->state == PHY_CABLETEST) {
 946		NL_SET_ERR_MSG(extack,
 947			       "PHY already performing a test");
 948		err = -EBUSY;
 949		goto out;
 950	}
 951
 952	if (phydev->state < PHY_UP ||
 953	    phydev->state > PHY_CABLETEST) {
 954		NL_SET_ERR_MSG(extack,
 955			       "PHY not configured. Try setting interface up");
 956		err = -EBUSY;
 957		goto out;
 958	}
 959
 960	err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
 961	if (err)
 962		goto out;
 963
 964	/* Mark the carrier down until the test is complete */
 965	phy_link_down(phydev);
 966
 967	netif_testing_on(dev);
 968	err = phydev->drv->cable_test_tdr_start(phydev, config);
 969	if (err) {
 970		netif_testing_off(dev);
 971		phy_link_up(phydev);
 972		goto out_free;
 973	}
 974
 975	phydev->state = PHY_CABLETEST;
 976
 977	if (phy_polling_mode(phydev))
 978		phy_trigger_machine(phydev);
 979
 980	mutex_unlock(&phydev->lock);
 981
 982	return 0;
 983
 984out_free:
 985	ethnl_cable_test_free(phydev);
 986out:
 987	mutex_unlock(&phydev->lock);
 988
 989	return err;
 990}
 991EXPORT_SYMBOL(phy_start_cable_test_tdr);
 992
 993int phy_config_aneg(struct phy_device *phydev)
 994{
 995	if (phydev->drv->config_aneg)
 996		return phydev->drv->config_aneg(phydev);
 997
 998	/* Clause 45 PHYs that don't implement Clause 22 registers are not
 999	 * allowed to call genphy_config_aneg()
1000	 */
1001	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
1002		return genphy_c45_config_aneg(phydev);
1003
1004	return genphy_config_aneg(phydev);
1005}
1006EXPORT_SYMBOL(phy_config_aneg);
1007
1008/**
1009 * phy_check_link_status - check link status and set state accordingly
1010 * @phydev: the phy_device struct
1011 *
1012 * Description: Check for link and whether autoneg was triggered / is running
1013 * and set state accordingly
1014 */
1015static int phy_check_link_status(struct phy_device *phydev)
1016{
1017	int err;
1018
1019	lockdep_assert_held(&phydev->lock);
1020
1021	/* Keep previous state if loopback is enabled because some PHYs
1022	 * report that Link is Down when loopback is enabled.
1023	 */
1024	if (phydev->loopback_enabled)
1025		return 0;
1026
1027	err = phy_read_status(phydev);
1028	if (err)
1029		return err;
1030
1031	if (phydev->link && phydev->state != PHY_RUNNING) {
1032		phy_check_downshift(phydev);
1033		phydev->state = PHY_RUNNING;
1034		err = genphy_c45_eee_is_active(phydev,
1035					       NULL, NULL, NULL);
1036		phydev->eee_active = err > 0;
1037		phydev->enable_tx_lpi = phydev->eee_cfg.tx_lpi_enabled &&
1038					phydev->eee_active;
1039
1040		phy_link_up(phydev);
1041	} else if (!phydev->link && phydev->state != PHY_NOLINK) {
1042		phydev->state = PHY_NOLINK;
1043		phydev->eee_active = false;
1044		phydev->enable_tx_lpi = false;
1045		phy_link_down(phydev);
1046	}
1047
1048	return 0;
1049}
1050
1051/**
1052 * _phy_start_aneg - start auto-negotiation for this PHY device
1053 * @phydev: the phy_device struct
1054 *
1055 * Description: Sanitizes the settings (if we're not autonegotiating
1056 *   them), and then calls the driver's config_aneg function.
1057 *   If the PHYCONTROL Layer is operating, we change the state to
1058 *   reflect the beginning of Auto-negotiation or forcing.
1059 */
1060int _phy_start_aneg(struct phy_device *phydev)
1061{
1062	int err;
1063
1064	lockdep_assert_held(&phydev->lock);
1065
1066	if (!phydev->drv)
1067		return -EIO;
1068
 
 
1069	if (AUTONEG_DISABLE == phydev->autoneg)
1070		phy_sanitize_settings(phydev);
1071
1072	err = phy_config_aneg(phydev);
1073	if (err < 0)
1074		return err;
1075
1076	if (phy_is_started(phydev))
1077		err = phy_check_link_status(phydev);
1078
1079	return err;
1080}
1081EXPORT_SYMBOL(_phy_start_aneg);
1082
1083/**
1084 * phy_start_aneg - start auto-negotiation for this PHY device
1085 * @phydev: the phy_device struct
1086 *
1087 * Description: Sanitizes the settings (if we're not autonegotiating
1088 *   them), and then calls the driver's config_aneg function.
1089 *   If the PHYCONTROL Layer is operating, we change the state to
1090 *   reflect the beginning of Auto-negotiation or forcing.
1091 */
1092int phy_start_aneg(struct phy_device *phydev)
1093{
1094	int err;
1095
1096	mutex_lock(&phydev->lock);
1097	err = _phy_start_aneg(phydev);
1098	mutex_unlock(&phydev->lock);
1099
1100	return err;
1101}
1102EXPORT_SYMBOL(phy_start_aneg);
1103
1104static int phy_poll_aneg_done(struct phy_device *phydev)
1105{
1106	unsigned int retries = 100;
1107	int ret;
1108
1109	do {
1110		msleep(100);
1111		ret = phy_aneg_done(phydev);
1112	} while (!ret && --retries);
1113
1114	if (!ret)
1115		return -ETIMEDOUT;
1116
1117	return ret < 0 ? ret : 0;
1118}
1119
1120int phy_ethtool_ksettings_set(struct phy_device *phydev,
1121			      const struct ethtool_link_ksettings *cmd)
1122{
1123	__ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
1124	u8 autoneg = cmd->base.autoneg;
1125	u8 duplex = cmd->base.duplex;
1126	u32 speed = cmd->base.speed;
1127
1128	if (cmd->base.phy_address != phydev->mdio.addr)
1129		return -EINVAL;
1130
1131	linkmode_copy(advertising, cmd->link_modes.advertising);
1132
1133	/* We make sure that we don't pass unsupported values in to the PHY */
1134	linkmode_and(advertising, advertising, phydev->supported);
1135
1136	/* Verify the settings we care about. */
1137	if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
1138		return -EINVAL;
1139
1140	if (autoneg == AUTONEG_ENABLE &&
1141	    (linkmode_empty(advertising) ||
1142	     !linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1143				phydev->supported)))
1144		return -EINVAL;
1145
1146	if (autoneg == AUTONEG_DISABLE &&
1147	    ((speed != SPEED_1000 &&
1148	      speed != SPEED_100 &&
1149	      speed != SPEED_10) ||
1150	     (duplex != DUPLEX_HALF &&
1151	      duplex != DUPLEX_FULL)))
1152		return -EINVAL;
1153
1154	mutex_lock(&phydev->lock);
1155	phydev->autoneg = autoneg;
1156
1157	if (autoneg == AUTONEG_DISABLE) {
1158		phydev->speed = speed;
1159		phydev->duplex = duplex;
1160	}
1161
1162	linkmode_copy(phydev->advertising, advertising);
1163
1164	linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1165			 phydev->advertising, autoneg == AUTONEG_ENABLE);
1166
1167	phydev->master_slave_set = cmd->base.master_slave_cfg;
1168	phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
1169
1170	/* Restart the PHY */
1171	if (phy_is_started(phydev)) {
1172		phydev->state = PHY_UP;
1173		phy_trigger_machine(phydev);
1174	} else {
1175		_phy_start_aneg(phydev);
1176	}
1177
1178	mutex_unlock(&phydev->lock);
1179	return 0;
1180}
1181EXPORT_SYMBOL(phy_ethtool_ksettings_set);
1182
1183/**
1184 * phy_speed_down - set speed to lowest speed supported by both link partners
1185 * @phydev: the phy_device struct
1186 * @sync: perform action synchronously
1187 *
1188 * Description: Typically used to save energy when waiting for a WoL packet
1189 *
1190 * WARNING: Setting sync to false may cause the system being unable to suspend
1191 * in case the PHY generates an interrupt when finishing the autonegotiation.
1192 * This interrupt may wake up the system immediately after suspend.
1193 * Therefore use sync = false only if you're sure it's safe with the respective
1194 * network chip.
1195 */
1196int phy_speed_down(struct phy_device *phydev, bool sync)
1197{
1198	__ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
1199	int ret = 0;
1200
1201	mutex_lock(&phydev->lock);
1202
1203	if (phydev->autoneg != AUTONEG_ENABLE)
1204		goto out;
1205
1206	linkmode_copy(adv_tmp, phydev->advertising);
1207
1208	ret = phy_speed_down_core(phydev);
1209	if (ret)
1210		goto out;
1211
1212	linkmode_copy(phydev->adv_old, adv_tmp);
1213
1214	if (linkmode_equal(phydev->advertising, adv_tmp)) {
1215		ret = 0;
1216		goto out;
1217	}
1218
1219	ret = phy_config_aneg(phydev);
1220	if (ret)
1221		goto out;
1222
1223	ret = sync ? phy_poll_aneg_done(phydev) : 0;
1224out:
1225	mutex_unlock(&phydev->lock);
1226
1227	return ret;
1228}
1229EXPORT_SYMBOL_GPL(phy_speed_down);
1230
1231/**
1232 * phy_speed_up - (re)set advertised speeds to all supported speeds
1233 * @phydev: the phy_device struct
1234 *
1235 * Description: Used to revert the effect of phy_speed_down
1236 */
1237int phy_speed_up(struct phy_device *phydev)
1238{
1239	__ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
1240	int ret = 0;
1241
1242	mutex_lock(&phydev->lock);
1243
1244	if (phydev->autoneg != AUTONEG_ENABLE)
1245		goto out;
1246
1247	if (linkmode_empty(phydev->adv_old))
1248		goto out;
1249
1250	linkmode_copy(adv_tmp, phydev->advertising);
1251	linkmode_copy(phydev->advertising, phydev->adv_old);
1252	linkmode_zero(phydev->adv_old);
1253
1254	if (linkmode_equal(phydev->advertising, adv_tmp))
1255		goto out;
1256
1257	ret = phy_config_aneg(phydev);
1258out:
1259	mutex_unlock(&phydev->lock);
1260
1261	return ret;
1262}
1263EXPORT_SYMBOL_GPL(phy_speed_up);
1264
1265/**
1266 * phy_start_machine - start PHY state machine tracking
1267 * @phydev: the phy_device struct
1268 *
1269 * Description: The PHY infrastructure can run a state machine
1270 *   which tracks whether the PHY is starting up, negotiating,
1271 *   etc.  This function starts the delayed workqueue which tracks
1272 *   the state of the PHY. If you want to maintain your own state machine,
1273 *   do not call this function.
1274 */
1275void phy_start_machine(struct phy_device *phydev)
1276{
1277	phy_trigger_machine(phydev);
1278}
1279EXPORT_SYMBOL_GPL(phy_start_machine);
1280
1281/**
1282 * phy_stop_machine - stop the PHY state machine tracking
1283 * @phydev: target phy_device struct
1284 *
1285 * Description: Stops the state machine delayed workqueue, sets the
1286 *   state to UP (unless it wasn't up yet). This function must be
1287 *   called BEFORE phy_detach.
1288 */
1289void phy_stop_machine(struct phy_device *phydev)
1290{
1291	cancel_delayed_work_sync(&phydev->state_queue);
1292
1293	mutex_lock(&phydev->lock);
1294	if (phy_is_started(phydev))
1295		phydev->state = PHY_UP;
1296	mutex_unlock(&phydev->lock);
1297}
1298
1299static void phy_process_error(struct phy_device *phydev)
1300{
1301	/* phydev->lock must be held for the state change to be safe */
1302	if (!mutex_is_locked(&phydev->lock))
1303		phydev_err(phydev, "PHY-device data unsafe context\n");
1304
1305	phydev->state = PHY_ERROR;
1306
1307	phy_trigger_machine(phydev);
1308}
1309
1310static void phy_error_precise(struct phy_device *phydev,
1311			      const void *func, int err)
1312{
1313	WARN(1, "%pS: returned: %d\n", func, err);
1314	phy_process_error(phydev);
1315}
1316
1317/**
1318 * phy_error - enter ERROR state for this PHY device
1319 * @phydev: target phy_device struct
1320 *
1321 * Moves the PHY to the ERROR state in response to a read
1322 * or write error, and tells the controller the link is down.
1323 * Must be called with phydev->lock held.
 
1324 */
1325void phy_error(struct phy_device *phydev)
1326{
1327	WARN_ON(1);
1328	phy_process_error(phydev);
 
 
 
 
 
1329}
1330EXPORT_SYMBOL(phy_error);
1331
1332/**
1333 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
1334 * @phydev: target phy_device struct
1335 */
1336int phy_disable_interrupts(struct phy_device *phydev)
1337{
 
 
1338	/* Disable PHY interrupts */
1339	return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
 
 
 
 
 
1340}
1341
1342/**
1343 * phy_interrupt - PHY interrupt handler
1344 * @irq: interrupt line
1345 * @phy_dat: phy_device pointer
1346 *
1347 * Description: Handle PHY interrupt
1348 */
1349static irqreturn_t phy_interrupt(int irq, void *phy_dat)
1350{
1351	struct phy_device *phydev = phy_dat;
1352	irqreturn_t ret;
1353
1354	/* Wakeup interrupts may occur during a system sleep transition.
1355	 * Postpone handling until the PHY has resumed.
1356	 */
1357	if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {
1358		struct net_device *netdev = phydev->attached_dev;
1359
1360		if (netdev) {
1361			struct device *parent = netdev->dev.parent;
1362
1363			if (netdev->ethtool->wol_enabled)
1364				pm_system_wakeup();
1365			else if (device_may_wakeup(&netdev->dev))
1366				pm_wakeup_dev_event(&netdev->dev, 0, true);
1367			else if (parent && device_may_wakeup(parent))
1368				pm_wakeup_dev_event(parent, 0, true);
1369		}
1370
1371		phydev->irq_rerun = 1;
1372		disable_irq_nosync(irq);
1373		return IRQ_HANDLED;
 
1374	}
1375
1376	mutex_lock(&phydev->lock);
1377	ret = phydev->drv->handle_interrupt(phydev);
1378	mutex_unlock(&phydev->lock);
1379
1380	return ret;
1381}
1382
1383/**
1384 * phy_enable_interrupts - Enable the interrupts from the PHY side
1385 * @phydev: target phy_device struct
1386 */
1387static int phy_enable_interrupts(struct phy_device *phydev)
1388{
 
 
 
 
 
1389	return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
1390}
1391
1392/**
1393 * phy_request_interrupt - request and enable interrupt for a PHY device
1394 * @phydev: target phy_device struct
1395 *
1396 * Description: Request and enable the interrupt for the given PHY.
1397 *   If this fails, then we set irq to PHY_POLL.
1398 *   This should only be called with a valid IRQ number.
1399 */
1400void phy_request_interrupt(struct phy_device *phydev)
1401{
1402	int err;
1403
1404	err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
1405				   IRQF_ONESHOT | IRQF_SHARED,
1406				   phydev_name(phydev), phydev);
1407	if (err) {
1408		phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
1409			    err, phydev->irq);
1410		phydev->irq = PHY_POLL;
1411	} else {
1412		if (phy_enable_interrupts(phydev)) {
1413			phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1414			phy_free_interrupt(phydev);
1415			phydev->irq = PHY_POLL;
1416		}
1417	}
1418}
1419EXPORT_SYMBOL(phy_request_interrupt);
1420
1421/**
1422 * phy_free_interrupt - disable and free interrupt for a PHY device
1423 * @phydev: target phy_device struct
1424 *
1425 * Description: Disable and free the interrupt for the given PHY.
1426 *   This should only be called with a valid IRQ number.
1427 */
1428void phy_free_interrupt(struct phy_device *phydev)
1429{
1430	phy_disable_interrupts(phydev);
1431	free_irq(phydev->irq, phydev);
1432}
1433EXPORT_SYMBOL(phy_free_interrupt);
1434
1435enum phy_state_work {
1436	PHY_STATE_WORK_NONE,
1437	PHY_STATE_WORK_ANEG,
1438	PHY_STATE_WORK_SUSPEND,
1439};
1440
1441static enum phy_state_work _phy_state_machine(struct phy_device *phydev)
1442{
1443	enum phy_state_work state_work = PHY_STATE_WORK_NONE;
1444	struct net_device *dev = phydev->attached_dev;
1445	enum phy_state old_state = phydev->state;
1446	const void *func = NULL;
1447	bool finished = false;
1448	int err = 0;
1449
1450	switch (phydev->state) {
1451	case PHY_DOWN:
1452	case PHY_READY:
1453		break;
1454	case PHY_UP:
1455		state_work = PHY_STATE_WORK_ANEG;
1456		break;
1457	case PHY_NOLINK:
1458	case PHY_RUNNING:
1459		err = phy_check_link_status(phydev);
1460		func = &phy_check_link_status;
1461		break;
1462	case PHY_CABLETEST:
1463		err = phydev->drv->cable_test_get_status(phydev, &finished);
1464		if (err) {
1465			phy_abort_cable_test(phydev);
1466			netif_testing_off(dev);
1467			state_work = PHY_STATE_WORK_ANEG;
1468			phydev->state = PHY_UP;
1469			break;
1470		}
1471
1472		if (finished) {
1473			ethnl_cable_test_finished(phydev);
1474			netif_testing_off(dev);
1475			state_work = PHY_STATE_WORK_ANEG;
1476			phydev->state = PHY_UP;
1477		}
1478		break;
1479	case PHY_HALTED:
1480	case PHY_ERROR:
1481		if (phydev->link) {
1482			phydev->link = 0;
1483			phy_link_down(phydev);
1484		}
1485		state_work = PHY_STATE_WORK_SUSPEND;
1486		break;
1487	}
1488
1489	if (state_work == PHY_STATE_WORK_ANEG) {
1490		err = _phy_start_aneg(phydev);
1491		func = &_phy_start_aneg;
1492	}
1493
1494	if (err == -ENODEV)
1495		return state_work;
1496
1497	if (err < 0)
1498		phy_error_precise(phydev, func, err);
1499
1500	phy_process_state_change(phydev, old_state);
1501
1502	/* Only re-schedule a PHY state machine change if we are polling the
1503	 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving
1504	 * between states from phy_mac_interrupt().
1505	 *
1506	 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1507	 * state machine would be pointless and possibly error prone when
1508	 * called from phy_disconnect() synchronously.
1509	 */
1510	if (phy_polling_mode(phydev) && phy_is_started(phydev))
1511		phy_queue_state_machine(phydev, PHY_STATE_TIME);
1512
1513	return state_work;
1514}
1515
1516/* unlocked part of the PHY state machine */
1517static void _phy_state_machine_post_work(struct phy_device *phydev,
1518					 enum phy_state_work state_work)
1519{
1520	if (state_work == PHY_STATE_WORK_SUSPEND)
1521		phy_suspend(phydev);
1522}
1523
1524/**
1525 * phy_state_machine - Handle the state machine
1526 * @work: work_struct that describes the work to be done
1527 */
1528void phy_state_machine(struct work_struct *work)
1529{
1530	struct delayed_work *dwork = to_delayed_work(work);
1531	struct phy_device *phydev =
1532			container_of(dwork, struct phy_device, state_queue);
1533	enum phy_state_work state_work;
1534
1535	mutex_lock(&phydev->lock);
1536	state_work = _phy_state_machine(phydev);
1537	mutex_unlock(&phydev->lock);
1538
1539	_phy_state_machine_post_work(phydev, state_work);
1540}
1541
1542/**
1543 * phy_stop - Bring down the PHY link, and stop checking the status
1544 * @phydev: target phy_device struct
1545 */
1546void phy_stop(struct phy_device *phydev)
1547{
1548	struct net_device *dev = phydev->attached_dev;
1549	enum phy_state_work state_work;
1550	enum phy_state old_state;
1551
1552	if (!phy_is_started(phydev) && phydev->state != PHY_DOWN &&
1553	    phydev->state != PHY_ERROR) {
1554		WARN(1, "called from state %s\n",
1555		     phy_state_to_str(phydev->state));
1556		return;
1557	}
1558
1559	mutex_lock(&phydev->lock);
1560	old_state = phydev->state;
1561
1562	if (phydev->state == PHY_CABLETEST) {
1563		phy_abort_cable_test(phydev);
1564		netif_testing_off(dev);
1565	}
1566
1567	if (phydev->sfp_bus)
1568		sfp_upstream_stop(phydev->sfp_bus);
1569
1570	phydev->state = PHY_HALTED;
1571	phy_process_state_change(phydev, old_state);
1572
1573	state_work = _phy_state_machine(phydev);
1574	mutex_unlock(&phydev->lock);
1575
1576	_phy_state_machine_post_work(phydev, state_work);
1577	phy_stop_machine(phydev);
1578
1579	/* Cannot call flush_scheduled_work() here as desired because
1580	 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1581	 * will not reenable interrupts.
1582	 */
1583}
1584EXPORT_SYMBOL(phy_stop);
1585
1586/**
1587 * phy_start - start or restart a PHY device
1588 * @phydev: target phy_device struct
1589 *
1590 * Description: Indicates the attached device's readiness to
1591 *   handle PHY-related work.  Used during startup to start the
1592 *   PHY, and after a call to phy_stop() to resume operation.
1593 *   Also used to indicate the MDIO bus has cleared an error
1594 *   condition.
1595 */
1596void phy_start(struct phy_device *phydev)
1597{
1598	mutex_lock(&phydev->lock);
1599
1600	if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1601		WARN(1, "called from state %s\n",
1602		     phy_state_to_str(phydev->state));
1603		goto out;
1604	}
1605
1606	if (phydev->sfp_bus)
1607		sfp_upstream_start(phydev->sfp_bus);
1608
1609	/* if phy was suspended, bring the physical link up again */
1610	__phy_resume(phydev);
1611
1612	phydev->state = PHY_UP;
1613
1614	phy_start_machine(phydev);
1615out:
1616	mutex_unlock(&phydev->lock);
1617}
1618EXPORT_SYMBOL(phy_start);
1619
1620/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1621 * phy_mac_interrupt - MAC says the link has changed
1622 * @phydev: phy_device struct with changed link
1623 *
1624 * The MAC layer is able to indicate there has been a change in the PHY link
1625 * status. Trigger the state machine and work a work queue.
1626 */
1627void phy_mac_interrupt(struct phy_device *phydev)
1628{
1629	/* Trigger a state machine change */
1630	phy_trigger_machine(phydev);
1631}
1632EXPORT_SYMBOL(phy_mac_interrupt);
1633
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1634/**
1635 * phy_init_eee - init and check the EEE feature
1636 * @phydev: target phy_device struct
1637 * @clk_stop_enable: PHY may stop the clock during LPI
1638 *
1639 * Description: it checks if the Energy-Efficient Ethernet (EEE)
1640 * is supported by looking at the MMD registers 3.20 and 7.60/61
1641 * and it programs the MMD register 3.0 setting the "Clock stop enable"
1642 * bit if required.
1643 */
1644int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1645{
1646	int ret;
1647
1648	if (!phydev->drv)
1649		return -EIO;
1650
1651	ret = genphy_c45_eee_is_active(phydev, NULL, NULL, NULL);
1652	if (ret < 0)
1653		return ret;
1654	if (!ret)
1655		return -EPROTONOSUPPORT;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1656
1657	if (clk_stop_enable)
1658		/* Configure the PHY to stop receiving xMII
1659		 * clock while it is signaling LPI.
1660		 */
1661		ret = phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1662				       MDIO_PCS_CTRL1_CLKSTOP_EN);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1663
1664	return ret < 0 ? ret : 0;
 
 
 
1665}
1666EXPORT_SYMBOL(phy_init_eee);
1667
1668/**
1669 * phy_get_eee_err - report the EEE wake error count
1670 * @phydev: target phy_device struct
1671 *
1672 * Description: it is to report the number of time where the PHY
1673 * failed to complete its normal wake sequence.
1674 */
1675int phy_get_eee_err(struct phy_device *phydev)
1676{
1677	int ret;
1678
1679	if (!phydev->drv)
1680		return -EIO;
1681
1682	mutex_lock(&phydev->lock);
1683	ret = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1684	mutex_unlock(&phydev->lock);
1685
1686	return ret;
1687}
1688EXPORT_SYMBOL(phy_get_eee_err);
1689
1690/**
1691 * phy_ethtool_get_eee - get EEE supported and status
1692 * @phydev: target phy_device struct
1693 * @data: ethtool_keee data
1694 *
1695 * Description: reports the Supported/Advertisement/LP Advertisement
1696 * capabilities, etc.
1697 */
1698int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data)
1699{
1700	int ret;
1701
1702	if (!phydev->drv)
1703		return -EIO;
1704
1705	mutex_lock(&phydev->lock);
1706	ret = genphy_c45_ethtool_get_eee(phydev, data);
1707	eeecfg_to_eee(data, &phydev->eee_cfg);
1708	mutex_unlock(&phydev->lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1709
1710	return ret;
1711}
1712EXPORT_SYMBOL(phy_ethtool_get_eee);
1713
1714/**
1715 * phy_ethtool_set_eee_noneg - Adjusts MAC LPI configuration without PHY
1716 *			       renegotiation
1717 * @phydev: pointer to the target PHY device structure
1718 * @old_cfg: pointer to the eee_config structure containing the old EEE settings
1719 *
1720 * This function updates the Energy Efficient Ethernet (EEE) configuration
1721 * for cases where only the MAC's Low Power Idle (LPI) configuration changes,
1722 * without triggering PHY renegotiation. It ensures that the MAC is properly
1723 * informed of the new LPI settings by cycling the link down and up, which
1724 * is necessary for the MAC to adopt the new configuration. This adjustment
1725 * is done only if there is a change in the tx_lpi_enabled or tx_lpi_timer
1726 * configuration.
1727 */
1728static void phy_ethtool_set_eee_noneg(struct phy_device *phydev,
1729				      const struct eee_config *old_cfg)
1730{
1731	bool enable_tx_lpi;
1732
1733	if (!phydev->link)
1734		return;
1735
1736	enable_tx_lpi = phydev->eee_cfg.tx_lpi_enabled && phydev->eee_active;
1737
1738	if (phydev->enable_tx_lpi != enable_tx_lpi ||
1739	    phydev->eee_cfg.tx_lpi_timer != old_cfg->tx_lpi_timer) {
1740		phydev->enable_tx_lpi = false;
1741		phydev->link = false;
1742		phy_link_down(phydev);
1743		phydev->enable_tx_lpi = enable_tx_lpi;
1744		phydev->link = true;
1745		phy_link_up(phydev);
1746	}
1747}
 
1748
1749/**
1750 * phy_ethtool_set_eee - set EEE supported and status
1751 * @phydev: target phy_device struct
1752 * @data: ethtool_keee data
1753 *
1754 * Description: it is to program the Advertisement EEE register.
1755 */
1756int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data)
1757{
1758	struct eee_config old_cfg;
1759	int ret;
1760
1761	if (!phydev->drv)
1762		return -EIO;
1763
1764	mutex_lock(&phydev->lock);
1765
1766	old_cfg = phydev->eee_cfg;
1767	eee_to_eeecfg(&phydev->eee_cfg, data);
 
 
 
 
 
 
 
 
 
 
 
1768
1769	ret = genphy_c45_ethtool_set_eee(phydev, data);
1770	if (ret == 0)
1771		phy_ethtool_set_eee_noneg(phydev, &old_cfg);
1772	else if (ret < 0)
1773		phydev->eee_cfg = old_cfg;
1774
1775	mutex_unlock(&phydev->lock);
 
 
 
 
 
 
 
 
1776
1777	return ret < 0 ? ret : 0;
1778}
1779EXPORT_SYMBOL(phy_ethtool_set_eee);
1780
1781/**
1782 * phy_ethtool_set_wol - Configure Wake On LAN
1783 *
1784 * @phydev: target phy_device struct
1785 * @wol: Configuration requested
1786 */
1787int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1788{
1789	int ret;
1790
1791	if (phydev->drv && phydev->drv->set_wol) {
1792		mutex_lock(&phydev->lock);
1793		ret = phydev->drv->set_wol(phydev, wol);
1794		mutex_unlock(&phydev->lock);
1795
1796		return ret;
1797	}
1798
1799	return -EOPNOTSUPP;
1800}
1801EXPORT_SYMBOL(phy_ethtool_set_wol);
1802
1803/**
1804 * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1805 *
1806 * @phydev: target phy_device struct
1807 * @wol: Store the current configuration here
1808 */
1809void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1810{
1811	if (phydev->drv && phydev->drv->get_wol) {
1812		mutex_lock(&phydev->lock);
1813		phydev->drv->get_wol(phydev, wol);
1814		mutex_unlock(&phydev->lock);
1815	}
1816}
1817EXPORT_SYMBOL(phy_ethtool_get_wol);
1818
1819int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1820				   struct ethtool_link_ksettings *cmd)
1821{
1822	struct phy_device *phydev = ndev->phydev;
1823
1824	if (!phydev)
1825		return -ENODEV;
1826
1827	phy_ethtool_ksettings_get(phydev, cmd);
1828
1829	return 0;
1830}
1831EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1832
1833int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1834				   const struct ethtool_link_ksettings *cmd)
1835{
1836	struct phy_device *phydev = ndev->phydev;
1837
1838	if (!phydev)
1839		return -ENODEV;
1840
1841	return phy_ethtool_ksettings_set(phydev, cmd);
1842}
1843EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1844
1845/**
1846 * phy_ethtool_nway_reset - Restart auto negotiation
1847 * @ndev: Network device to restart autoneg for
1848 */
1849int phy_ethtool_nway_reset(struct net_device *ndev)
1850{
1851	struct phy_device *phydev = ndev->phydev;
1852	int ret;
1853
1854	if (!phydev)
1855		return -ENODEV;
1856
1857	if (!phydev->drv)
1858		return -EIO;
1859
1860	mutex_lock(&phydev->lock);
1861	ret = phy_restart_aneg(phydev);
1862	mutex_unlock(&phydev->lock);
1863
1864	return ret;
1865}
1866EXPORT_SYMBOL(phy_ethtool_nway_reset);