phy.c 30.3 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 33
#include <linux/timer.h>
#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
static const char *phy_speed_to_str(int speed)
{
	switch (speed) {
	case SPEED_10:
		return "10Mbps";
	case SPEED_100:
		return "100Mbps";
	case SPEED_1000:
		return "1Gbps";
	case SPEED_2500:
		return "2.5Gbps";
	case SPEED_10000:
		return "10Gbps";
	case SPEED_UNKNOWN:
		return "Unknown";
	default:
		return "Unsupported (update phy.c)";
	}
}

61 62 63
/**
 * phy_print_status - Convenience function to print out the current phy status
 * @phydev: the phy_device struct
A
Andy Fleming 已提交
64 65 66
 */
void phy_print_status(struct phy_device *phydev)
{
S
Sergei Shtylyov 已提交
67
	if (phydev->link) {
68
		netdev_info(phydev->attached_dev,
69 70
			"Link is Up - %s/%s - flow control %s\n",
			phy_speed_to_str(phydev->speed),
71 72
			DUPLEX_FULL == phydev->duplex ? "Full" : "Half",
			phydev->pause ? "rx/tx" : "off");
S
Sergei Shtylyov 已提交
73
	} else	{
74
		netdev_info(phydev->attached_dev, "Link is Down\n");
S
Sergei Shtylyov 已提交
75
	}
A
Andy Fleming 已提交
76 77
}
EXPORT_SYMBOL(phy_print_status);
78

79 80 81 82 83 84 85
/**
 * 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.
 *
86
 * Returns 0 on success or < 0 on error.
87
 */
88
static int phy_clear_interrupt(struct phy_device *phydev)
89 90
{
	if (phydev->drv->ack_interrupt)
91
		return phydev->drv->ack_interrupt(phydev);
92

93
	return 0;
94 95
}

96 97 98 99 100
/**
 * phy_config_interrupt - configure the PHY device for the requested interrupts
 * @phydev: the phy_device struct
 * @interrupts: interrupt flags to configure for this @phydev
 *
101
 * Returns 0 on success or < 0 on error.
102
 */
103
static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
104 105 106
{
	phydev->interrupts = interrupts;
	if (phydev->drv->config_intr)
107
		return phydev->drv->config_intr(phydev);
108

109
	return 0;
110 111 112
}


113 114 115
/**
 * phy_aneg_done - return auto-negotiation status
 * @phydev: target phy_device struct
116
 *
117 118 119
 * 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.
120 121 122
 */
static inline int phy_aneg_done(struct phy_device *phydev)
{
123 124 125
	if (phydev->drv->aneg_done)
		return phydev->drv->aneg_done(phydev);

126
	return genphy_aneg_done(phydev);
127 128 129
}

/* A structure for mapping a particular speed and duplex
S
Sergei Shtylyov 已提交
130 131
 * combination to a particular SUPPORTED and ADVERTISED value
 */
132 133 134 135 136 137 138
struct phy_setting {
	int speed;
	int duplex;
	u32 setting;
};

/* A mapping of all SUPPORTED settings to speed/duplex */
139
static const struct phy_setting settings[] = {
140
	{
141 142 143 144 145 146 147 148 149 150 151
		.speed = SPEED_10000,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_10000baseKR_Full,
	},
	{
		.speed = SPEED_10000,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_10000baseKX4_Full,
	},
	{
		.speed = SPEED_10000,
152 153 154
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_10000baseT_Full,
	},
155 156 157 158 159 160 161 162 163 164
	{
		.speed = SPEED_2500,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_2500baseX_Full,
	},
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_1000baseKX_Full,
	},
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_1000baseT_Full,
	},
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_HALF,
		.setting = SUPPORTED_1000baseT_Half,
	},
	{
		.speed = SPEED_100,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_100baseT_Full,
	},
	{
		.speed = SPEED_100,
		.duplex = DUPLEX_HALF,
		.setting = SUPPORTED_100baseT_Half,
	},
	{
		.speed = SPEED_10,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_10baseT_Full,
	},
	{
		.speed = SPEED_10,
		.duplex = DUPLEX_HALF,
		.setting = SUPPORTED_10baseT_Half,
	},
};

197
#define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
198

199 200 201 202
/**
 * phy_find_setting - find a PHY settings array entry that matches speed & duplex
 * @speed: speed to match
 * @duplex: duplex to match
203
 *
204
 * Description: Searches the settings array for the setting which
205 206 207 208
 *   matches the desired speed and duplex, and returns the index
 *   of that setting.  Returns the index of the last setting if
 *   none of the others match.
 */
209
static inline unsigned int phy_find_setting(int speed, int duplex)
210
{
211
	unsigned int idx = 0;
212 213

	while (idx < ARRAY_SIZE(settings) &&
S
Sergei Shtylyov 已提交
214
	       (settings[idx].speed != speed || settings[idx].duplex != duplex))
215 216 217 218 219
		idx++;

	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
}

220 221 222 223
/**
 * phy_find_valid - find a PHY setting that matches the requested features mask
 * @idx: The first index in settings[] to search
 * @features: A mask of the valid settings
224
 *
225
 * Description: Returns the index of the first valid setting less
226 227 228 229
 *   than or equal to the one pointed to by idx, as determined by
 *   the mask in features.  Returns the index of the last setting
 *   if nothing else matches.
 */
230
static inline unsigned int phy_find_valid(unsigned int idx, u32 features)
231 232 233 234 235 236 237
{
	while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
		idx++;

	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
}

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
/**
 * 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)
{
	unsigned int idx;

	idx = phy_find_valid(phy_find_setting(speed, duplex), features);

	return settings[idx].speed == speed && settings[idx].duplex == duplex &&
		(settings[idx].setting & features);
}

257 258 259
/**
 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
 * @phydev: the target phy_device struct
260
 *
261
 * Description: Make sure the PHY is set to supported speeds and
262
 *   duplexes.  Drop down by one in this order:  1000/FULL,
263
 *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
264
 */
265
static void phy_sanitize_settings(struct phy_device *phydev)
266 267
{
	u32 features = phydev->supported;
268
	unsigned int idx;
269 270 271

	/* Sanitize settings based on PHY capabilities */
	if ((features & SUPPORTED_Autoneg) == 0)
272
		phydev->autoneg = AUTONEG_DISABLE;
273 274 275 276 277 278 279 280

	idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),
			features);

	phydev->speed = settings[idx].speed;
	phydev->duplex = settings[idx].duplex;
}

281 282 283 284
/**
 * phy_ethtool_sset - generic ethtool sset function, handles all the details
 * @phydev: target phy_device struct
 * @cmd: ethtool_cmd
285 286 287 288 289 290
 *
 * A few notes about parameter checking:
 * - 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
291
 *   care if ethtool tries to give us bad values.
292 293 294
 */
int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
{
295 296
	u32 speed = ethtool_cmd_speed(cmd);

297 298 299
	if (cmd->phy_address != phydev->addr)
		return -EINVAL;

S
Sergei Shtylyov 已提交
300
	/* We make sure that we don't pass unsupported values in to the PHY */
301 302 303 304 305 306 307 308 309
	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;

310
	if (cmd->autoneg == AUTONEG_DISABLE &&
311 312 313
	    ((speed != SPEED_1000 &&
	      speed != SPEED_100 &&
	      speed != SPEED_10) ||
314 315
	     (cmd->duplex != DUPLEX_HALF &&
	      cmd->duplex != DUPLEX_FULL)))
316 317 318 319
		return -EINVAL;

	phydev->autoneg = cmd->autoneg;

320
	phydev->speed = speed;
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335

	phydev->advertising = cmd->advertising;

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

	phydev->duplex = cmd->duplex;

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

	return 0;
}
K
Kumar Gala 已提交
336
EXPORT_SYMBOL(phy_ethtool_sset);
337 338 339 340 341 342

int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
{
	cmd->supported = phydev->supported;

	cmd->advertising = phydev->advertising;
343
	cmd->lp_advertising = phydev->lp_advertising;
344

345
	ethtool_cmd_speed_set(cmd, phydev->speed);
346
	cmd->duplex = phydev->duplex;
347 348 349 350
	if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
		cmd->port = PORT_BNC;
	else
		cmd->port = PORT_MII;
351
	cmd->phy_address = phydev->addr;
352 353
	cmd->transceiver = phy_is_internal(phydev) ?
		XCVR_INTERNAL : XCVR_EXTERNAL;
354 355 356 357
	cmd->autoneg = phydev->autoneg;

	return 0;
}
K
Kumar Gala 已提交
358
EXPORT_SYMBOL(phy_ethtool_gset);
359

360 361 362
/**
 * phy_mii_ioctl - generic PHY MII ioctl interface
 * @phydev: the phy_device struct
R
Randy Dunlap 已提交
363
 * @ifr: &struct ifreq for socket ioctl's
364 365 366
 * @cmd: ioctl cmd to execute
 *
 * Note that this function is currently incompatible with the
367
 * PHYCONTROL layer.  It changes registers without regard to
368
 * current state.  Use at own risk.
369
 */
S
Sergei Shtylyov 已提交
370
int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
371
{
372
	struct mii_ioctl_data *mii_data = if_mii(ifr);
373
	u16 val = mii_data->val_in;
374
	bool change_autoneg = false;
375 376 377 378

	switch (cmd) {
	case SIOCGMIIPHY:
		mii_data->phy_id = phydev->addr;
L
Lennert Buytenhek 已提交
379 380
		/* fall through */

381
	case SIOCGMIIREG:
382 383
		mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id,
						 mii_data->reg_num);
384
		return 0;
385 386 387

	case SIOCSMIIREG:
		if (mii_data->phy_id == phydev->addr) {
F
Florian Fainelli 已提交
388
			switch (mii_data->reg_num) {
389
			case MII_BMCR:
390 391 392
				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
					if (phydev->autoneg == AUTONEG_ENABLE)
						change_autoneg = true;
393
					phydev->autoneg = AUTONEG_DISABLE;
394 395 396 397 398 399 400 401 402 403 404 405 406
					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;
407
					phydev->autoneg = AUTONEG_ENABLE;
408
				}
409 410
				break;
			case MII_ADVERTISE:
411 412
				phydev->advertising = mii_adv_to_ethtool_adv_t(val);
				change_autoneg = true;
413 414 415 416 417 418 419
				break;
			default:
				/* do nothing */
				break;
			}
		}

420 421 422
		mdiobus_write(phydev->bus, mii_data->phy_id,
			      mii_data->reg_num, val);

423
		if (mii_data->reg_num == MII_BMCR &&
424
		    val & BMCR_RESET)
425
			return phy_init_hw(phydev);
426 427 428 429

		if (change_autoneg)
			return phy_start_aneg(phydev);

430
		return 0;
431

432 433 434 435 436
	case SIOCSHWTSTAMP:
		if (phydev->drv->hwtstamp)
			return phydev->drv->hwtstamp(phydev, ifr);
		/* fall through */

437
	default:
L
Lennert Buytenhek 已提交
438
		return -EOPNOTSUPP;
439 440
	}
}
D
Domen Puncer 已提交
441
EXPORT_SYMBOL(phy_mii_ioctl);
442

443 444 445
/**
 * phy_start_aneg - start auto-negotiation for this PHY device
 * @phydev: the phy_device struct
A
Andy Fleming 已提交
446
 *
447 448 449 450
 * 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 已提交
451 452 453 454 455
 */
int phy_start_aneg(struct phy_device *phydev)
{
	int err;

456
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
457 458 459 460

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

461 462 463
	/* Invalidate LP advertising flags */
	phydev->lp_advertising = 0;

A
Andy Fleming 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
	err = phydev->drv->config_aneg(phydev);
	if (err < 0)
		goto out_unlock;

	if (phydev->state != PHY_HALTED) {
		if (AUTONEG_ENABLE == phydev->autoneg) {
			phydev->state = PHY_AN;
			phydev->link_timeout = PHY_AN_TIMEOUT;
		} else {
			phydev->state = PHY_FORCING;
			phydev->link_timeout = PHY_FORCE_TIMEOUT;
		}
	}

out_unlock:
479
	mutex_unlock(&phydev->lock);
A
Andy Fleming 已提交
480 481 482 483
	return err;
}
EXPORT_SYMBOL(phy_start_aneg);

484 485 486
/**
 * phy_start_machine - start PHY state machine tracking
 * @phydev: the phy_device struct
487
 *
488
 * Description: The PHY infrastructure can run a state machine
489 490
 *   which tracks whether the PHY is starting up, negotiating,
 *   etc.  This function starts the timer which tracks the state
491 492
 *   of the PHY.  If you want to maintain your own state machine,
 *   do not call this function.
493
 */
494
void phy_start_machine(struct phy_device *phydev)
495
{
496
	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);
497 498
}

499 500 501
/**
 * phy_stop_machine - stop the PHY state machine tracking
 * @phydev: target phy_device struct
502
 *
503
 * Description: Stops the state machine timer, sets the state to UP
504
 *   (unless it wasn't up yet). This function must be called BEFORE
505 506 507 508
 *   phy_detach.
 */
void phy_stop_machine(struct phy_device *phydev)
{
509
	cancel_delayed_work_sync(&phydev->state_queue);
510

511
	mutex_lock(&phydev->lock);
512 513
	if (phydev->state > PHY_UP)
		phydev->state = PHY_UP;
514
	mutex_unlock(&phydev->lock);
515 516
}

517 518 519
/**
 * phy_error - enter HALTED state for this PHY device
 * @phydev: target phy_device struct
520 521 522 523 524 525
 *
 * 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 已提交
526
static void phy_error(struct phy_device *phydev)
527
{
528
	mutex_lock(&phydev->lock);
529
	phydev->state = PHY_HALTED;
530
	mutex_unlock(&phydev->lock);
531 532
}

533 534 535 536
/**
 * phy_interrupt - PHY interrupt handler
 * @irq: interrupt line
 * @phy_dat: phy_device pointer
A
Andy Fleming 已提交
537
 *
538
 * Description: When a PHY interrupt occurs, the handler disables
A
Andy Fleming 已提交
539 540
 * interrupts, and schedules a work task to clear the interrupt.
 */
541
static irqreturn_t phy_interrupt(int irq, void *phy_dat)
A
Andy Fleming 已提交
542 543 544
{
	struct phy_device *phydev = phy_dat;

545 546 547
	if (PHY_HALTED == phydev->state)
		return IRQ_NONE;		/* It can't be ours.  */

A
Andy Fleming 已提交
548 549 550
	/* The MDIO bus is not allowed to be written in interrupt
	 * context, so we need to disable the irq here.  A work
	 * queue will write the PHY to disable and clear the
S
Sergei Shtylyov 已提交
551 552
	 * interrupt, and then reenable the irq line.
	 */
A
Andy Fleming 已提交
553
	disable_irq_nosync(irq);
554
	atomic_inc(&phydev->irq_disable);
A
Andy Fleming 已提交
555

556
	queue_work(system_power_efficient_wq, &phydev->phy_queue);
A
Andy Fleming 已提交
557 558 559 560

	return IRQ_HANDLED;
}

561 562 563 564
/**
 * phy_enable_interrupts - Enable the interrupts from the PHY side
 * @phydev: target phy_device struct
 */
565
static int phy_enable_interrupts(struct phy_device *phydev)
566
{
S
Sergei Shtylyov 已提交
567
	int err = phy_clear_interrupt(phydev);
568

A
Andy Fleming 已提交
569 570
	if (err < 0)
		return err;
571

S
Sergei Shtylyov 已提交
572
	return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
573 574
}

575 576 577 578
/**
 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
 * @phydev: target phy_device struct
 */
579
static int phy_disable_interrupts(struct phy_device *phydev)
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
{
	int err;

	/* Disable PHY interrupts */
	err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
	if (err)
		goto phy_err;

	/* Clear the interrupt */
	err = phy_clear_interrupt(phydev);
	if (err)
		goto phy_err;

	return 0;

phy_err:
	phy_error(phydev);

	return err;
}
A
Andy Fleming 已提交
600

601 602 603
/**
 * phy_start_interrupts - request and enable interrupts for a PHY device
 * @phydev: target phy_device struct
A
Andy Fleming 已提交
604
 *
605 606
 * Description: Request the interrupt for the given PHY.
 *   If this fails, then we set irq to PHY_POLL.
A
Andy Fleming 已提交
607 608
 *   Otherwise, we enable the interrupts in the PHY.
 *   This should only be called with a valid IRQ number.
609
 *   Returns 0 on success or < 0 on error.
A
Andy Fleming 已提交
610 611 612
 */
int phy_start_interrupts(struct phy_device *phydev)
{
613
	atomic_set(&phydev->irq_disable, 0);
S
Sergei Shtylyov 已提交
614 615
	if (request_irq(phydev->irq, phy_interrupt, 0, "phy_interrupt",
			phydev) < 0) {
J
Joe Perches 已提交
616 617
		pr_warn("%s: Can't get IRQ %d (PHY)\n",
			phydev->bus->name, phydev->irq);
A
Andy Fleming 已提交
618 619 620 621
		phydev->irq = PHY_POLL;
		return 0;
	}

622
	return phy_enable_interrupts(phydev);
A
Andy Fleming 已提交
623 624 625
}
EXPORT_SYMBOL(phy_start_interrupts);

626 627 628 629
/**
 * phy_stop_interrupts - disable interrupts from a PHY device
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
630 631
int phy_stop_interrupts(struct phy_device *phydev)
{
S
Sergei Shtylyov 已提交
632
	int err = phy_disable_interrupts(phydev);
A
Andy Fleming 已提交
633 634 635 636

	if (err)
		phy_error(phydev);

637 638
	free_irq(phydev->irq, phydev);

S
Sergei Shtylyov 已提交
639
	/* Cannot call flush_scheduled_work() here as desired because
640 641 642
	 * of rtnl_lock(), but we do not really care about what would
	 * be done, except from enable_irq(), so cancel any work
	 * possibly pending and take care of the matter below.
643
	 */
644
	cancel_work_sync(&phydev->phy_queue);
S
Sergei Shtylyov 已提交
645
	/* If work indeed has been cancelled, disable_irq() will have
646 647 648 649 650
	 * been left unbalanced from phy_interrupt() and enable_irq()
	 * has to be called so that other devices on the line work.
	 */
	while (atomic_dec_return(&phydev->irq_disable) >= 0)
		enable_irq(phydev->irq);
A
Andy Fleming 已提交
651 652 653 654 655

	return err;
}
EXPORT_SYMBOL(phy_stop_interrupts);

656 657 658 659
/**
 * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
 * @work: work_struct that describes the work to be done
 */
660
void phy_change(struct work_struct *work)
A
Andy Fleming 已提交
661
{
D
David Howells 已提交
662 663
	struct phy_device *phydev =
		container_of(work, struct phy_device, phy_queue);
A
Andy Fleming 已提交
664

665 666 667 668
	if (phydev->drv->did_interrupt &&
	    !phydev->drv->did_interrupt(phydev))
		goto ignore;

669
	if (phy_disable_interrupts(phydev))
A
Andy Fleming 已提交
670 671
		goto phy_err;

672
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
673 674
	if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
		phydev->state = PHY_CHANGELINK;
675
	mutex_unlock(&phydev->lock);
A
Andy Fleming 已提交
676

677
	atomic_dec(&phydev->irq_disable);
A
Andy Fleming 已提交
678 679 680
	enable_irq(phydev->irq);

	/* Reenable interrupts */
681 682
	if (PHY_HALTED != phydev->state &&
	    phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED))
A
Andy Fleming 已提交
683 684
		goto irq_enable_err;

685 686
	/* reschedule state queue work to run as soon as possible */
	cancel_delayed_work_sync(&phydev->state_queue);
687
	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);
A
Andy Fleming 已提交
688 689
	return;

690 691 692 693 694
ignore:
	atomic_dec(&phydev->irq_disable);
	enable_irq(phydev->irq);
	return;

A
Andy Fleming 已提交
695 696
irq_enable_err:
	disable_irq(phydev->irq);
697
	atomic_inc(&phydev->irq_disable);
A
Andy Fleming 已提交
698 699 700 701
phy_err:
	phy_error(phydev);
}

702 703 704 705
/**
 * phy_stop - Bring down the PHY link, and stop checking the status
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
706 707
void phy_stop(struct phy_device *phydev)
{
708
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
709 710 711 712

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

713
	if (phy_interrupt_is_valid(phydev)) {
A
Andy Fleming 已提交
714 715 716
		/* Disable PHY Interrupts */
		phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);

717 718 719
		/* Clear any pending interrupts */
		phy_clear_interrupt(phydev);
	}
A
Andy Fleming 已提交
720

721 722
	phydev->state = PHY_HALTED;

A
Andy Fleming 已提交
723
out_unlock:
724
	mutex_unlock(&phydev->lock);
725

S
Sergei Shtylyov 已提交
726
	/* Cannot call flush_scheduled_work() here as desired because
727 728 729
	 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
	 * will not reenable interrupts.
	 */
A
Andy Fleming 已提交
730
}
S
Sergei Shtylyov 已提交
731
EXPORT_SYMBOL(phy_stop);
A
Andy Fleming 已提交
732

733 734 735
/**
 * phy_start - start or restart a PHY device
 * @phydev: target phy_device struct
A
Andy Fleming 已提交
736
 *
737
 * Description: Indicates the attached device's readiness to
A
Andy Fleming 已提交
738 739 740 741 742 743 744
 *   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)
{
745
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
746 747

	switch (phydev->state) {
F
Florian Fainelli 已提交
748 749 750 751 752 753 754 755 756 757
	case PHY_STARTING:
		phydev->state = PHY_PENDING;
		break;
	case PHY_READY:
		phydev->state = PHY_UP;
		break;
	case PHY_HALTED:
		phydev->state = PHY_RESUMING;
	default:
		break;
A
Andy Fleming 已提交
758
	}
759
	mutex_unlock(&phydev->lock);
A
Andy Fleming 已提交
760 761
}
EXPORT_SYMBOL(phy_start);
762

763 764 765 766
/**
 * phy_state_machine - Handle the state machine
 * @work: work_struct that describes the work to be done
 */
767
void phy_state_machine(struct work_struct *work)
768
{
769
	struct delayed_work *dwork = to_delayed_work(work);
770
	struct phy_device *phydev =
771
			container_of(dwork, struct phy_device, state_queue);
772
	bool needs_aneg = false, do_suspend = false, do_resume = false;
773 774
	int err = 0;

775
	mutex_lock(&phydev->lock);
776

777 778 779
	if (phydev->drv->link_change_notify)
		phydev->drv->link_change_notify(phydev);

F
Florian Fainelli 已提交
780 781 782 783 784 785 786
	switch (phydev->state) {
	case PHY_DOWN:
	case PHY_STARTING:
	case PHY_READY:
	case PHY_PENDING:
		break;
	case PHY_UP:
787
		needs_aneg = true;
788

F
Florian Fainelli 已提交
789 790 791 792 793 794
		phydev->link_timeout = PHY_AN_TIMEOUT;

		break;
	case PHY_AN:
		err = phy_read_status(phydev);
		if (err < 0)
795
			break;
796

S
Sergei Shtylyov 已提交
797
		/* If the link is down, give up on negotiation for now */
F
Florian Fainelli 已提交
798 799 800 801 802 803
		if (!phydev->link) {
			phydev->state = PHY_NOLINK;
			netif_carrier_off(phydev->attached_dev);
			phydev->adjust_link(phydev->attached_dev);
			break;
		}
804

S
Sergei Shtylyov 已提交
805
		/* Check if negotiation is done.  Break if there's an error */
F
Florian Fainelli 已提交
806 807 808
		err = phy_aneg_done(phydev);
		if (err < 0)
			break;
809

F
Florian Fainelli 已提交
810 811 812 813 814
		/* If AN is done, we're running */
		if (err > 0) {
			phydev->state = PHY_RUNNING;
			netif_carrier_on(phydev->attached_dev);
			phydev->adjust_link(phydev->attached_dev);
815

816
		} else if (0 == phydev->link_timeout--)
817
			needs_aneg = true;
F
Florian Fainelli 已提交
818 819 820 821
		break;
	case PHY_NOLINK:
		err = phy_read_status(phydev);
		if (err)
822 823
			break;

F
Florian Fainelli 已提交
824
		if (phydev->link) {
825 826 827 828 829 830 831 832 833 834 835
			if (AUTONEG_ENABLE == phydev->autoneg) {
				err = phy_aneg_done(phydev);
				if (err < 0)
					break;

				if (!err) {
					phydev->state = PHY_AN;
					phydev->link_timeout = PHY_AN_TIMEOUT;
					break;
				}
			}
F
Florian Fainelli 已提交
836 837 838 839 840 841 842 843
			phydev->state = PHY_RUNNING;
			netif_carrier_on(phydev->attached_dev);
			phydev->adjust_link(phydev->attached_dev);
		}
		break;
	case PHY_FORCING:
		err = genphy_update_link(phydev);
		if (err)
844 845
			break;

F
Florian Fainelli 已提交
846 847 848 849 850
		if (phydev->link) {
			phydev->state = PHY_RUNNING;
			netif_carrier_on(phydev->attached_dev);
		} else {
			if (0 == phydev->link_timeout--)
851
				needs_aneg = true;
F
Florian Fainelli 已提交
852
		}
853

F
Florian Fainelli 已提交
854 855 856 857 858 859 860 861 862 863 864 865
		phydev->adjust_link(phydev->attached_dev);
		break;
	case PHY_RUNNING:
		/* Only register a CHANGE if we are
		 * polling or ignoring interrupts
		 */
		if (!phy_interrupt_is_valid(phydev))
			phydev->state = PHY_CHANGELINK;
		break;
	case PHY_CHANGELINK:
		err = phy_read_status(phydev);
		if (err)
866 867
			break;

F
Florian Fainelli 已提交
868 869 870 871 872 873 874
		if (phydev->link) {
			phydev->state = PHY_RUNNING;
			netif_carrier_on(phydev->attached_dev);
		} else {
			phydev->state = PHY_NOLINK;
			netif_carrier_off(phydev->attached_dev);
		}
875

F
Florian Fainelli 已提交
876
		phydev->adjust_link(phydev->attached_dev);
877

F
Florian Fainelli 已提交
878 879
		if (phy_interrupt_is_valid(phydev))
			err = phy_config_interrupt(phydev,
S
Sergei Shtylyov 已提交
880
						   PHY_INTERRUPT_ENABLED);
F
Florian Fainelli 已提交
881 882 883 884 885
		break;
	case PHY_HALTED:
		if (phydev->link) {
			phydev->link = 0;
			netif_carrier_off(phydev->attached_dev);
886
			phydev->adjust_link(phydev->attached_dev);
887
			do_suspend = true;
F
Florian Fainelli 已提交
888 889 890 891 892 893
		}
		break;
	case PHY_RESUMING:
		err = phy_clear_interrupt(phydev);
		if (err)
			break;
894

S
Sergei Shtylyov 已提交
895
		err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
F
Florian Fainelli 已提交
896 897
		if (err)
			break;
898

F
Florian Fainelli 已提交
899 900 901
		if (AUTONEG_ENABLE == phydev->autoneg) {
			err = phy_aneg_done(phydev);
			if (err < 0)
902 903
				break;

F
Florian Fainelli 已提交
904
			/* err > 0 if AN is done.
S
Sergei Shtylyov 已提交
905 906
			 * Otherwise, it's 0, and we're  still waiting for AN
			 */
F
Florian Fainelli 已提交
907
			if (err > 0) {
908 909 910 911 912 913 914
				err = phy_read_status(phydev);
				if (err)
					break;

				if (phydev->link) {
					phydev->state = PHY_RUNNING;
					netif_carrier_on(phydev->attached_dev);
S
Sergei Shtylyov 已提交
915
				} else	{
916
					phydev->state = PHY_NOLINK;
S
Sergei Shtylyov 已提交
917
				}
918
				phydev->adjust_link(phydev->attached_dev);
F
Florian Fainelli 已提交
919 920 921
			} else {
				phydev->state = PHY_AN;
				phydev->link_timeout = PHY_AN_TIMEOUT;
922
			}
F
Florian Fainelli 已提交
923 924 925 926 927 928 929 930
		} else {
			err = phy_read_status(phydev);
			if (err)
				break;

			if (phydev->link) {
				phydev->state = PHY_RUNNING;
				netif_carrier_on(phydev->attached_dev);
S
Sergei Shtylyov 已提交
931
			} else	{
F
Florian Fainelli 已提交
932
				phydev->state = PHY_NOLINK;
S
Sergei Shtylyov 已提交
933
			}
F
Florian Fainelli 已提交
934 935
			phydev->adjust_link(phydev->attached_dev);
		}
936
		do_resume = true;
F
Florian Fainelli 已提交
937
		break;
938 939
	}

940
	mutex_unlock(&phydev->lock);
941 942 943

	if (needs_aneg)
		err = phy_start_aneg(phydev);
944
	else if (do_suspend)
945
		phy_suspend(phydev);
946 947
	else if (do_resume)
		phy_resume(phydev);
948

949 950 951
	if (err < 0)
		phy_error(phydev);

952
	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue,
S
Sergei Shtylyov 已提交
953
			   PHY_STATE_TIME * HZ);
954
}
955

956 957 958 959 960 961 962 963
void phy_mac_interrupt(struct phy_device *phydev, int new_link)
{
	cancel_work_sync(&phydev->phy_queue);
	phydev->link = new_link;
	schedule_work(&phydev->phy_queue);
}
EXPORT_SYMBOL(phy_mac_interrupt);

964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad,
				    int addr)
{
	/* Write the desired MMD Devad */
	bus->write(bus, addr, MII_MMD_CTRL, devad);

	/* Write the desired MMD register address */
	bus->write(bus, addr, MII_MMD_DATA, prtad);

	/* Select the Function : DATA with no post increment */
	bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR));
}

/**
 * phy_read_mmd_indirect - reads data from the MMD registers
979
 * @phydev: The PHY device bus
980 981 982 983 984 985 986 987 988 989 990 991
 * @prtad: MMD Address
 * @devad: MMD DEVAD
 * @addr: PHY address on the MII bus
 *
 * Description: it reads data from the MMD registers (clause 22 to access to
 * clause 45) of the specified phy address.
 * To read these register we have:
 * 1) Write reg 13 // DEVAD
 * 2) Write reg 14 // MMD Address
 * 3) Write reg 13 // MMD Data Command for MMD DEVAD
 * 3) Read  reg 14 // Read MMD data
 */
992
int phy_read_mmd_indirect(struct phy_device *phydev, int prtad,
993
				 int devad, int addr)
994
{
995 996
	struct phy_driver *phydrv = phydev->drv;
	int value = -1;
997

998 999 1000 1001 1002 1003 1004 1005 1006
	if (phydrv->read_mmd_indirect == NULL) {
		mmd_phy_indirect(phydev->bus, prtad, devad, addr);

		/* Read the content of the MMD's selected register */
		value = phydev->bus->read(phydev->bus, addr, MII_MMD_DATA);
	} else {
		value = phydrv->read_mmd_indirect(phydev, prtad, devad, addr);
	}
	return value;
1007
}
1008
EXPORT_SYMBOL(phy_read_mmd_indirect);
1009 1010 1011

/**
 * phy_write_mmd_indirect - writes data to the MMD registers
1012
 * @phydev: The PHY device
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
 * @prtad: MMD Address
 * @devad: MMD DEVAD
 * @addr: PHY address on the MII bus
 * @data: data to write in the MMD register
 *
 * Description: Write data from the MMD registers of the specified
 * phy address.
 * To write these register we have:
 * 1) Write reg 13 // DEVAD
 * 2) Write reg 14 // MMD Address
 * 3) Write reg 13 // MMD Data Command for MMD DEVAD
 * 3) Write reg 14 // Write MMD data
 */
1026
void phy_write_mmd_indirect(struct phy_device *phydev, int prtad,
1027
				   int devad, int addr, u32 data)
1028
{
1029
	struct phy_driver *phydrv = phydev->drv;
1030

1031 1032 1033 1034 1035 1036 1037 1038
	if (phydrv->write_mmd_indirect == NULL) {
		mmd_phy_indirect(phydev->bus, prtad, devad, addr);

		/* Write the data into MMD's selected register */
		phydev->bus->write(phydev->bus, addr, MII_MMD_DATA, data);
	} else {
		phydrv->write_mmd_indirect(phydev, prtad, devad, addr, data);
	}
1039
}
1040
EXPORT_SYMBOL(phy_write_mmd_indirect);
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055

/**
 * 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)
{
	/* According to 802.3az,the EEE is supported only in full duplex-mode.
	 * Also EEE feature is active when core is operating with MII, GMII
1056 1057
	 * or RGMII. Internal PHYs are also allowed to proceed and should
	 * return an error if they do not support EEE.
1058 1059 1060 1061
	 */
	if ((phydev->duplex == DUPLEX_FULL) &&
	    ((phydev->interface == PHY_INTERFACE_MODE_MII) ||
	    (phydev->interface == PHY_INTERFACE_MODE_GMII) ||
1062 1063
	    (phydev->interface == PHY_INTERFACE_MODE_RGMII) ||
	     phy_is_internal(phydev))) {
1064 1065
		int eee_lp, eee_cap, eee_adv;
		u32 lp, cap, adv;
1066
		int status;
1067 1068 1069 1070 1071 1072 1073

		/* 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 */
1074
		eee_cap = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE,
1075
						MDIO_MMD_PCS, phydev->addr);
1076 1077
		if (eee_cap <= 0)
			goto eee_exit_err;
1078

1079
		cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1080
		if (!cap)
1081
			goto eee_exit_err;
1082 1083 1084 1085

		/* Check which link settings negotiated and verify it in
		 * the EEE advertising registers.
		 */
1086
		eee_lp = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE,
1087
					       MDIO_MMD_AN, phydev->addr);
1088 1089
		if (eee_lp <= 0)
			goto eee_exit_err;
1090

1091
		eee_adv = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV,
1092
						MDIO_MMD_AN, phydev->addr);
1093 1094
		if (eee_adv <= 0)
			goto eee_exit_err;
1095

1096 1097
		adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
		lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
1098
		if (!phy_check_valid(phydev->speed, phydev->duplex, lp & adv))
1099
			goto eee_exit_err;
1100 1101 1102 1103 1104

		if (clk_stop_enable) {
			/* Configure the PHY to stop receiving xMII
			 * clock while it is signaling LPI.
			 */
1105
			int val = phy_read_mmd_indirect(phydev, MDIO_CTRL1,
1106 1107 1108 1109 1110 1111
							MDIO_MMD_PCS,
							phydev->addr);
			if (val < 0)
				return val;

			val |= MDIO_PCS_CTRL1_CLKSTOP_EN;
1112 1113 1114
			phy_write_mmd_indirect(phydev, MDIO_CTRL1,
					       MDIO_MMD_PCS, phydev->addr,
					       val);
1115 1116
		}

1117
		return 0; /* EEE supported */
1118
	}
1119
eee_exit_err:
1120
	return -EPROTONOSUPPORT;
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
}
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)
{
1133
	return phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_WK_ERR,
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
				     MDIO_MMD_PCS, phydev->addr);
}
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;

	/* Get Supported EEE */
1151
	val = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE,
1152 1153 1154
				    MDIO_MMD_PCS, phydev->addr);
	if (val < 0)
		return val;
1155
	data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1156 1157

	/* Get advertisement EEE */
1158
	val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV,
1159 1160 1161
				    MDIO_MMD_AN, phydev->addr);
	if (val < 0)
		return val;
1162
	data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1163 1164

	/* Get LP advertisement EEE */
1165
	val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE,
1166 1167 1168
				    MDIO_MMD_AN, phydev->addr);
	if (val < 0)
		return val;
1169
	data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183

	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)
{
S
Sergei Shtylyov 已提交
1184
	int val = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
1185

1186
	phy_write_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN,
1187 1188 1189 1190 1191
			       phydev->addr, val);

	return 0;
}
EXPORT_SYMBOL(phy_ethtool_set_eee);
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207

int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
{
	if (phydev->drv->set_wol)
		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)
{
	if (phydev->drv->get_wol)
		phydev->drv->get_wol(phydev, wol);
}
EXPORT_SYMBOL(phy_ethtool_get_wol);