phy_device.c 20.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/*
 * drivers/net/phy/phy_device.c
 *
 * Framework for finding and configuring PHYs.
 * Also contains generic PHY driver
 *
 * Author: Andy Fleming
 *
 * Copyright (c) 2004 Freescale Semiconductor, Inc.
 *
 * 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.
 *
 */
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/slab.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>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>

38 39 40 41
MODULE_DESCRIPTION("PHY library");
MODULE_AUTHOR("Andy Fleming");
MODULE_LICENSE("GPL");

A
Andy Fleming 已提交
42 43 44
static struct phy_driver genphy_driver;
extern int mdio_bus_init(void);
extern void mdio_bus_exit(void);
45

46 47 48 49 50 51 52 53 54 55
void phy_device_free(struct phy_device *phydev)
{
	kfree(phydev);
}

static void phy_device_release(struct device *dev)
{
	phy_device_free(to_phy_device(dev));
}

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
static LIST_HEAD(phy_fixup_list);
static DEFINE_MUTEX(phy_fixup_lock);

/*
 * Creates a new phy_fixup and adds it to the list
 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
 * 	It can also be PHY_ANY_UID
 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
 * 	comparison
 * @run: The actual code to be run when a matching PHY is found
 */
int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
		int (*run)(struct phy_device *))
{
	struct phy_fixup *fixup;

	fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);
	if (!fixup)
		return -ENOMEM;

	strncpy(fixup->bus_id, bus_id, BUS_ID_SIZE);
	fixup->phy_uid = phy_uid;
	fixup->phy_uid_mask = phy_uid_mask;
	fixup->run = run;

	mutex_lock(&phy_fixup_lock);
	list_add_tail(&fixup->list, &phy_fixup_list);
	mutex_unlock(&phy_fixup_lock);

	return 0;
}
EXPORT_SYMBOL(phy_register_fixup);

/* Registers a fixup to be run on any PHY with the UID in phy_uid */
int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
		int (*run)(struct phy_device *))
{
	return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
}
EXPORT_SYMBOL(phy_register_fixup_for_uid);

/* Registers a fixup to be run on the PHY with id string bus_id */
int phy_register_fixup_for_id(const char *bus_id,
		int (*run)(struct phy_device *))
{
	return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
}
EXPORT_SYMBOL(phy_register_fixup_for_id);

/*
 * Returns 1 if fixup matches phydev in bus_id and phy_uid.
 * Fixups can be set to match any in one or more fields.
 */
static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
{
	if (strcmp(fixup->bus_id, phydev->dev.bus_id) != 0)
		if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
			return 0;

	if ((fixup->phy_uid & fixup->phy_uid_mask) !=
			(phydev->phy_id & fixup->phy_uid_mask))
		if (fixup->phy_uid != PHY_ANY_UID)
			return 0;

	return 1;
}

/* Runs any matching fixups for this phydev */
int phy_scan_fixups(struct phy_device *phydev)
{
	struct phy_fixup *fixup;

	mutex_lock(&phy_fixup_lock);
	list_for_each_entry(fixup, &phy_fixup_list, list) {
		if (phy_needs_fixup(phydev, fixup)) {
			int err;

			err = fixup->run(phydev);

			if (err < 0)
				return err;
		}
	}
	mutex_unlock(&phy_fixup_lock);

	return 0;
}
EXPORT_SYMBOL(phy_scan_fixups);

146 147 148 149 150
struct phy_device* phy_device_create(struct mii_bus *bus, int addr, int phy_id)
{
	struct phy_device *dev;
	/* We allocate the device, and initialize the
	 * default values */
151
	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
152 153 154 155

	if (NULL == dev)
		return (struct phy_device*) PTR_ERR((void*)-ENOMEM);

156 157
	dev->dev.release = phy_device_release;

158 159 160 161
	dev->speed = 0;
	dev->duplex = -1;
	dev->pause = dev->asym_pause = 0;
	dev->link = 1;
162
	dev->interface = PHY_INTERFACE_MODE_GMII;
163 164 165 166 167 168 169 170 171

	dev->autoneg = AUTONEG_ENABLE;

	dev->addr = addr;
	dev->phy_id = phy_id;
	dev->bus = bus;

	dev->state = PHY_DOWN;

172
	mutex_init(&dev->lock);
173 174 175 176 177

	return dev;
}
EXPORT_SYMBOL(phy_device_create);

178
/**
179
 * get_phy_id - reads the specified addr for its ID.
180 181
 * @bus: the target MII bus
 * @addr: PHY address on the MII bus
182
 * @phy_id: where to store the ID retrieved.
183
 *
184
 * Description: Reads the ID registers of the PHY at @addr on the
185
 *   @bus, stores it in @phy_id and returns zero on success.
186
 */
187
int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id)
188 189 190 191 192 193 194 195
{
	int phy_reg;

	/* Grab the bits from PHYIR1, and put them
	 * in the upper half */
	phy_reg = bus->read(bus, addr, MII_PHYSID1);

	if (phy_reg < 0)
196
		return -EIO;
197

198
	*phy_id = (phy_reg & 0xffff) << 16;
199 200 201 202 203

	/* Grab the bits from PHYIR2, and put them in the lower half */
	phy_reg = bus->read(bus, addr, MII_PHYSID2);

	if (phy_reg < 0)
204 205 206 207 208 209
		return -EIO;

	*phy_id |= (phy_reg & 0xffff);

	return 0;
}
210
EXPORT_SYMBOL(get_phy_id);
211 212 213 214 215 216 217 218 219 220 221 222 223 224

/**
 * get_phy_device - reads the specified PHY device and returns its @phy_device struct
 * @bus: the target MII bus
 * @addr: PHY address on the MII bus
 *
 * Description: Reads the ID registers of the PHY at @addr on the
 *   @bus, then allocates and returns the phy_device to represent it.
 */
struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
{
	struct phy_device *dev = NULL;
	u32 phy_id;
	int r;
225

226 227 228
	r = get_phy_id(bus, addr, &phy_id);
	if (r)
		return ERR_PTR(r);
229

G
Giulio Benetti 已提交
230 231
	/* If the phy_id is all Fs or all 0s, there is no device there */
	if ((0xffff == phy_id) || (0x00 == phy_id))
232 233
		return NULL;

234
	dev = phy_device_create(bus, addr, phy_id);
235 236 237 238

	return dev;
}

239 240 241 242
/**
 * phy_prepare_link - prepares the PHY layer to monitor link status
 * @phydev: target phy_device struct
 * @handler: callback function for link status change notifications
243
 *
244
 * Description: Tells the PHY infrastructure to handle the
245 246 247 248
 *   gory details on monitoring link status (whether through
 *   polling or an interrupt), and to call back to the
 *   connected device driver when the link status changes.
 *   If you want to monitor your own link state, don't call
249 250
 *   this function.
 */
251 252 253 254 255 256
void phy_prepare_link(struct phy_device *phydev,
		void (*handler)(struct net_device *))
{
	phydev->adjust_link = handler;
}

257 258 259
/**
 * phy_connect - connect an ethernet device to a PHY device
 * @dev: the network device to connect
260
 * @bus_id: the id string of the PHY device to connect
261 262 263
 * @handler: callback function for state change notifications
 * @flags: PHY device's dev_flags
 * @interface: PHY device's interface
A
Andy Fleming 已提交
264
 *
265
 * Description: Convenience function for connecting ethernet
A
Andy Fleming 已提交
266 267 268 269 270 271 272
 *   devices to PHY devices.  The default behavior is for
 *   the PHY infrastructure to handle everything, and only notify
 *   the connected driver when the link status changes.  If you
 *   don't want, or can't use the provided functionality, you may
 *   choose to call only the subset of functions which provide
 *   the desired functionality.
 */
273
struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
274
		void (*handler)(struct net_device *), u32 flags,
R
Randy Dunlap 已提交
275
		phy_interface_t interface)
A
Andy Fleming 已提交
276 277 278
{
	struct phy_device *phydev;

279
	phydev = phy_attach(dev, bus_id, flags, interface);
A
Andy Fleming 已提交
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294

	if (IS_ERR(phydev))
		return phydev;

	phy_prepare_link(phydev, handler);

	phy_start_machine(phydev, NULL);

	if (phydev->irq > 0)
		phy_start_interrupts(phydev);

	return phydev;
}
EXPORT_SYMBOL(phy_connect);

295 296 297 298
/**
 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311
void phy_disconnect(struct phy_device *phydev)
{
	if (phydev->irq > 0)
		phy_stop_interrupts(phydev);

	phy_stop_machine(phydev);
	
	phydev->adjust_link = NULL;

	phy_detach(phydev);
}
EXPORT_SYMBOL(phy_disconnect);

312 313 314
/**
 * phy_attach - attach a network device to a particular PHY device
 * @dev: network device to attach
315
 * @bus_id: PHY device to attach
316 317
 * @flags: PHY device's dev_flags
 * @interface: PHY device's interface
A
Andy Fleming 已提交
318
 *
319
 * Description: Called by drivers to attach to a particular PHY
A
Andy Fleming 已提交
320 321 322 323
 *     device. The phy_device is found, and properly hooked up
 *     to the phy_driver.  If no driver is attached, then the
 *     genphy_driver is used.  The phy_device is given a ptr to
 *     the attaching device, and given a callback for link status
324
 *     change.  The phy_device is returned to the attaching driver.
A
Andy Fleming 已提交
325 326
 */
struct phy_device *phy_attach(struct net_device *dev,
327
		const char *bus_id, u32 flags, phy_interface_t interface)
A
Andy Fleming 已提交
328 329 330 331 332 333 334
{
	struct bus_type *bus = &mdio_bus_type;
	struct phy_device *phydev;
	struct device *d;

	/* Search the list of PHY devices on the mdio bus for the
	 * PHY with the requested name */
335
	d = bus_find_device_by_name(bus, NULL, bus_id);
A
Andy Fleming 已提交
336 337 338
	if (d) {
		phydev = to_phy_device(d);
	} else {
339
		printk(KERN_ERR "%s not found\n", bus_id);
A
Andy Fleming 已提交
340 341 342 343 344 345 346 347 348 349
		return ERR_PTR(-ENODEV);
	}

	/* Assume that if there is no driver, that it doesn't
	 * exist, and we should use the genphy driver. */
	if (NULL == d->driver) {
		int err;
		d->driver = &genphy_driver.driver;

		err = d->driver->probe(d);
350 351
		if (err >= 0)
			err = device_bind_driver(d);
A
Andy Fleming 已提交
352

353 354
		if (err)
			return ERR_PTR(err);
A
Andy Fleming 已提交
355 356 357 358
	}

	if (phydev->attached_dev) {
		printk(KERN_ERR "%s: %s already attached\n",
359
				dev->name, bus_id);
A
Andy Fleming 已提交
360 361 362 363 364 365 366
		return ERR_PTR(-EBUSY);
	}

	phydev->attached_dev = dev;

	phydev->dev_flags = flags;

367 368 369 370 371 372 373 374
	phydev->interface = interface;

	/* Do initial configuration here, now that
	 * we have certain key parameters
	 * (dev_flags and interface) */
	if (phydev->drv->config_init) {
		int err;

375 376 377 378 379
		err = phy_scan_fixups(phydev);

		if (err < 0)
			return ERR_PTR(err);

380 381 382 383 384 385
		err = phydev->drv->config_init(phydev);

		if (err < 0)
			return ERR_PTR(err);
	}

A
Andy Fleming 已提交
386 387 388 389
	return phydev;
}
EXPORT_SYMBOL(phy_attach);

390 391 392 393
/**
 * phy_detach - detach a PHY device from its network device
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
394 395 396 397 398 399 400 401
void phy_detach(struct phy_device *phydev)
{
	phydev->attached_dev = NULL;

	/* If the device had no specific driver before (i.e. - it
	 * was using the generic driver), we unbind the device
	 * from the generic driver so that there's a chance a
	 * real driver could be loaded */
402
	if (phydev->dev.driver == &genphy_driver.driver)
A
Andy Fleming 已提交
403 404 405 406 407
		device_release_driver(&phydev->dev);
}
EXPORT_SYMBOL(phy_detach);


408 409
/* Generic PHY support and helper functions */

410 411 412
/**
 * genphy_config_advert - sanitize and advertise auto-negotation parameters
 * @phydev: target phy_device struct
413
 *
414
 * Description: Writes MII_ADVERTISE with the appropriate values,
415
 *   after sanitizing the values to make sure we only advertise
416 417
 *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
 *   hasn't changed, and > 0 if it has changed.
418
 */
A
Andy Fleming 已提交
419
int genphy_config_advert(struct phy_device *phydev)
420 421
{
	u32 advertise;
422 423
	int oldadv, adv;
	int err, changed = 0;
424 425 426 427 428 429 430

	/* Only allow advertising what
	 * this PHY supports */
	phydev->advertising &= phydev->supported;
	advertise = phydev->advertising;

	/* Setup standard advertisement */
431
	oldadv = adv = phy_read(phydev, MII_ADVERTISE);
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

	if (adv < 0)
		return adv;

	adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 
		 ADVERTISE_PAUSE_ASYM);
	if (advertise & ADVERTISED_10baseT_Half)
		adv |= ADVERTISE_10HALF;
	if (advertise & ADVERTISED_10baseT_Full)
		adv |= ADVERTISE_10FULL;
	if (advertise & ADVERTISED_100baseT_Half)
		adv |= ADVERTISE_100HALF;
	if (advertise & ADVERTISED_100baseT_Full)
		adv |= ADVERTISE_100FULL;
	if (advertise & ADVERTISED_Pause)
		adv |= ADVERTISE_PAUSE_CAP;
	if (advertise & ADVERTISED_Asym_Pause)
		adv |= ADVERTISE_PAUSE_ASYM;

451 452
	if (adv != oldadv) {
		err = phy_write(phydev, MII_ADVERTISE, adv);
453

454 455 456 457
		if (err < 0)
			return err;
		changed = 1;
	}
458 459 460 461

	/* Configure gigabit if it's supported */
	if (phydev->supported & (SUPPORTED_1000baseT_Half |
				SUPPORTED_1000baseT_Full)) {
462
		oldadv = adv = phy_read(phydev, MII_CTRL1000);
463 464 465 466 467 468 469 470 471 472

		if (adv < 0)
			return adv;

		adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
		if (advertise & SUPPORTED_1000baseT_Half)
			adv |= ADVERTISE_1000HALF;
		if (advertise & SUPPORTED_1000baseT_Full)
			adv |= ADVERTISE_1000FULL;

473 474 475 476 477 478 479
		if (adv != oldadv) {
			err = phy_write(phydev, MII_CTRL1000, adv);

			if (err < 0)
				return err;
			changed = 1;
		}
480 481
	}

482
	return changed;
483
}
A
Andy Fleming 已提交
484
EXPORT_SYMBOL(genphy_config_advert);
485

486 487 488
/**
 * genphy_setup_forced - configures/forces speed/duplex from @phydev
 * @phydev: target phy_device struct
489
 *
490
 * Description: Configures MII_BMCR to force speed/duplex
491
 *   to the values in phydev. Assumes that the values are valid.
492 493
 *   Please see phy_sanitize_settings().
 */
494 495
int genphy_setup_forced(struct phy_device *phydev)
{
496
	int err;
497
	int ctl = 0;
498 499 500 501 502 503 504 505 506 507 508

	phydev->pause = phydev->asym_pause = 0;

	if (SPEED_1000 == phydev->speed)
		ctl |= BMCR_SPEED1000;
	else if (SPEED_100 == phydev->speed)
		ctl |= BMCR_SPEED100;

	if (DUPLEX_FULL == phydev->duplex)
		ctl |= BMCR_FULLDPLX;
	
509
	err = phy_write(phydev, MII_BMCR, ctl);
510

511 512 513 514 515 516 517 518 519 520 521
	if (err < 0)
		return err;

	/*
	 * Run the fixups on this PHY, just in case the
	 * board code needs to change something after a reset
	 */
	err = phy_scan_fixups(phydev);

	if (err < 0)
		return err;
522 523 524 525

	/* We just reset the device, so we'd better configure any
	 * settings the PHY requires to operate */
	if (phydev->drv->config_init)
526
		err = phydev->drv->config_init(phydev);
527

528
	return err;
529 530 531
}


532 533 534 535
/**
 * genphy_restart_aneg - Enable and Restart Autonegotiation
 * @phydev: target phy_device struct
 */
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
int genphy_restart_aneg(struct phy_device *phydev)
{
	int ctl;

	ctl = phy_read(phydev, MII_BMCR);

	if (ctl < 0)
		return ctl;

	ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);

	/* Don't isolate the PHY if we're negotiating */
	ctl &= ~(BMCR_ISOLATE);

	ctl = phy_write(phydev, MII_BMCR, ctl);

	return ctl;
}
A
Adrian Bunk 已提交
554
EXPORT_SYMBOL(genphy_restart_aneg);
555 556


557 558 559
/**
 * genphy_config_aneg - restart auto-negotiation or write BMCR
 * @phydev: target phy_device struct
560
 *
561
 * Description: If auto-negotiation is enabled, we configure the
562
 *   advertising, and then restart auto-negotiation.  If it is not
563
 *   enabled, then we write the BMCR.
564 565 566
 */
int genphy_config_aneg(struct phy_device *phydev)
{
567
	int result = 0;
568 569

	if (AUTONEG_ENABLE == phydev->autoneg) {
570
		int result = genphy_config_advert(phydev);
571

572 573
		if (result < 0) /* error */
			return result;
574

575 576 577 578
		/* Only restart aneg if we are advertising something different
		 * than we were before.	 */
		if (result > 0)
			result = genphy_restart_aneg(phydev);
579
	} else
580
		result = genphy_setup_forced(phydev);
581

582
	return result;
583 584 585
}
EXPORT_SYMBOL(genphy_config_aneg);

586 587 588
/**
 * genphy_update_link - update link status in @phydev
 * @phydev: target phy_device struct
589
 *
590
 * Description: Update the value in phydev->link to reflect the
591
 *   current link value.  In order to do this, we need to read
592
 *   the status register twice, keeping the second value.
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
 */
int genphy_update_link(struct phy_device *phydev)
{
	int status;

	/* Do a fake read */
	status = phy_read(phydev, MII_BMSR);

	if (status < 0)
		return status;

	/* Read link and autonegotiation status */
	status = phy_read(phydev, MII_BMSR);

	if (status < 0)
		return status;

	if ((status & BMSR_LSTATUS) == 0)
		phydev->link = 0;
	else
		phydev->link = 1;

	return 0;
}
617
EXPORT_SYMBOL(genphy_update_link);
618

619 620 621
/**
 * genphy_read_status - check the link status and update current link state
 * @phydev: target phy_device struct
622
 *
623
 * Description: Check the link, then figure out the current state
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 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
 *   by comparing what we advertise with what the link partner
 *   advertises.  Start by checking the gigabit possibilities,
 *   then move on to 10/100.
 */
int genphy_read_status(struct phy_device *phydev)
{
	int adv;
	int err;
	int lpa;
	int lpagb = 0;

	/* Update the link, but return if there
	 * was an error */
	err = genphy_update_link(phydev);
	if (err)
		return err;

	if (AUTONEG_ENABLE == phydev->autoneg) {
		if (phydev->supported & (SUPPORTED_1000baseT_Half
					| SUPPORTED_1000baseT_Full)) {
			lpagb = phy_read(phydev, MII_STAT1000);

			if (lpagb < 0)
				return lpagb;

			adv = phy_read(phydev, MII_CTRL1000);

			if (adv < 0)
				return adv;

			lpagb &= adv << 2;
		}

		lpa = phy_read(phydev, MII_LPA);

		if (lpa < 0)
			return lpa;

		adv = phy_read(phydev, MII_ADVERTISE);

		if (adv < 0)
			return adv;

		lpa &= adv;

		phydev->speed = SPEED_10;
		phydev->duplex = DUPLEX_HALF;
		phydev->pause = phydev->asym_pause = 0;

		if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
			phydev->speed = SPEED_1000;

			if (lpagb & LPA_1000FULL)
				phydev->duplex = DUPLEX_FULL;
		} else if (lpa & (LPA_100FULL | LPA_100HALF)) {
			phydev->speed = SPEED_100;
			
			if (lpa & LPA_100FULL)
				phydev->duplex = DUPLEX_FULL;
		} else
			if (lpa & LPA_10FULL)
				phydev->duplex = DUPLEX_FULL;

		if (phydev->duplex == DUPLEX_FULL){
			phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
			phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
		}
	} else {
		int bmcr = phy_read(phydev, MII_BMCR);
		if (bmcr < 0)
			return bmcr;

		if (bmcr & BMCR_FULLDPLX)
			phydev->duplex = DUPLEX_FULL;
		else
			phydev->duplex = DUPLEX_HALF;

		if (bmcr & BMCR_SPEED1000)
			phydev->speed = SPEED_1000;
		else if (bmcr & BMCR_SPEED100)
			phydev->speed = SPEED_100;
		else
			phydev->speed = SPEED_10;

		phydev->pause = phydev->asym_pause = 0;
	}

	return 0;
}
EXPORT_SYMBOL(genphy_read_status);

static int genphy_config_init(struct phy_device *phydev)
{
717
	int val;
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
	u32 features;

	/* For now, I'll claim that the generic driver supports
	 * all possible port types */
	features = (SUPPORTED_TP | SUPPORTED_MII
			| SUPPORTED_AUI | SUPPORTED_FIBRE |
			SUPPORTED_BNC);

	/* Do we support autonegotiation? */
	val = phy_read(phydev, MII_BMSR);

	if (val < 0)
		return val;

	if (val & BMSR_ANEGCAPABLE)
		features |= SUPPORTED_Autoneg;

	if (val & BMSR_100FULL)
		features |= SUPPORTED_100baseT_Full;
	if (val & BMSR_100HALF)
		features |= SUPPORTED_100baseT_Half;
	if (val & BMSR_10FULL)
		features |= SUPPORTED_10baseT_Full;
	if (val & BMSR_10HALF)
		features |= SUPPORTED_10baseT_Half;

	if (val & BMSR_ESTATEN) {
		val = phy_read(phydev, MII_ESTATUS);

		if (val < 0)
			return val;

		if (val & ESTATUS_1000_TFULL)
			features |= SUPPORTED_1000baseT_Full;
		if (val & ESTATUS_1000_THALF)
			features |= SUPPORTED_1000baseT_Half;
	}

	phydev->supported = features;
	phydev->advertising = features;

	return 0;
}


763 764 765
/**
 * phy_probe - probe and init a PHY device
 * @dev: device to probe and init
766
 *
767
 * Description: Take care of setting up the phy_device structure,
768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
 *   set the state to READY (the driver's init function should
 *   set it to STARTING if needed).
 */
static int phy_probe(struct device *dev)
{
	struct phy_device *phydev;
	struct phy_driver *phydrv;
	struct device_driver *drv;
	int err = 0;

	phydev = to_phy_device(dev);

	/* Make sure the driver is held.
	 * XXX -- Is this correct? */
	drv = get_driver(phydev->dev.driver);
	phydrv = to_phy_driver(drv);
	phydev->drv = phydrv;

	/* Disable the interrupt if the PHY doesn't support it */
	if (!(phydrv->flags & PHY_HAS_INTERRUPT))
		phydev->irq = PHY_POLL;

790
	mutex_lock(&phydev->lock);
791 792 793 794 795 796 797 798 799 800 801 802 803

	/* Start out supporting everything. Eventually,
	 * a controller will attach, and may modify one
	 * or both of these values */
	phydev->supported = phydrv->features;
	phydev->advertising = phydrv->features;

	/* Set the state to READY by default */
	phydev->state = PHY_READY;

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

804
	mutex_unlock(&phydev->lock);
805 806

	return err;
807

808 809 810 811 812 813 814 815
}

static int phy_remove(struct device *dev)
{
	struct phy_device *phydev;

	phydev = to_phy_device(dev);

816
	mutex_lock(&phydev->lock);
817
	phydev->state = PHY_DOWN;
818
	mutex_unlock(&phydev->lock);
819 820 821 822 823 824 825 826 827 828

	if (phydev->drv->remove)
		phydev->drv->remove(phydev);

	put_driver(dev->driver);
	phydev->drv = NULL;

	return 0;
}

829 830 831 832
/**
 * phy_driver_register - register a phy_driver with the PHY layer
 * @new_driver: new phy_driver to register
 */
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
int phy_driver_register(struct phy_driver *new_driver)
{
	int retval;

	memset(&new_driver->driver, 0, sizeof(new_driver->driver));
	new_driver->driver.name = new_driver->name;
	new_driver->driver.bus = &mdio_bus_type;
	new_driver->driver.probe = phy_probe;
	new_driver->driver.remove = phy_remove;

	retval = driver_register(&new_driver->driver);

	if (retval) {
		printk(KERN_ERR "%s: Error %d in registering driver\n",
				new_driver->name, retval);

		return retval;
	}

852
	pr_debug("%s: Registered new driver\n", new_driver->name);
853 854 855 856 857 858 859 860 861 862 863

	return 0;
}
EXPORT_SYMBOL(phy_driver_register);

void phy_driver_unregister(struct phy_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(phy_driver_unregister);

A
Andy Fleming 已提交
864 865 866 867 868 869 870 871 872 873
static struct phy_driver genphy_driver = {
	.phy_id		= 0xffffffff,
	.phy_id_mask	= 0xffffffff,
	.name		= "Generic PHY",
	.config_init	= genphy_config_init,
	.features	= 0,
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.driver		= {.owner= THIS_MODULE, },
};
874

875
static int __init phy_init(void)
876
{
877 878 879 880
	int rc;

	rc = mdio_bus_init();
	if (rc)
A
Andy Fleming 已提交
881
		return rc;
882

A
Andy Fleming 已提交
883 884 885
	rc = phy_driver_register(&genphy_driver);
	if (rc)
		mdio_bus_exit();
886 887

	return rc;
888 889
}

890
static void __exit phy_exit(void)
891 892
{
	phy_driver_unregister(&genphy_driver);
A
Andy Fleming 已提交
893
	mdio_bus_exit();
894 895
}

A
Andy Fleming 已提交
896
subsys_initcall(phy_init);
897
module_exit(phy_exit);