phy.c 30.8 KB
Newer Older
S
Sergei Shtylyov 已提交
1
/* Framework for configuring and reading PHY devices
2 3 4 5 6
 * Based on code in sungem_phy.c and gianfar_phy.c
 *
 * Author: Andy Fleming
 *
 * Copyright (c) 2004 Freescale Semiconductor, Inc.
7
 * Copyright (c) 2006, 2007  Maciej W. Rozycki
8 9 10 11 12 13 14
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 *
 */
J
Joe Perches 已提交
15 16 17

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

18 19 20 21 22 23 24 25 26 27 28 29 30 31
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/phy.h>
32
#include <linux/phy_led_triggers.h>
33
#include <linux/workqueue.h>
34
#include <linux/mdio.h>
S
Sergei Shtylyov 已提交
35 36
#include <linux/io.h>
#include <linux/uaccess.h>
A
Arun Sharma 已提交
37
#include <linux/atomic.h>
S
Sergei Shtylyov 已提交
38

39 40
#include <asm/irq.h>

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
#define PHY_STATE_STR(_state)			\
	case PHY_##_state:			\
		return __stringify(_state);	\

static const char *phy_state_to_str(enum phy_state st)
{
	switch (st) {
	PHY_STATE_STR(DOWN)
	PHY_STATE_STR(STARTING)
	PHY_STATE_STR(READY)
	PHY_STATE_STR(PENDING)
	PHY_STATE_STR(UP)
	PHY_STATE_STR(RUNNING)
	PHY_STATE_STR(NOLINK)
	PHY_STATE_STR(FORCING)
	PHY_STATE_STR(CHANGELINK)
	PHY_STATE_STR(HALTED)
	PHY_STATE_STR(RESUMING)
	}

	return NULL;
}

64 65 66 67 68 69 70 71 72 73 74
static void phy_link_up(struct phy_device *phydev)
{
	phydev->phy_link_change(phydev, true, true);
	phy_led_trigger_change_speed(phydev);
}

static void phy_link_down(struct phy_device *phydev, bool do_carrier)
{
	phydev->phy_link_change(phydev, false, do_carrier);
	phy_led_trigger_change_speed(phydev);
}
75

76 77 78
/**
 * phy_print_status - Convenience function to print out the current phy status
 * @phydev: the phy_device struct
A
Andy Fleming 已提交
79 80 81
 */
void phy_print_status(struct phy_device *phydev)
{
S
Sergei Shtylyov 已提交
82
	if (phydev->link) {
83
		netdev_info(phydev->attached_dev,
84 85
			"Link is Up - %s/%s - flow control %s\n",
			phy_speed_to_str(phydev->speed),
86
			phy_duplex_to_str(phydev->duplex),
87
			phydev->pause ? "rx/tx" : "off");
S
Sergei Shtylyov 已提交
88
	} else	{
89
		netdev_info(phydev->attached_dev, "Link is Down\n");
S
Sergei Shtylyov 已提交
90
	}
A
Andy Fleming 已提交
91 92
}
EXPORT_SYMBOL(phy_print_status);
93

94 95 96 97 98 99 100
/**
 * phy_clear_interrupt - Ack the phy device's interrupt
 * @phydev: the phy_device struct
 *
 * If the @phydev driver has an ack_interrupt function, call it to
 * ack and clear the phy device's interrupt.
 *
101
 * Returns 0 on success or < 0 on error.
102
 */
103
static int phy_clear_interrupt(struct phy_device *phydev)
104 105
{
	if (phydev->drv->ack_interrupt)
106
		return phydev->drv->ack_interrupt(phydev);
107

108
	return 0;
109 110
}

111 112 113 114 115
/**
 * phy_config_interrupt - configure the PHY device for the requested interrupts
 * @phydev: the phy_device struct
 * @interrupts: interrupt flags to configure for this @phydev
 *
116
 * Returns 0 on success or < 0 on error.
117
 */
118
static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
119
{
120
	phydev->interrupts = interrupts ? 1 : 0;
121
	if (phydev->drv->config_intr)
122
		return phydev->drv->config_intr(phydev);
123

124
	return 0;
125 126
}

127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
/**
 * phy_restart_aneg - restart auto-negotiation
 * @phydev: target phy_device struct
 *
 * Restart the autonegotiation on @phydev.  Returns >= 0 on success or
 * negative errno on error.
 */
int phy_restart_aneg(struct phy_device *phydev)
{
	int ret;

	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
		ret = genphy_c45_restart_aneg(phydev);
	else
		ret = genphy_restart_aneg(phydev);

	return ret;
}
EXPORT_SYMBOL_GPL(phy_restart_aneg);
146

147 148 149
/**
 * phy_aneg_done - return auto-negotiation status
 * @phydev: target phy_device struct
150
 *
151 152 153
 * Description: Return the auto-negotiation status from this @phydev
 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
 * is still pending.
154
 */
155
int phy_aneg_done(struct phy_device *phydev)
156
{
157
	if (phydev->drv && phydev->drv->aneg_done)
158 159
		return phydev->drv->aneg_done(phydev);

160 161 162 163 164 165
	/* Avoid genphy_aneg_done() if the Clause 45 PHY does not
	 * implement Clause 22 registers
	 */
	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
		return -EINVAL;

166
	return genphy_aneg_done(phydev);
167
}
168
EXPORT_SYMBOL(phy_aneg_done);
169

170
/**
171 172 173 174
 * phy_find_valid - find a PHY setting that matches the requested parameters
 * @speed: desired speed
 * @duplex: desired duplex
 * @supported: mask of supported link modes
175
 *
176 177 178 179 180 181
 * Locate a supported phy setting that is, in priority order:
 * - an exact match for the specified speed and duplex mode
 * - a match for the specified speed, or slower speed
 * - the slowest supported speed
 * Returns the matched phy_setting entry, or %NULL if no supported phy
 * settings were found.
182
 */
183 184
static const struct phy_setting *
phy_find_valid(int speed, int duplex, u32 supported)
185
{
186 187 188
	unsigned long mask = supported;

	return phy_lookup_setting(speed, duplex, &mask, BITS_PER_LONG, false);
189 190
}

191 192 193 194 195 196 197 198 199 200 201 202 203 204
/**
 * phy_supported_speeds - return all speeds currently supported by a phy device
 * @phy: The phy device to return supported speeds of.
 * @speeds: buffer to store supported speeds in.
 * @size:   size of speeds buffer.
 *
 * Description: Returns the number of supported speeds, and fills the speeds
 * buffer with the supported speeds. If speeds buffer is too small to contain
 * all currently supported speeds, will return as many speeds as can fit.
 */
unsigned int phy_supported_speeds(struct phy_device *phy,
				  unsigned int *speeds,
				  unsigned int size)
{
205
	unsigned long supported = phy->supported;
206

207
	return phy_speeds(speeds, size, &supported, BITS_PER_LONG);
208 209
}

210 211 212 213 214 215 216 217 218 219 220
/**
 * phy_check_valid - check if there is a valid PHY setting which matches
 *		     speed, duplex, and feature mask
 * @speed: speed to match
 * @duplex: duplex to match
 * @features: A mask of the valid settings
 *
 * Description: Returns true if there is a valid setting, false otherwise.
 */
static inline bool phy_check_valid(int speed, int duplex, u32 features)
{
221 222 223
	unsigned long mask = features;

	return !!phy_lookup_setting(speed, duplex, &mask, BITS_PER_LONG, true);
224 225
}

226 227 228
/**
 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
 * @phydev: the target phy_device struct
229
 *
230
 * Description: Make sure the PHY is set to supported speeds and
231
 *   duplexes.  Drop down by one in this order:  1000/FULL,
232
 *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
233
 */
234
static void phy_sanitize_settings(struct phy_device *phydev)
235
{
236
	const struct phy_setting *setting;
237 238 239 240
	u32 features = phydev->supported;

	/* Sanitize settings based on PHY capabilities */
	if ((features & SUPPORTED_Autoneg) == 0)
241
		phydev->autoneg = AUTONEG_DISABLE;
242

243 244 245 246 247 248 249 250 251
	setting = phy_find_valid(phydev->speed, phydev->duplex, features);
	if (setting) {
		phydev->speed = setting->speed;
		phydev->duplex = setting->duplex;
	} else {
		/* We failed to find anything (no supported speeds?) */
		phydev->speed = SPEED_UNKNOWN;
		phydev->duplex = DUPLEX_UNKNOWN;
	}
252 253
}

254 255 256 257
/**
 * phy_ethtool_sset - generic ethtool sset function, handles all the details
 * @phydev: target phy_device struct
 * @cmd: ethtool_cmd
258 259
 *
 * A few notes about parameter checking:
260
 *
261 262 263 264
 * - We don't set port or transceiver, so we don't care what they
 *   were set to.
 * - phy_start_aneg() will make sure forced settings are sane, and
 *   choose the next best ones from the ones selected, so we don't
265
 *   care if ethtool tries to give us bad values.
266 267 268
 */
int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
{
269 270
	u32 speed = ethtool_cmd_speed(cmd);

A
Andrew Lunn 已提交
271
	if (cmd->phy_address != phydev->mdio.addr)
272 273
		return -EINVAL;

S
Sergei Shtylyov 已提交
274
	/* We make sure that we don't pass unsupported values in to the PHY */
275 276 277 278 279 280 281 282 283
	cmd->advertising &= phydev->supported;

	/* Verify the settings we care about. */
	if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
		return -EINVAL;

	if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
		return -EINVAL;

284
	if (cmd->autoneg == AUTONEG_DISABLE &&
285 286 287
	    ((speed != SPEED_1000 &&
	      speed != SPEED_100 &&
	      speed != SPEED_10) ||
288 289
	     (cmd->duplex != DUPLEX_HALF &&
	      cmd->duplex != DUPLEX_FULL)))
290 291 292 293
		return -EINVAL;

	phydev->autoneg = cmd->autoneg;

294
	phydev->speed = speed;
295 296 297 298 299 300 301 302 303 304

	phydev->advertising = cmd->advertising;

	if (AUTONEG_ENABLE == cmd->autoneg)
		phydev->advertising |= ADVERTISED_Autoneg;
	else
		phydev->advertising &= ~ADVERTISED_Autoneg;

	phydev->duplex = cmd->duplex;

305
	phydev->mdix_ctrl = cmd->eth_tp_mdix_ctrl;
306

307 308 309 310 311
	/* Restart the PHY */
	phy_start_aneg(phydev);

	return 0;
}
K
Kumar Gala 已提交
312
EXPORT_SYMBOL(phy_ethtool_sset);
313

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
int phy_ethtool_ksettings_set(struct phy_device *phydev,
			      const struct ethtool_link_ksettings *cmd)
{
	u8 autoneg = cmd->base.autoneg;
	u8 duplex = cmd->base.duplex;
	u32 speed = cmd->base.speed;
	u32 advertising;

	if (cmd->base.phy_address != phydev->mdio.addr)
		return -EINVAL;

	ethtool_convert_link_mode_to_legacy_u32(&advertising,
						cmd->link_modes.advertising);

	/* We make sure that we don't pass unsupported values in to the PHY */
	advertising &= phydev->supported;

	/* Verify the settings we care about. */
	if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
		return -EINVAL;

	if (autoneg == AUTONEG_ENABLE && advertising == 0)
		return -EINVAL;

	if (autoneg == AUTONEG_DISABLE &&
	    ((speed != SPEED_1000 &&
	      speed != SPEED_100 &&
	      speed != SPEED_10) ||
	     (duplex != DUPLEX_HALF &&
	      duplex != DUPLEX_FULL)))
		return -EINVAL;

	phydev->autoneg = autoneg;

	phydev->speed = speed;

	phydev->advertising = advertising;

	if (autoneg == AUTONEG_ENABLE)
		phydev->advertising |= ADVERTISED_Autoneg;
	else
		phydev->advertising &= ~ADVERTISED_Autoneg;

	phydev->duplex = duplex;

359
	phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
360 361 362 363 364 365 366 367

	/* Restart the PHY */
	phy_start_aneg(phydev);

	return 0;
}
EXPORT_SYMBOL(phy_ethtool_ksettings_set);

368 369
void phy_ethtool_ksettings_get(struct phy_device *phydev,
			       struct ethtool_link_ksettings *cmd)
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
{
	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
						phydev->supported);

	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
						phydev->advertising);

	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
						phydev->lp_advertising);

	cmd->base.speed = phydev->speed;
	cmd->base.duplex = phydev->duplex;
	if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
		cmd->base.port = PORT_BNC;
	else
		cmd->base.port = PORT_MII;
386 387
	cmd->base.transceiver = phy_is_internal(phydev) ?
				XCVR_INTERNAL : XCVR_EXTERNAL;
388 389
	cmd->base.phy_address = phydev->mdio.addr;
	cmd->base.autoneg = phydev->autoneg;
390 391
	cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
	cmd->base.eth_tp_mdix = phydev->mdix;
392 393
}
EXPORT_SYMBOL(phy_ethtool_ksettings_get);
394

395 396 397
/**
 * phy_mii_ioctl - generic PHY MII ioctl interface
 * @phydev: the phy_device struct
R
Randy Dunlap 已提交
398
 * @ifr: &struct ifreq for socket ioctl's
399 400 401
 * @cmd: ioctl cmd to execute
 *
 * Note that this function is currently incompatible with the
402
 * PHYCONTROL layer.  It changes registers without regard to
403
 * current state.  Use at own risk.
404
 */
S
Sergei Shtylyov 已提交
405
int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
406
{
407
	struct mii_ioctl_data *mii_data = if_mii(ifr);
408
	u16 val = mii_data->val_in;
409
	bool change_autoneg = false;
410 411 412

	switch (cmd) {
	case SIOCGMIIPHY:
A
Andrew Lunn 已提交
413
		mii_data->phy_id = phydev->mdio.addr;
L
Lennert Buytenhek 已提交
414 415
		/* fall through */

416
	case SIOCGMIIREG:
A
Andrew Lunn 已提交
417 418
		mii_data->val_out = mdiobus_read(phydev->mdio.bus,
						 mii_data->phy_id,
419
						 mii_data->reg_num);
420
		return 0;
421 422

	case SIOCSMIIREG:
A
Andrew Lunn 已提交
423
		if (mii_data->phy_id == phydev->mdio.addr) {
F
Florian Fainelli 已提交
424
			switch (mii_data->reg_num) {
425
			case MII_BMCR:
426 427 428
				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
					if (phydev->autoneg == AUTONEG_ENABLE)
						change_autoneg = true;
429
					phydev->autoneg = AUTONEG_DISABLE;
430 431 432 433 434 435 436 437 438 439 440 441 442
					if (val & BMCR_FULLDPLX)
						phydev->duplex = DUPLEX_FULL;
					else
						phydev->duplex = DUPLEX_HALF;
					if (val & BMCR_SPEED1000)
						phydev->speed = SPEED_1000;
					else if (val & BMCR_SPEED100)
						phydev->speed = SPEED_100;
					else phydev->speed = SPEED_10;
				}
				else {
					if (phydev->autoneg == AUTONEG_DISABLE)
						change_autoneg = true;
443
					phydev->autoneg = AUTONEG_ENABLE;
444
				}
445 446
				break;
			case MII_ADVERTISE:
447 448
				phydev->advertising = mii_adv_to_ethtool_adv_t(val);
				change_autoneg = true;
449 450 451 452 453 454 455
				break;
			default:
				/* do nothing */
				break;
			}
		}

A
Andrew Lunn 已提交
456
		mdiobus_write(phydev->mdio.bus, mii_data->phy_id,
457 458
			      mii_data->reg_num, val);

A
Andrew Lunn 已提交
459
		if (mii_data->phy_id == phydev->mdio.addr &&
460
		    mii_data->reg_num == MII_BMCR &&
461
		    val & BMCR_RESET)
462
			return phy_init_hw(phydev);
463 464 465 466

		if (change_autoneg)
			return phy_start_aneg(phydev);

467
		return 0;
468

469
	case SIOCSHWTSTAMP:
F
Florian Fainelli 已提交
470
		if (phydev->drv && phydev->drv->hwtstamp)
471 472 473
			return phydev->drv->hwtstamp(phydev, ifr);
		/* fall through */

474
	default:
L
Lennert Buytenhek 已提交
475
		return -EOPNOTSUPP;
476 477
	}
}
D
Domen Puncer 已提交
478
EXPORT_SYMBOL(phy_mii_ioctl);
479

480 481 482 483 484 485 486 487 488 489 490 491
static void phy_queue_state_machine(struct phy_device *phydev,
				    unsigned int secs)
{
	mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
			 secs * HZ);
}

static void phy_trigger_machine(struct phy_device *phydev)
{
	phy_queue_state_machine(phydev, 0);
}

492 493 494 495
static int phy_config_aneg(struct phy_device *phydev)
{
	if (phydev->drv->config_aneg)
		return phydev->drv->config_aneg(phydev);
496 497 498 499 500 501 502 503

	/* Clause 45 PHYs that don't implement Clause 22 registers are not
	 * allowed to call genphy_config_aneg()
	 */
	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
		return -EOPNOTSUPP;

	return genphy_config_aneg(phydev);
504 505
}

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
/**
 * phy_check_link_status - check link status and set state accordingly
 * @phydev: the phy_device struct
 *
 * Description: Check for link and whether autoneg was triggered / is running
 * and set state accordingly
 */
static int phy_check_link_status(struct phy_device *phydev)
{
	int err;

	WARN_ON(!mutex_is_locked(&phydev->lock));

	err = phy_read_status(phydev);
	if (err)
		return err;

	if (phydev->link && phydev->state != PHY_RUNNING) {
		phydev->state = PHY_RUNNING;
		phy_link_up(phydev);
	} else if (!phydev->link && phydev->state != PHY_NOLINK) {
		phydev->state = PHY_NOLINK;
		phy_link_down(phydev, true);
	}

	return 0;
}

534
/**
535
 * phy_start_aneg - start auto-negotiation for this PHY device
536
 * @phydev: the phy_device struct
A
Andy Fleming 已提交
537
 *
538 539 540 541
 * Description: Sanitizes the settings (if we're not autonegotiating
 *   them), and then calls the driver's config_aneg function.
 *   If the PHYCONTROL Layer is operating, we change the state to
 *   reflect the beginning of Auto-negotiation or forcing.
A
Andy Fleming 已提交
542
 */
543
int phy_start_aneg(struct phy_device *phydev)
A
Andy Fleming 已提交
544 545 546
{
	int err;

F
Florian Fainelli 已提交
547 548 549
	if (!phydev->drv)
		return -EIO;

550
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
551 552 553 554

	if (AUTONEG_DISABLE == phydev->autoneg)
		phy_sanitize_settings(phydev);

555 556 557
	/* Invalidate LP advertising flags */
	phydev->lp_advertising = 0;

558
	err = phy_config_aneg(phydev);
A
Andy Fleming 已提交
559 560 561 562 563
	if (err < 0)
		goto out_unlock;

	if (phydev->state != PHY_HALTED) {
		if (AUTONEG_ENABLE == phydev->autoneg) {
564
			err = phy_check_link_status(phydev);
A
Andy Fleming 已提交
565 566 567 568 569 570 571
		} else {
			phydev->state = PHY_FORCING;
			phydev->link_timeout = PHY_FORCE_TIMEOUT;
		}
	}

out_unlock:
572
	mutex_unlock(&phydev->lock);
573

A
Andy Fleming 已提交
574 575 576 577
	return err;
}
EXPORT_SYMBOL(phy_start_aneg);

578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
static int phy_poll_aneg_done(struct phy_device *phydev)
{
	unsigned int retries = 100;
	int ret;

	do {
		msleep(100);
		ret = phy_aneg_done(phydev);
	} while (!ret && --retries);

	if (!ret)
		return -ETIMEDOUT;

	return ret < 0 ? ret : 0;
}

/**
 * phy_speed_down - set speed to lowest speed supported by both link partners
 * @phydev: the phy_device struct
 * @sync: perform action synchronously
 *
 * Description: Typically used to save energy when waiting for a WoL packet
 *
 * WARNING: Setting sync to false may cause the system being unable to suspend
 * in case the PHY generates an interrupt when finishing the autonegotiation.
 * This interrupt may wake up the system immediately after suspend.
 * Therefore use sync = false only if you're sure it's safe with the respective
 * network chip.
 */
int phy_speed_down(struct phy_device *phydev, bool sync)
{
	u32 adv = phydev->lp_advertising & phydev->supported;
	u32 adv_old = phydev->advertising;
	int ret;

	if (phydev->autoneg != AUTONEG_ENABLE)
		return 0;

	if (adv & PHY_10BT_FEATURES)
		phydev->advertising &= ~(PHY_100BT_FEATURES |
					 PHY_1000BT_FEATURES);
	else if (adv & PHY_100BT_FEATURES)
		phydev->advertising &= ~PHY_1000BT_FEATURES;

	if (phydev->advertising == adv_old)
		return 0;

	ret = phy_config_aneg(phydev);
	if (ret)
		return ret;

	return sync ? phy_poll_aneg_done(phydev) : 0;
}
EXPORT_SYMBOL_GPL(phy_speed_down);

/**
 * phy_speed_up - (re)set advertised speeds to all supported speeds
 * @phydev: the phy_device struct
 *
 * Description: Used to revert the effect of phy_speed_down
 */
int phy_speed_up(struct phy_device *phydev)
{
	u32 mask = PHY_10BT_FEATURES | PHY_100BT_FEATURES | PHY_1000BT_FEATURES;
	u32 adv_old = phydev->advertising;

	if (phydev->autoneg != AUTONEG_ENABLE)
		return 0;

	phydev->advertising = (adv_old & ~mask) | (phydev->supported & mask);

	if (phydev->advertising == adv_old)
		return 0;

	return phy_config_aneg(phydev);
}
EXPORT_SYMBOL_GPL(phy_speed_up);

656 657 658
/**
 * phy_start_machine - start PHY state machine tracking
 * @phydev: the phy_device struct
659
 *
660
 * Description: The PHY infrastructure can run a state machine
661
 *   which tracks whether the PHY is starting up, negotiating,
662 663
 *   etc.  This function starts the delayed workqueue which tracks
 *   the state of the PHY. If you want to maintain your own state machine,
664
 *   do not call this function.
665
 */
666
void phy_start_machine(struct phy_device *phydev)
667
{
668
	phy_trigger_machine(phydev);
669
}
670
EXPORT_SYMBOL_GPL(phy_start_machine);
671

672 673 674
/**
 * phy_stop_machine - stop the PHY state machine tracking
 * @phydev: target phy_device struct
675
 *
676 677 678
 * Description: Stops the state machine delayed workqueue, sets the
 *   state to UP (unless it wasn't up yet). This function must be
 *   called BEFORE phy_detach.
679 680 681
 */
void phy_stop_machine(struct phy_device *phydev)
{
682
	cancel_delayed_work_sync(&phydev->state_queue);
683

684
	mutex_lock(&phydev->lock);
685
	if (phydev->state > PHY_UP && phydev->state != PHY_HALTED)
686
		phydev->state = PHY_UP;
687
	mutex_unlock(&phydev->lock);
688 689
}

690 691 692
/**
 * phy_error - enter HALTED state for this PHY device
 * @phydev: target phy_device struct
693 694 695 696 697 698
 *
 * Moves the PHY to the HALTED state in response to a read
 * or write error, and tells the controller the link is down.
 * Must not be called from interrupt context, or while the
 * phydev->lock is held.
 */
A
Andy Fleming 已提交
699
static void phy_error(struct phy_device *phydev)
700
{
701
	mutex_lock(&phydev->lock);
702
	phydev->state = PHY_HALTED;
703
	mutex_unlock(&phydev->lock);
704

705
	phy_trigger_machine(phydev);
706 707
}

708 709 710 711 712 713 714 715 716 717 718
/**
 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
 * @phydev: target phy_device struct
 */
static int phy_disable_interrupts(struct phy_device *phydev)
{
	int err;

	/* Disable PHY interrupts */
	err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
	if (err)
719
		return err;
720 721

	/* Clear the interrupt */
722
	return phy_clear_interrupt(phydev);
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
}

/**
 * phy_change - Called by the phy_interrupt to handle PHY changes
 * @phydev: phy_device struct that interrupted
 */
static irqreturn_t phy_change(struct phy_device *phydev)
{
	if (phy_interrupt_is_valid(phydev)) {
		if (phydev->drv->did_interrupt &&
		    !phydev->drv->did_interrupt(phydev))
			return IRQ_NONE;

		if (phydev->state == PHY_HALTED)
			if (phy_disable_interrupts(phydev))
				goto phy_err;
	}

	/* reschedule state queue work to run as soon as possible */
742
	phy_trigger_machine(phydev);
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764

	if (phy_interrupt_is_valid(phydev) && phy_clear_interrupt(phydev))
		goto phy_err;
	return IRQ_HANDLED;

phy_err:
	phy_error(phydev);
	return IRQ_NONE;
}

/**
 * phy_change_work - Scheduled by the phy_mac_interrupt to handle PHY changes
 * @work: work_struct that describes the work to be done
 */
void phy_change_work(struct work_struct *work)
{
	struct phy_device *phydev =
		container_of(work, struct phy_device, phy_queue);

	phy_change(phydev);
}

765 766 767 768
/**
 * phy_interrupt - PHY interrupt handler
 * @irq: interrupt line
 * @phy_dat: phy_device pointer
A
Andy Fleming 已提交
769
 *
770
 * Description: When a PHY interrupt occurs, the handler disables
771
 * interrupts, and uses phy_change to handle the interrupt.
A
Andy Fleming 已提交
772
 */
773
static irqreturn_t phy_interrupt(int irq, void *phy_dat)
A
Andy Fleming 已提交
774 775 776
{
	struct phy_device *phydev = phy_dat;

777 778 779
	if (PHY_HALTED == phydev->state)
		return IRQ_NONE;		/* It can't be ours.  */

780
	return phy_change(phydev);
A
Andy Fleming 已提交
781 782
}

783 784 785 786
/**
 * phy_enable_interrupts - Enable the interrupts from the PHY side
 * @phydev: target phy_device struct
 */
787
static int phy_enable_interrupts(struct phy_device *phydev)
788
{
S
Sergei Shtylyov 已提交
789
	int err = phy_clear_interrupt(phydev);
790

A
Andy Fleming 已提交
791 792
	if (err < 0)
		return err;
793

S
Sergei Shtylyov 已提交
794
	return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
795 796
}

797 798 799
/**
 * phy_start_interrupts - request and enable interrupts for a PHY device
 * @phydev: target phy_device struct
A
Andy Fleming 已提交
800
 *
801 802
 * Description: Request the interrupt for the given PHY.
 *   If this fails, then we set irq to PHY_POLL.
A
Andy Fleming 已提交
803 804
 *   Otherwise, we enable the interrupts in the PHY.
 *   This should only be called with a valid IRQ number.
805
 *   Returns 0 on success or < 0 on error.
A
Andy Fleming 已提交
806 807 808
 */
int phy_start_interrupts(struct phy_device *phydev)
{
809 810
	if (request_threaded_irq(phydev->irq, NULL, phy_interrupt,
				 IRQF_ONESHOT | IRQF_SHARED,
811
				 phydev_name(phydev), phydev) < 0) {
J
Joe Perches 已提交
812
		pr_warn("%s: Can't get IRQ %d (PHY)\n",
A
Andrew Lunn 已提交
813
			phydev->mdio.bus->name, phydev->irq);
A
Andy Fleming 已提交
814 815 816 817
		phydev->irq = PHY_POLL;
		return 0;
	}

818
	return phy_enable_interrupts(phydev);
A
Andy Fleming 已提交
819 820 821
}
EXPORT_SYMBOL(phy_start_interrupts);

822 823 824 825
/**
 * phy_stop_interrupts - disable interrupts from a PHY device
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
826 827
int phy_stop_interrupts(struct phy_device *phydev)
{
S
Sergei Shtylyov 已提交
828
	int err = phy_disable_interrupts(phydev);
A
Andy Fleming 已提交
829 830 831 832

	if (err)
		phy_error(phydev);

833 834
	free_irq(phydev->irq, phydev);

A
Andy Fleming 已提交
835 836 837 838
	return err;
}
EXPORT_SYMBOL(phy_stop_interrupts);

839 840 841 842
/**
 * phy_stop - Bring down the PHY link, and stop checking the status
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
843 844
void phy_stop(struct phy_device *phydev)
{
845
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
846 847 848 849

	if (PHY_HALTED == phydev->state)
		goto out_unlock;

850 851
	if (phy_interrupt_is_valid(phydev))
		phy_disable_interrupts(phydev);
A
Andy Fleming 已提交
852

853 854
	phydev->state = PHY_HALTED;

A
Andy Fleming 已提交
855
out_unlock:
856
	mutex_unlock(&phydev->lock);
857

858 859
	phy_state_machine(&phydev->state_queue.work);

S
Sergei Shtylyov 已提交
860
	/* Cannot call flush_scheduled_work() here as desired because
861 862 863
	 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
	 * will not reenable interrupts.
	 */
A
Andy Fleming 已提交
864
}
S
Sergei Shtylyov 已提交
865
EXPORT_SYMBOL(phy_stop);
A
Andy Fleming 已提交
866

867 868 869
/**
 * phy_start - start or restart a PHY device
 * @phydev: target phy_device struct
A
Andy Fleming 已提交
870
 *
871
 * Description: Indicates the attached device's readiness to
A
Andy Fleming 已提交
872 873 874 875 876 877 878
 *   handle PHY-related work.  Used during startup to start the
 *   PHY, and after a call to phy_stop() to resume operation.
 *   Also used to indicate the MDIO bus has cleared an error
 *   condition.
 */
void phy_start(struct phy_device *phydev)
{
879 880
	int err = 0;

881
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
882 883

	switch (phydev->state) {
F
Florian Fainelli 已提交
884 885 886 887 888 889 890
	case PHY_STARTING:
		phydev->state = PHY_PENDING;
		break;
	case PHY_READY:
		phydev->state = PHY_UP;
		break;
	case PHY_HALTED:
R
Russell King 已提交
891
		/* if phy was suspended, bring the physical link up again */
892
		__phy_resume(phydev);
R
Russell King 已提交
893

894
		/* make sure interrupts are re-enabled for the PHY */
895
		if (phy_interrupt_is_valid(phydev)) {
896 897 898 899
			err = phy_enable_interrupts(phydev);
			if (err < 0)
				break;
		}
900

F
Florian Fainelli 已提交
901
		phydev->state = PHY_RESUMING;
902
		break;
F
Florian Fainelli 已提交
903 904
	default:
		break;
A
Andy Fleming 已提交
905
	}
906
	mutex_unlock(&phydev->lock);
907

908
	phy_trigger_machine(phydev);
A
Andy Fleming 已提交
909 910
}
EXPORT_SYMBOL(phy_start);
911

912 913 914 915
/**
 * phy_state_machine - Handle the state machine
 * @work: work_struct that describes the work to be done
 */
916
void phy_state_machine(struct work_struct *work)
917
{
918
	struct delayed_work *dwork = to_delayed_work(work);
919
	struct phy_device *phydev =
920
			container_of(dwork, struct phy_device, state_queue);
921
	bool needs_aneg = false, do_suspend = false;
922
	enum phy_state old_state;
923 924
	int err = 0;

925
	mutex_lock(&phydev->lock);
926

927 928
	old_state = phydev->state;

F
Florian Fainelli 已提交
929
	if (phydev->drv && phydev->drv->link_change_notify)
930 931
		phydev->drv->link_change_notify(phydev);

F
Florian Fainelli 已提交
932 933 934 935 936 937 938
	switch (phydev->state) {
	case PHY_DOWN:
	case PHY_STARTING:
	case PHY_READY:
	case PHY_PENDING:
		break;
	case PHY_UP:
939
		needs_aneg = true;
940

F
Florian Fainelli 已提交
941 942
		break;
	case PHY_NOLINK:
943 944 945 946
	case PHY_RUNNING:
	case PHY_CHANGELINK:
	case PHY_RESUMING:
		err = phy_check_link_status(phydev);
F
Florian Fainelli 已提交
947 948 949 950
		break;
	case PHY_FORCING:
		err = genphy_update_link(phydev);
		if (err)
951 952
			break;

F
Florian Fainelli 已提交
953 954
		if (phydev->link) {
			phydev->state = PHY_RUNNING;
955
			phy_link_up(phydev);
F
Florian Fainelli 已提交
956 957
		} else {
			if (0 == phydev->link_timeout--)
958
				needs_aneg = true;
959
			phy_link_down(phydev, false);
F
Florian Fainelli 已提交
960 961 962 963 964
		}
		break;
	case PHY_HALTED:
		if (phydev->link) {
			phydev->link = 0;
965
			phy_link_down(phydev, true);
966
			do_suspend = true;
F
Florian Fainelli 已提交
967 968
		}
		break;
969 970
	}

971
	mutex_unlock(&phydev->lock);
972 973

	if (needs_aneg)
974
		err = phy_start_aneg(phydev);
975
	else if (do_suspend)
976 977
		phy_suspend(phydev);

978 979 980
	if (err < 0)
		phy_error(phydev);

981 982 983 984
	if (old_state != phydev->state)
		phydev_dbg(phydev, "PHY state change %s -> %s\n",
			   phy_state_to_str(old_state),
			   phy_state_to_str(phydev->state));
985

986 987
	/* Only re-schedule a PHY state machine change if we are polling the
	 * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving
988 989 990 991 992
	 * between states from phy_mac_interrupt().
	 *
	 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
	 * state machine would be pointless and possibly error prone when
	 * called from phy_disconnect() synchronously.
993
	 */
994
	if (phy_polling_mode(phydev) && old_state != PHY_HALTED)
995
		phy_queue_state_machine(phydev, PHY_STATE_TIME);
996
}
997

998 999 1000 1001
/**
 * phy_mac_interrupt - MAC says the link has changed
 * @phydev: phy_device struct with changed link
 *
1002 1003
 * The MAC layer is able to indicate there has been a change in the PHY link
 * status. Trigger the state machine and work a work queue.
1004
 */
1005
void phy_mac_interrupt(struct phy_device *phydev)
1006
{
1007 1008
	/* Trigger a state machine change */
	queue_work(system_power_efficient_wq, &phydev->phy_queue);
1009 1010 1011
}
EXPORT_SYMBOL(phy_mac_interrupt);

1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
/**
 * phy_init_eee - init and check the EEE feature
 * @phydev: target phy_device struct
 * @clk_stop_enable: PHY may stop the clock during LPI
 *
 * Description: it checks if the Energy-Efficient Ethernet (EEE)
 * is supported by looking at the MMD registers 3.20 and 7.60/61
 * and it programs the MMD register 3.0 setting the "Clock stop enable"
 * bit if required.
 */
int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
{
F
Florian Fainelli 已提交
1024 1025 1026
	if (!phydev->drv)
		return -EIO;

1027 1028
	/* According to 802.3az,the EEE is supported only in full duplex-mode.
	 */
1029
	if (phydev->duplex == DUPLEX_FULL) {
1030 1031
		int eee_lp, eee_cap, eee_adv;
		u32 lp, cap, adv;
1032
		int status;
1033 1034 1035 1036 1037 1038 1039

		/* Read phy status to properly get the right settings */
		status = phy_read_status(phydev);
		if (status)
			return status;

		/* First check if the EEE ability is supported */
1040
		eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1041 1042
		if (eee_cap <= 0)
			goto eee_exit_err;
1043

1044
		cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1045
		if (!cap)
1046
			goto eee_exit_err;
1047 1048 1049 1050

		/* Check which link settings negotiated and verify it in
		 * the EEE advertising registers.
		 */
1051
		eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1052 1053
		if (eee_lp <= 0)
			goto eee_exit_err;
1054

1055
		eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1056 1057
		if (eee_adv <= 0)
			goto eee_exit_err;
1058

1059 1060
		adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
		lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
1061
		if (!phy_check_valid(phydev->speed, phydev->duplex, lp & adv))
1062
			goto eee_exit_err;
1063 1064 1065 1066 1067

		if (clk_stop_enable) {
			/* Configure the PHY to stop receiving xMII
			 * clock while it is signaling LPI.
			 */
1068
			int val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1);
1069 1070 1071 1072
			if (val < 0)
				return val;

			val |= MDIO_PCS_CTRL1_CLKSTOP_EN;
1073
			phy_write_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1, val);
1074 1075
		}

1076
		return 0; /* EEE supported */
1077
	}
1078
eee_exit_err:
1079
	return -EPROTONOSUPPORT;
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
}
EXPORT_SYMBOL(phy_init_eee);

/**
 * phy_get_eee_err - report the EEE wake error count
 * @phydev: target phy_device struct
 *
 * Description: it is to report the number of time where the PHY
 * failed to complete its normal wake sequence.
 */
int phy_get_eee_err(struct phy_device *phydev)
{
F
Florian Fainelli 已提交
1092 1093 1094
	if (!phydev->drv)
		return -EIO;

1095
	return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
}
EXPORT_SYMBOL(phy_get_eee_err);

/**
 * phy_ethtool_get_eee - get EEE supported and status
 * @phydev: target phy_device struct
 * @data: ethtool_eee data
 *
 * Description: it reportes the Supported/Advertisement/LP Advertisement
 * capabilities.
 */
int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
{
	int val;

F
Florian Fainelli 已提交
1111 1112 1113
	if (!phydev->drv)
		return -EIO;

1114
	/* Get Supported EEE */
1115
	val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1116 1117
	if (val < 0)
		return val;
1118
	data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1119 1120

	/* Get advertisement EEE */
1121
	val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1122 1123
	if (val < 0)
		return val;
1124
	data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1125 1126

	/* Get LP advertisement EEE */
1127
	val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1128 1129
	if (val < 0)
		return val;
1130
	data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144

	return 0;
}
EXPORT_SYMBOL(phy_ethtool_get_eee);

/**
 * phy_ethtool_set_eee - set EEE supported and status
 * @phydev: target phy_device struct
 * @data: ethtool_eee data
 *
 * Description: it is to program the Advertisement EEE register.
 */
int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
{
1145
	int cap, old_adv, adv, ret;
1146

F
Florian Fainelli 已提交
1147 1148 1149
	if (!phydev->drv)
		return -EIO;

1150 1151 1152 1153
	/* Get Supported EEE */
	cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
	if (cap < 0)
		return cap;
1154

1155 1156 1157 1158
	old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
	if (old_adv < 0)
		return old_adv;

1159
	adv = ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1160

1161 1162 1163
	/* Mask prohibited EEE modes */
	adv &= ~phydev->eee_broken_modes;

1164 1165 1166 1167 1168 1169 1170 1171
	if (old_adv != adv) {
		ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
		if (ret < 0)
			return ret;

		/* Restart autonegotiation so the new modes get sent to the
		 * link partner.
		 */
1172
		ret = phy_restart_aneg(phydev);
1173 1174 1175 1176 1177
		if (ret < 0)
			return ret;
	}

	return 0;
1178 1179
}
EXPORT_SYMBOL(phy_ethtool_set_eee);
1180 1181 1182

int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
{
F
Florian Fainelli 已提交
1183
	if (phydev->drv && phydev->drv->set_wol)
1184 1185 1186 1187 1188 1189 1190 1191
		return phydev->drv->set_wol(phydev, wol);

	return -EOPNOTSUPP;
}
EXPORT_SYMBOL(phy_ethtool_set_wol);

void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
{
F
Florian Fainelli 已提交
1192
	if (phydev->drv && phydev->drv->get_wol)
1193 1194 1195
		phydev->drv->get_wol(phydev, wol);
}
EXPORT_SYMBOL(phy_ethtool_get_wol);
1196 1197 1198 1199 1200 1201 1202 1203 1204

int phy_ethtool_get_link_ksettings(struct net_device *ndev,
				   struct ethtool_link_ksettings *cmd)
{
	struct phy_device *phydev = ndev->phydev;

	if (!phydev)
		return -ENODEV;

1205 1206 1207
	phy_ethtool_ksettings_get(phydev, cmd);

	return 0;
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
}
EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);

int phy_ethtool_set_link_ksettings(struct net_device *ndev,
				   const struct ethtool_link_ksettings *cmd)
{
	struct phy_device *phydev = ndev->phydev;

	if (!phydev)
		return -ENODEV;

	return phy_ethtool_ksettings_set(phydev, cmd);
}
EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1222 1223 1224 1225 1226 1227 1228 1229

int phy_ethtool_nway_reset(struct net_device *ndev)
{
	struct phy_device *phydev = ndev->phydev;

	if (!phydev)
		return -ENODEV;

F
Florian Fainelli 已提交
1230 1231 1232
	if (!phydev->drv)
		return -EIO;

1233
	return phy_restart_aneg(phydev);
1234 1235
}
EXPORT_SYMBOL(phy_ethtool_nway_reset);