phy.c 28.3 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * drivers/net/phy/phy.c
 *
 * Framework for configuring and reading PHY devices
 * Based on code in sungem_phy.c and gianfar_phy.c
 *
 * Author: Andy Fleming
 *
 * Copyright (c) 2004 Freescale Semiconductor, Inc.
10
 * Copyright (c) 2006, 2007  Maciej W. Rozycki
11 12 13 14 15 16 17
 *
 * 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 已提交
18 19 20

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/interrupt.h>
#include <linux/init.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>
36 37
#include <linux/timer.h>
#include <linux/workqueue.h>
38
#include <linux/mdio.h>
39

A
Arun Sharma 已提交
40
#include <linux/atomic.h>
41 42 43 44
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>

45 46 47
/**
 * phy_print_status - Convenience function to print out the current phy status
 * @phydev: the phy_device struct
A
Andy Fleming 已提交
48 49 50 51
 */
void phy_print_status(struct phy_device *phydev)
{
	if (phydev->link)
J
Joe Perches 已提交
52 53 54 55 56 57
		pr_info("%s - Link is Up - %d/%s\n",
			dev_name(&phydev->dev),
			phydev->speed,
			DUPLEX_FULL == phydev->duplex ? "Full" : "Half");
	else
		pr_info("%s - Link is Down\n", dev_name(&phydev->dev));
A
Andy Fleming 已提交
58 59
}
EXPORT_SYMBOL(phy_print_status);
60

61 62 63 64 65 66 67 68 69
/**
 * 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.
 *
 * Returns 0 on success on < 0 on error.
 */
70
static int phy_clear_interrupt(struct phy_device *phydev)
71 72 73 74 75 76 77 78 79
{
	int err = 0;

	if (phydev->drv->ack_interrupt)
		err = phydev->drv->ack_interrupt(phydev);

	return err;
}

80 81 82 83 84 85 86
/**
 * phy_config_interrupt - configure the PHY device for the requested interrupts
 * @phydev: the phy_device struct
 * @interrupts: interrupt flags to configure for this @phydev
 *
 * Returns 0 on success on < 0 on error.
 */
87
static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
88 89 90 91 92 93 94 95 96 97 98
{
	int err = 0;

	phydev->interrupts = interrupts;
	if (phydev->drv->config_intr)
		err = phydev->drv->config_intr(phydev);

	return err;
}


99 100 101
/**
 * phy_aneg_done - return auto-negotiation status
 * @phydev: target phy_device struct
102
 *
103
 * Description: Reads the status register and returns 0 either if
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
 *   auto-negotiation is incomplete, or if there was an error.
 *   Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
 */
static inline int phy_aneg_done(struct phy_device *phydev)
{
	int retval;

	retval = phy_read(phydev, MII_BMSR);

	return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
}

/* A structure for mapping a particular speed and duplex
 * combination to a particular SUPPORTED and ADVERTISED value */
struct phy_setting {
	int speed;
	int duplex;
	u32 setting;
};

/* A mapping of all SUPPORTED settings to speed/duplex */
125
static const struct phy_setting settings[] = {
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
	{
		.speed = 10000,
		.duplex = DUPLEX_FULL,
		.setting = SUPPORTED_10000baseT_Full,
	},
	{
		.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,
	},
};

163
#define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
164

165 166 167 168
/**
 * phy_find_setting - find a PHY settings array entry that matches speed & duplex
 * @speed: speed to match
 * @duplex: duplex to match
169
 *
170
 * Description: Searches the settings array for the setting which
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
 *   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.
 */
static inline int phy_find_setting(int speed, int duplex)
{
	int idx = 0;

	while (idx < ARRAY_SIZE(settings) &&
			(settings[idx].speed != speed ||
			settings[idx].duplex != duplex))
		idx++;

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

187 188 189 190
/**
 * 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
191
 *
192
 * Description: Returns the index of the first valid setting less
193 194 195 196 197 198 199 200 201 202 203 204
 *   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.
 */
static inline int phy_find_valid(int idx, u32 features)
{
	while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
		idx++;

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

205 206 207
/**
 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
 * @phydev: the target phy_device struct
208
 *
209
 * Description: Make sure the PHY is set to supported speeds and
210
 *   duplexes.  Drop down by one in this order:  1000/FULL,
211
 *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
212
 */
213
static void phy_sanitize_settings(struct phy_device *phydev)
214 215 216 217 218 219
{
	u32 features = phydev->supported;
	int idx;

	/* Sanitize settings based on PHY capabilities */
	if ((features & SUPPORTED_Autoneg) == 0)
220
		phydev->autoneg = AUTONEG_DISABLE;
221 222 223 224 225 226 227 228

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

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

229 230 231 232
/**
 * phy_ethtool_sset - generic ethtool sset function, handles all the details
 * @phydev: target phy_device struct
 * @cmd: ethtool_cmd
233 234 235 236 237 238
 *
 * 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
239
 *   care if ethtool tries to give us bad values.
240 241 242
 */
int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
{
243 244
	u32 speed = ethtool_cmd_speed(cmd);

245 246 247 248 249 250 251 252 253 254 255 256 257 258
	if (cmd->phy_address != phydev->addr)
		return -EINVAL;

	/* We make sure that we don't pass unsupported
	 * values in to the PHY */
	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;

259
	if (cmd->autoneg == AUTONEG_DISABLE &&
260 261 262
	    ((speed != SPEED_1000 &&
	      speed != SPEED_100 &&
	      speed != SPEED_10) ||
263 264
	     (cmd->duplex != DUPLEX_HALF &&
	      cmd->duplex != DUPLEX_FULL)))
265 266 267 268
		return -EINVAL;

	phydev->autoneg = cmd->autoneg;

269
	phydev->speed = speed;
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284

	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 已提交
285
EXPORT_SYMBOL(phy_ethtool_sset);
286 287 288 289 290 291

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

	cmd->advertising = phydev->advertising;
292
	cmd->lp_advertising = phydev->lp_advertising;
293

294
	ethtool_cmd_speed_set(cmd, phydev->speed);
295 296 297
	cmd->duplex = phydev->duplex;
	cmd->port = PORT_MII;
	cmd->phy_address = phydev->addr;
298 299
	cmd->transceiver = phy_is_internal(phydev) ?
		XCVR_INTERNAL : XCVR_EXTERNAL;
300 301 302 303
	cmd->autoneg = phydev->autoneg;

	return 0;
}
K
Kumar Gala 已提交
304
EXPORT_SYMBOL(phy_ethtool_gset);
305

306 307 308
/**
 * phy_mii_ioctl - generic PHY MII ioctl interface
 * @phydev: the phy_device struct
R
Randy Dunlap 已提交
309
 * @ifr: &struct ifreq for socket ioctl's
310 311 312
 * @cmd: ioctl cmd to execute
 *
 * Note that this function is currently incompatible with the
313
 * PHYCONTROL layer.  It changes registers without regard to
314
 * current state.  Use at own risk.
315 316
 */
int phy_mii_ioctl(struct phy_device *phydev,
317
		struct ifreq *ifr, int cmd)
318
{
319
	struct mii_ioctl_data *mii_data = if_mii(ifr);
320
	u16 val = mii_data->val_in;
321
	int ret = 0;
322 323 324 325

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

328
	case SIOCGMIIREG:
329 330
		mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id,
						 mii_data->reg_num);
331 332 333 334
		break;

	case SIOCSMIIREG:
		if (mii_data->phy_id == phydev->addr) {
F
Florian Fainelli 已提交
335
			switch (mii_data->reg_num) {
336
			case MII_BMCR:
337
				if ((val & (BMCR_RESET|BMCR_ANENABLE)) == 0)
338 339 340 341 342 343 344
					phydev->autoneg = AUTONEG_DISABLE;
				else
					phydev->autoneg = AUTONEG_ENABLE;
				if ((!phydev->autoneg) && (val & BMCR_FULLDPLX))
					phydev->duplex = DUPLEX_FULL;
				else
					phydev->duplex = DUPLEX_HALF;
345 346 347 348 349 350
				if ((!phydev->autoneg) &&
						(val & BMCR_SPEED1000))
					phydev->speed = SPEED_1000;
				else if ((!phydev->autoneg) &&
						(val & BMCR_SPEED100))
					phydev->speed = SPEED_100;
351 352 353 354 355 356 357 358 359 360
				break;
			case MII_ADVERTISE:
				phydev->advertising = val;
				break;
			default:
				/* do nothing */
				break;
			}
		}

361 362 363
		mdiobus_write(phydev->bus, mii_data->phy_id,
			      mii_data->reg_num, val);

364
		if (mii_data->reg_num == MII_BMCR &&
365
		    val & BMCR_RESET)
366
			ret = phy_init_hw(phydev);
367
		break;
368

369 370 371 372 373
	case SIOCSHWTSTAMP:
		if (phydev->drv->hwtstamp)
			return phydev->drv->hwtstamp(phydev, ifr);
		/* fall through */

374
	default:
L
Lennert Buytenhek 已提交
375
		return -EOPNOTSUPP;
376 377
	}

378
	return ret;
379
}
D
Domen Puncer 已提交
380
EXPORT_SYMBOL(phy_mii_ioctl);
381

382 383 384
/**
 * phy_start_aneg - start auto-negotiation for this PHY device
 * @phydev: the phy_device struct
A
Andy Fleming 已提交
385
 *
386 387 388 389
 * 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 已提交
390 391 392 393 394
 */
int phy_start_aneg(struct phy_device *phydev)
{
	int err;

395
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415

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

	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:
416
	mutex_unlock(&phydev->lock);
A
Andy Fleming 已提交
417 418 419 420 421
	return err;
}
EXPORT_SYMBOL(phy_start_aneg);


422 423 424 425
/**
 * phy_start_machine - start PHY state machine tracking
 * @phydev: the phy_device struct
 * @handler: callback function for state change notifications
426
 *
427
 * Description: The PHY infrastructure can run a state machine
428 429
 *   which tracks whether the PHY is starting up, negotiating,
 *   etc.  This function starts the timer which tracks the state
430 431
 *   of the PHY.  If you want to be notified when the state changes,
 *   pass in the callback @handler, otherwise, pass NULL.  If you
432
 *   want to maintain your own state machine, do not call this
433 434
 *   function.
 */
435 436 437 438 439
void phy_start_machine(struct phy_device *phydev,
		void (*handler)(struct net_device *))
{
	phydev->adjust_state = handler;

440
	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);
441 442
}

443 444 445
/**
 * phy_stop_machine - stop the PHY state machine tracking
 * @phydev: target phy_device struct
446
 *
447
 * Description: Stops the state machine timer, sets the state to UP
448
 *   (unless it wasn't up yet). This function must be called BEFORE
449 450 451 452
 *   phy_detach.
 */
void phy_stop_machine(struct phy_device *phydev)
{
453
	cancel_delayed_work_sync(&phydev->state_queue);
454

455
	mutex_lock(&phydev->lock);
456 457
	if (phydev->state > PHY_UP)
		phydev->state = PHY_UP;
458
	mutex_unlock(&phydev->lock);
459 460 461 462

	phydev->adjust_state = NULL;
}

463 464 465
/**
 * phy_error - enter HALTED state for this PHY device
 * @phydev: target phy_device struct
466 467 468 469 470 471
 *
 * 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 已提交
472
static void phy_error(struct phy_device *phydev)
473
{
474
	mutex_lock(&phydev->lock);
475
	phydev->state = PHY_HALTED;
476
	mutex_unlock(&phydev->lock);
477 478
}

479 480 481 482
/**
 * phy_interrupt - PHY interrupt handler
 * @irq: interrupt line
 * @phy_dat: phy_device pointer
A
Andy Fleming 已提交
483
 *
484
 * Description: When a PHY interrupt occurs, the handler disables
A
Andy Fleming 已提交
485 486
 * interrupts, and schedules a work task to clear the interrupt.
 */
487
static irqreturn_t phy_interrupt(int irq, void *phy_dat)
A
Andy Fleming 已提交
488 489 490
{
	struct phy_device *phydev = phy_dat;

491 492 493
	if (PHY_HALTED == phydev->state)
		return IRQ_NONE;		/* It can't be ours.  */

A
Andy Fleming 已提交
494 495 496 497 498
	/* 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
	 * interrupt, and then reenable the irq line. */
	disable_irq_nosync(irq);
499
	atomic_inc(&phydev->irq_disable);
A
Andy Fleming 已提交
500

501
	queue_work(system_power_efficient_wq, &phydev->phy_queue);
A
Andy Fleming 已提交
502 503 504 505

	return IRQ_HANDLED;
}

506 507 508 509
/**
 * phy_enable_interrupts - Enable the interrupts from the PHY side
 * @phydev: target phy_device struct
 */
510
static int phy_enable_interrupts(struct phy_device *phydev)
511 512 513
{
	int err;

A
Andy Fleming 已提交
514
	err = phy_clear_interrupt(phydev);
515

A
Andy Fleming 已提交
516 517
	if (err < 0)
		return err;
518

A
Andy Fleming 已提交
519
	err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
520 521 522 523

	return err;
}

524 525 526 527
/**
 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
 * @phydev: target phy_device struct
 */
528
static int phy_disable_interrupts(struct phy_device *phydev)
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
{
	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 已提交
551

552 553 554
/**
 * phy_start_interrupts - request and enable interrupts for a PHY device
 * @phydev: target phy_device struct
A
Andy Fleming 已提交
555
 *
556 557
 * Description: Request the interrupt for the given PHY.
 *   If this fails, then we set irq to PHY_POLL.
A
Andy Fleming 已提交
558 559
 *   Otherwise, we enable the interrupts in the PHY.
 *   This should only be called with a valid IRQ number.
560
 *   Returns 0 on success or < 0 on error.
A
Andy Fleming 已提交
561 562 563 564 565
 */
int phy_start_interrupts(struct phy_device *phydev)
{
	int err = 0;

566
	atomic_set(&phydev->irq_disable, 0);
A
Andy Fleming 已提交
567
	if (request_irq(phydev->irq, phy_interrupt,
568
				IRQF_SHARED,
A
Andy Fleming 已提交
569 570
				"phy_interrupt",
				phydev) < 0) {
J
Joe Perches 已提交
571 572
		pr_warn("%s: Can't get IRQ %d (PHY)\n",
			phydev->bus->name, phydev->irq);
A
Andy Fleming 已提交
573 574 575 576 577 578 579 580 581 582
		phydev->irq = PHY_POLL;
		return 0;
	}

	err = phy_enable_interrupts(phydev);

	return err;
}
EXPORT_SYMBOL(phy_start_interrupts);

583 584 585 586
/**
 * phy_stop_interrupts - disable interrupts from a PHY device
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
587 588 589 590 591 592 593 594 595
int phy_stop_interrupts(struct phy_device *phydev)
{
	int err;

	err = phy_disable_interrupts(phydev);

	if (err)
		phy_error(phydev);

596 597
	free_irq(phydev->irq, phydev);

598
	/*
599 600 601 602
	 * Cannot call flush_scheduled_work() here as desired because
	 * 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.
603
	 */
604
	cancel_work_sync(&phydev->phy_queue);
605 606 607 608 609 610 611
	/*
	 * If work indeed has been cancelled, disable_irq() will have
	 * 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 已提交
612 613 614 615 616 617

	return err;
}
EXPORT_SYMBOL(phy_stop_interrupts);


618 619 620 621
/**
 * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
 * @work: work_struct that describes the work to be done
 */
622
void phy_change(struct work_struct *work)
A
Andy Fleming 已提交
623 624
{
	int err;
D
David Howells 已提交
625 626
	struct phy_device *phydev =
		container_of(work, struct phy_device, phy_queue);
A
Andy Fleming 已提交
627

628 629 630 631
	if (phydev->drv->did_interrupt &&
	    !phydev->drv->did_interrupt(phydev))
		goto ignore;

A
Andy Fleming 已提交
632 633 634 635 636
	err = phy_disable_interrupts(phydev);

	if (err)
		goto phy_err;

637
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
638 639
	if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
		phydev->state = PHY_CHANGELINK;
640
	mutex_unlock(&phydev->lock);
A
Andy Fleming 已提交
641

642
	atomic_dec(&phydev->irq_disable);
A
Andy Fleming 已提交
643 644 645
	enable_irq(phydev->irq);

	/* Reenable interrupts */
646 647
	if (PHY_HALTED != phydev->state)
		err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
A
Andy Fleming 已提交
648 649 650 651

	if (err)
		goto irq_enable_err;

652 653
	/* reschedule state queue work to run as soon as possible */
	cancel_delayed_work_sync(&phydev->state_queue);
654
	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);
655

A
Andy Fleming 已提交
656 657
	return;

658 659 660 661 662
ignore:
	atomic_dec(&phydev->irq_disable);
	enable_irq(phydev->irq);
	return;

A
Andy Fleming 已提交
663 664
irq_enable_err:
	disable_irq(phydev->irq);
665
	atomic_inc(&phydev->irq_disable);
A
Andy Fleming 已提交
666 667 668 669
phy_err:
	phy_error(phydev);
}

670 671 672 673
/**
 * phy_stop - Bring down the PHY link, and stop checking the status
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
674 675
void phy_stop(struct phy_device *phydev)
{
676
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
677 678 679 680

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

681
	if (phy_interrupt_is_valid(phydev)) {
A
Andy Fleming 已提交
682 683 684
		/* Disable PHY Interrupts */
		phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);

685 686 687
		/* Clear any pending interrupts */
		phy_clear_interrupt(phydev);
	}
A
Andy Fleming 已提交
688

689 690
	phydev->state = PHY_HALTED;

A
Andy Fleming 已提交
691
out_unlock:
692
	mutex_unlock(&phydev->lock);
693 694 695 696 697 698

	/*
	 * Cannot call flush_scheduled_work() here as desired because
	 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
	 * will not reenable interrupts.
	 */
A
Andy Fleming 已提交
699 700 701
}


702 703 704
/**
 * phy_start - start or restart a PHY device
 * @phydev: target phy_device struct
A
Andy Fleming 已提交
705
 *
706
 * Description: Indicates the attached device's readiness to
A
Andy Fleming 已提交
707 708 709 710 711 712 713
 *   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)
{
714
	mutex_lock(&phydev->lock);
A
Andy Fleming 已提交
715 716

	switch (phydev->state) {
F
Florian Fainelli 已提交
717 718 719 720 721 722 723 724 725 726
	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 已提交
727
	}
728
	mutex_unlock(&phydev->lock);
A
Andy Fleming 已提交
729 730 731
}
EXPORT_SYMBOL(phy_stop);
EXPORT_SYMBOL(phy_start);
732

733 734 735 736
/**
 * phy_state_machine - Handle the state machine
 * @work: work_struct that describes the work to be done
 */
737
void phy_state_machine(struct work_struct *work)
738
{
739
	struct delayed_work *dwork = to_delayed_work(work);
740
	struct phy_device *phydev =
741
			container_of(dwork, struct phy_device, state_queue);
742
	int needs_aneg = 0, do_suspend = 0;
743 744
	int err = 0;

745
	mutex_lock(&phydev->lock);
746 747 748 749

	if (phydev->adjust_state)
		phydev->adjust_state(phydev->attached_dev);

F
Florian Fainelli 已提交
750 751 752 753 754 755 756 757
	switch (phydev->state) {
	case PHY_DOWN:
	case PHY_STARTING:
	case PHY_READY:
	case PHY_PENDING:
		break;
	case PHY_UP:
		needs_aneg = 1;
758

F
Florian Fainelli 已提交
759 760 761 762 763
		phydev->link_timeout = PHY_AN_TIMEOUT;

		break;
	case PHY_AN:
		err = phy_read_status(phydev);
764

F
Florian Fainelli 已提交
765
		if (err < 0)
766
			break;
767

F
Florian Fainelli 已提交
768 769 770 771 772 773 774 775
		/* If the link is down, give up on
		 * negotiation for now */
		if (!phydev->link) {
			phydev->state = PHY_NOLINK;
			netif_carrier_off(phydev->attached_dev);
			phydev->adjust_link(phydev->attached_dev);
			break;
		}
776

F
Florian Fainelli 已提交
777 778 779 780 781
		/* Check if negotiation is done.  Break
		 * if there's an error */
		err = phy_aneg_done(phydev);
		if (err < 0)
			break;
782

F
Florian Fainelli 已提交
783 784 785 786 787
		/* 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);
788

F
Florian Fainelli 已提交
789 790 791 792 793 794 795 796 797 798
		} else if (0 == phydev->link_timeout--) {
			needs_aneg = 1;
			/* If we have the magic_aneg bit,
			 * we try again */
			if (phydev->drv->flags & PHY_HAS_MAGICANEG)
				break;
		}
		break;
	case PHY_NOLINK:
		err = phy_read_status(phydev);
799

F
Florian Fainelli 已提交
800
		if (err)
801 802
			break;

F
Florian Fainelli 已提交
803 804 805 806 807 808 809 810
		if (phydev->link) {
			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);
811

F
Florian Fainelli 已提交
812
		if (err)
813 814
			break;

F
Florian Fainelli 已提交
815 816 817 818 819 820 821
		if (phydev->link) {
			phydev->state = PHY_RUNNING;
			netif_carrier_on(phydev->attached_dev);
		} else {
			if (0 == phydev->link_timeout--)
				needs_aneg = 1;
		}
822

F
Florian Fainelli 已提交
823 824 825 826 827 828 829 830 831 832 833
		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);
834

F
Florian Fainelli 已提交
835
		if (err)
836 837
			break;

F
Florian Fainelli 已提交
838 839 840 841 842 843 844
		if (phydev->link) {
			phydev->state = PHY_RUNNING;
			netif_carrier_on(phydev->attached_dev);
		} else {
			phydev->state = PHY_NOLINK;
			netif_carrier_off(phydev->attached_dev);
		}
845

F
Florian Fainelli 已提交
846
		phydev->adjust_link(phydev->attached_dev);
847

F
Florian Fainelli 已提交
848 849 850 851 852 853 854 855
		if (phy_interrupt_is_valid(phydev))
			err = phy_config_interrupt(phydev,
					PHY_INTERRUPT_ENABLED);
		break;
	case PHY_HALTED:
		if (phydev->link) {
			phydev->link = 0;
			netif_carrier_off(phydev->attached_dev);
856
			phydev->adjust_link(phydev->attached_dev);
F
Florian Fainelli 已提交
857 858 859 860
			do_suspend = 1;
		}
		break;
	case PHY_RESUMING:
861

F
Florian Fainelli 已提交
862
		err = phy_clear_interrupt(phydev);
863

F
Florian Fainelli 已提交
864 865
		if (err)
			break;
866

F
Florian Fainelli 已提交
867 868
		err = phy_config_interrupt(phydev,
				PHY_INTERRUPT_ENABLED);
869

F
Florian Fainelli 已提交
870 871
		if (err)
			break;
872

F
Florian Fainelli 已提交
873 874 875
		if (AUTONEG_ENABLE == phydev->autoneg) {
			err = phy_aneg_done(phydev);
			if (err < 0)
876 877
				break;

F
Florian Fainelli 已提交
878 879 880 881
			/* err > 0 if AN is done.
			 * Otherwise, it's 0, and we're
			 * still waiting for AN */
			if (err > 0) {
882 883 884 885 886 887 888 889 890 891
				err = phy_read_status(phydev);
				if (err)
					break;

				if (phydev->link) {
					phydev->state = PHY_RUNNING;
					netif_carrier_on(phydev->attached_dev);
				} else
					phydev->state = PHY_NOLINK;
				phydev->adjust_link(phydev->attached_dev);
F
Florian Fainelli 已提交
892 893 894
			} else {
				phydev->state = PHY_AN;
				phydev->link_timeout = PHY_AN_TIMEOUT;
895
			}
F
Florian Fainelli 已提交
896 897 898 899 900 901 902 903 904 905 906 907 908
		} else {
			err = phy_read_status(phydev);
			if (err)
				break;

			if (phydev->link) {
				phydev->state = PHY_RUNNING;
				netif_carrier_on(phydev->attached_dev);
			} else
				phydev->state = PHY_NOLINK;
			phydev->adjust_link(phydev->attached_dev);
		}
		break;
909 910
	}

911
	mutex_unlock(&phydev->lock);
912 913 914 915

	if (needs_aneg)
		err = phy_start_aneg(phydev);

916 917 918
	if (do_suspend)
		phy_suspend(phydev);

919 920 921
	if (err < 0)
		phy_error(phydev);

922 923
	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue,
			PHY_STATE_TIME * HZ);
924
}
925

926 927 928 929 930 931 932 933
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);

934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
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
 * @bus: the target MII bus
 * @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
 */
static int phy_read_mmd_indirect(struct mii_bus *bus, int prtad, int devad,
				 int addr)
{
	u32 ret;

	mmd_phy_indirect(bus, prtad, devad, addr);

	/* Read the content of the MMD's selected register */
	ret = bus->read(bus, addr, MII_MMD_DATA);

	return ret;
}

/**
 * phy_write_mmd_indirect - writes data to the MMD registers
 * @bus: the target MII bus
 * @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
 */
static void phy_write_mmd_indirect(struct mii_bus *bus, int prtad, int devad,
				   int addr, u32 data)
{
	mmd_phy_indirect(bus, prtad, devad, addr);

	/* Write the data into MMD's selected register */
	bus->write(bus, addr, MII_MMD_DATA, data);
}

/**
 * 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)
{
	int ret = -EPROTONOSUPPORT;

	/* 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
	 * or RGMII.
	 */
	if ((phydev->duplex == DUPLEX_FULL) &&
	    ((phydev->interface == PHY_INTERFACE_MODE_MII) ||
	    (phydev->interface == PHY_INTERFACE_MODE_GMII) ||
	    (phydev->interface == PHY_INTERFACE_MODE_RGMII))) {
		int eee_lp, eee_cap, eee_adv;
		u32 lp, cap, adv;
		int idx, status;

		/* 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 */
		eee_cap = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE,
						MDIO_MMD_PCS, phydev->addr);
		if (eee_cap < 0)
			return eee_cap;

1037
		cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
		if (!cap)
			goto eee_exit;

		/* Check which link settings negotiated and verify it in
		 * the EEE advertising registers.
		 */
		eee_lp = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE,
					       MDIO_MMD_AN, phydev->addr);
		if (eee_lp < 0)
			return eee_lp;

		eee_adv = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV,
						MDIO_MMD_AN, phydev->addr);
		if (eee_adv < 0)
			return eee_adv;

1054 1055
		adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
		lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
1056
		idx = phy_find_setting(phydev->speed, phydev->duplex);
1057
		if (!(lp & adv & settings[idx].setting))
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
			goto eee_exit;

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

			val |= MDIO_PCS_CTRL1_CLKSTOP_EN;
			phy_write_mmd_indirect(phydev->bus, MDIO_CTRL1,
					       MDIO_MMD_PCS, phydev->addr, val);
		}

		ret = 0; /* EEE supported */
	}

eee_exit:
	return ret;
}
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)
{
	return phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_WK_ERR,
				     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 */
	val = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE,
				    MDIO_MMD_PCS, phydev->addr);
	if (val < 0)
		return val;
1115
	data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1116 1117 1118 1119 1120 1121

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

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

	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)
{
	int val;

1146
	val = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
1147 1148 1149 1150 1151 1152
	phy_write_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, MDIO_MMD_AN,
			       phydev->addr, val);

	return 0;
}
EXPORT_SYMBOL(phy_ethtool_set_eee);
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168

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);