phy_device.c 20.9 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 230 231 232 233

	/* If the phy_id is all Fs, there is no device there */
	if (0xffffffff == phy_id)
		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 315 316 317 318 319
static int phy_compare_id(struct device *dev, void *data)
{
	return strcmp((char *)data, dev->bus_id) ? 0 : 1;
}

/**
 * phy_attach - attach a network device to a particular PHY device
 * @dev: network device to attach
320
 * @bus_id: PHY device to attach
321 322
 * @flags: PHY device's dev_flags
 * @interface: PHY device's interface
A
Andy Fleming 已提交
323
 *
324
 * Description: Called by drivers to attach to a particular PHY
A
Andy Fleming 已提交
325 326 327 328
 *     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
329
 *     change.  The phy_device is returned to the attaching driver.
A
Andy Fleming 已提交
330 331
 */
struct phy_device *phy_attach(struct net_device *dev,
332
		const char *bus_id, u32 flags, phy_interface_t interface)
A
Andy Fleming 已提交
333 334 335 336 337 338 339
{
	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 */
340
	d = bus_find_device(bus, NULL, (void *)bus_id, phy_compare_id);
A
Andy Fleming 已提交
341 342 343 344

	if (d) {
		phydev = to_phy_device(d);
	} else {
345
		printk(KERN_ERR "%s not found\n", bus_id);
A
Andy Fleming 已提交
346 347 348 349 350 351 352 353 354 355
		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);
356 357
		if (err >= 0)
			err = device_bind_driver(d);
A
Andy Fleming 已提交
358

359 360
		if (err)
			return ERR_PTR(err);
A
Andy Fleming 已提交
361 362 363 364
	}

	if (phydev->attached_dev) {
		printk(KERN_ERR "%s: %s already attached\n",
365
				dev->name, bus_id);
A
Andy Fleming 已提交
366 367 368 369 370 371 372
		return ERR_PTR(-EBUSY);
	}

	phydev->attached_dev = dev;

	phydev->dev_flags = flags;

373 374 375 376 377 378 379 380
	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;

381 382 383 384 385
		err = phy_scan_fixups(phydev);

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

386 387 388 389 390 391
		err = phydev->drv->config_init(phydev);

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

A
Andy Fleming 已提交
392 393 394 395
	return phydev;
}
EXPORT_SYMBOL(phy_attach);

396 397 398 399
/**
 * phy_detach - detach a PHY device from its network device
 * @phydev: target phy_device struct
 */
A
Andy Fleming 已提交
400 401 402 403 404 405 406 407
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 */
408
	if (phydev->dev.driver == &genphy_driver.driver)
A
Andy Fleming 已提交
409 410 411 412 413
		device_release_driver(&phydev->dev);
}
EXPORT_SYMBOL(phy_detach);


414 415
/* Generic PHY support and helper functions */

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

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

	/* Setup standard advertisement */
437
	oldadv = adv = phy_read(phydev, MII_ADVERTISE);
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456

	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;

457 458
	if (adv != oldadv) {
		err = phy_write(phydev, MII_ADVERTISE, adv);
459

460 461 462 463
		if (err < 0)
			return err;
		changed = 1;
	}
464 465 466 467

	/* Configure gigabit if it's supported */
	if (phydev->supported & (SUPPORTED_1000baseT_Half |
				SUPPORTED_1000baseT_Full)) {
468
		oldadv = adv = phy_read(phydev, MII_CTRL1000);
469 470 471 472 473 474 475 476 477 478

		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;

479 480 481 482 483 484 485
		if (adv != oldadv) {
			err = phy_write(phydev, MII_CTRL1000, adv);

			if (err < 0)
				return err;
			changed = 1;
		}
486 487
	}

488
	return changed;
489
}
A
Andy Fleming 已提交
490
EXPORT_SYMBOL(genphy_config_advert);
491

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

	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;
	
515
	err = phy_write(phydev, MII_BMCR, ctl);
516

517 518 519 520 521 522 523 524 525 526 527
	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;
528 529 530 531

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

534
	return err;
535 536 537
}


538 539 540 541
/**
 * genphy_restart_aneg - Enable and Restart Autonegotiation
 * @phydev: target phy_device struct
 */
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
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 已提交
560
EXPORT_SYMBOL(genphy_restart_aneg);
561 562


563 564 565
/**
 * genphy_config_aneg - restart auto-negotiation or write BMCR
 * @phydev: target phy_device struct
566
 *
567
 * Description: If auto-negotiation is enabled, we configure the
568
 *   advertising, and then restart auto-negotiation.  If it is not
569
 *   enabled, then we write the BMCR.
570 571 572
 */
int genphy_config_aneg(struct phy_device *phydev)
{
573
	int result = 0;
574 575

	if (AUTONEG_ENABLE == phydev->autoneg) {
576
		int result = genphy_config_advert(phydev);
577

578 579
		if (result < 0) /* error */
			return result;
580

581 582 583 584
		/* Only restart aneg if we are advertising something different
		 * than we were before.	 */
		if (result > 0)
			result = genphy_restart_aneg(phydev);
585
	} else
586
		result = genphy_setup_forced(phydev);
587

588
	return result;
589 590 591
}
EXPORT_SYMBOL(genphy_config_aneg);

592 593 594
/**
 * genphy_update_link - update link status in @phydev
 * @phydev: target phy_device struct
595
 *
596
 * Description: Update the value in phydev->link to reflect the
597
 *   current link value.  In order to do this, we need to read
598
 *   the status register twice, keeping the second value.
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
 */
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;
}
623
EXPORT_SYMBOL(genphy_update_link);
624

625 626 627
/**
 * genphy_read_status - check the link status and update current link state
 * @phydev: target phy_device struct
628
 *
629
 * Description: Check the link, then figure out the current state
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 717 718 719 720 721 722
 *   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)
{
723
	int val;
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 763 764 765 766 767 768
	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;
}


769 770 771
/**
 * phy_probe - probe and init a PHY device
 * @dev: device to probe and init
772
 *
773
 * Description: Take care of setting up the phy_device structure,
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
 *   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;

796
	mutex_lock(&phydev->lock);
797 798 799 800 801 802 803 804 805 806 807 808 809

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

810
	mutex_unlock(&phydev->lock);
811 812

	return err;
813

814 815 816 817 818 819 820 821
}

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

	phydev = to_phy_device(dev);

822
	mutex_lock(&phydev->lock);
823
	phydev->state = PHY_DOWN;
824
	mutex_unlock(&phydev->lock);
825 826 827 828 829 830 831 832 833 834

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

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

	return 0;
}

835 836 837 838
/**
 * phy_driver_register - register a phy_driver with the PHY layer
 * @new_driver: new phy_driver to register
 */
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
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;
	}

858
	pr_debug("%s: Registered new driver\n", new_driver->name);
859 860 861 862 863 864 865 866 867 868 869

	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 已提交
870 871 872 873 874 875 876 877 878 879
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, },
};
880

881
static int __init phy_init(void)
882
{
883 884 885 886
	int rc;

	rc = mdio_bus_init();
	if (rc)
A
Andy Fleming 已提交
887
		return rc;
888

A
Andy Fleming 已提交
889 890 891
	rc = phy_driver_register(&genphy_driver);
	if (rc)
		mdio_bus_exit();
892 893

	return rc;
894 895
}

896
static void __exit phy_exit(void)
897 898
{
	phy_driver_unregister(&genphy_driver);
A
Andy Fleming 已提交
899
	mdio_bus_exit();
900 901
}

A
Andy Fleming 已提交
902
subsys_initcall(phy_init);
903
module_exit(phy_exit);