1/*
   2 * drivers/net/phy/phy_device.c
   3 *
   4 * Framework for finding and configuring PHYs.
   5 * Also contains generic PHY driver
   6 *
   7 * Author: Andy Fleming
   8 *
   9 * Copyright (c) 2004 Freescale Semiconductor, Inc.
  10 *
  11 * This program is free software; you can redistribute  it and/or modify it
  12 * under  the terms of  the GNU General  Public License as published by the
  13 * Free Software Foundation;  either version 2 of the  License, or (at your
  14 * option) any later version.
  15 *
  16 */
  17#include <linux/kernel.h>
  18#include <linux/string.h>
  19#include <linux/errno.h>
  20#include <linux/unistd.h>
  21#include <linux/slab.h>
  22#include <linux/interrupt.h>
  23#include <linux/init.h>
  24#include <linux/delay.h>
  25#include <linux/netdevice.h>
  26#include <linux/etherdevice.h>
  27#include <linux/skbuff.h>
  28#include <linux/mm.h>
  29#include <linux/module.h>
  30#include <linux/mii.h>
  31#include <linux/ethtool.h>
  32#include <linux/phy.h>
  33
  34#include <asm/io.h>
  35#include <asm/irq.h>
  36#include <asm/uaccess.h>
  37
  38MODULE_DESCRIPTION("PHY library");
  39MODULE_AUTHOR("Andy Fleming");
  40MODULE_LICENSE("GPL");
  41
  42void phy_device_free(struct phy_device *phydev)
  43{
  44	kfree(phydev);
  45}
  46EXPORT_SYMBOL(phy_device_free);
  47
  48static void phy_device_release(struct device *dev)
  49{
  50	phy_device_free(to_phy_device(dev));
  51}
  52
  53static struct phy_driver genphy_driver;
  54extern int mdio_bus_init(void);
  55extern void mdio_bus_exit(void);
  56
  57static LIST_HEAD(phy_fixup_list);
  58static DEFINE_MUTEX(phy_fixup_lock);
  59
  60static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
  61			     u32 flags, phy_interface_t interface);
  62
  63/*
  64 * Creates a new phy_fixup and adds it to the list
  65 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
  66 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
  67 * 	It can also be PHY_ANY_UID
  68 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
  69 * 	comparison
  70 * @run: The actual code to be run when a matching PHY is found
  71 */
  72int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
  73		int (*run)(struct phy_device *))
  74{
  75	struct phy_fixup *fixup;
  76
  77	fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);
  78	if (!fixup)
  79		return -ENOMEM;
  80
  81	strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
  82	fixup->phy_uid = phy_uid;
  83	fixup->phy_uid_mask = phy_uid_mask;
  84	fixup->run = run;
  85
  86	mutex_lock(&phy_fixup_lock);
  87	list_add_tail(&fixup->list, &phy_fixup_list);
  88	mutex_unlock(&phy_fixup_lock);
  89
  90	return 0;
  91}
  92EXPORT_SYMBOL(phy_register_fixup);
  93
  94/* Registers a fixup to be run on any PHY with the UID in phy_uid */
  95int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
  96		int (*run)(struct phy_device *))
  97{
  98	return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
  99}
 100EXPORT_SYMBOL(phy_register_fixup_for_uid);
 101
 102/* Registers a fixup to be run on the PHY with id string bus_id */
 103int phy_register_fixup_for_id(const char *bus_id,
 104		int (*run)(struct phy_device *))
 105{
 106	return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
 107}
 108EXPORT_SYMBOL(phy_register_fixup_for_id);
 109
 110/*
 111 * Returns 1 if fixup matches phydev in bus_id and phy_uid.
 112 * Fixups can be set to match any in one or more fields.
 113 */
 114static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
 115{
 116	if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
 117		if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
 118			return 0;
 119
 120	if ((fixup->phy_uid & fixup->phy_uid_mask) !=
 121			(phydev->phy_id & fixup->phy_uid_mask))
 122		if (fixup->phy_uid != PHY_ANY_UID)
 123			return 0;
 124
 125	return 1;
 126}
 127
 128/* Runs any matching fixups for this phydev */
 129int phy_scan_fixups(struct phy_device *phydev)
 130{
 131	struct phy_fixup *fixup;
 132
 133	mutex_lock(&phy_fixup_lock);
 134	list_for_each_entry(fixup, &phy_fixup_list, list) {
 135		if (phy_needs_fixup(phydev, fixup)) {
 136			int err;
 137
 138			err = fixup->run(phydev);
 139
 140			if (err < 0) {
 141				mutex_unlock(&phy_fixup_lock);
 142				return err;
 143			}
 144		}
 145	}
 146	mutex_unlock(&phy_fixup_lock);
 147
 148	return 0;
 149}
 150EXPORT_SYMBOL(phy_scan_fixups);
 151
 152static struct phy_device* phy_device_create(struct mii_bus *bus,
 153					    int addr, int phy_id)
 154{
 155	struct phy_device *dev;
 156
 157	/* We allocate the device, and initialize the
 158	 * default values */
 159	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 160
 161	if (NULL == dev)
 162		return (struct phy_device*) PTR_ERR((void*)-ENOMEM);
 163
 164	dev->dev.release = phy_device_release;
 165
 166	dev->speed = 0;
 167	dev->duplex = -1;
 168	dev->pause = dev->asym_pause = 0;
 169	dev->link = 1;
 170	dev->interface = PHY_INTERFACE_MODE_GMII;
 171
 172	dev->autoneg = AUTONEG_ENABLE;
 173
 174	dev->addr = addr;
 175	dev->phy_id = phy_id;
 176	dev->bus = bus;
 177	dev->dev.parent = bus->parent;
 178	dev->dev.bus = &mdio_bus_type;
 179	dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
 180	dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
 181
 182	dev->state = PHY_DOWN;
 183
 184	mutex_init(&dev->lock);
 185	INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
 186
 187	/* Request the appropriate module unconditionally; don't
 188	   bother trying to do so only if it isn't already loaded,
 189	   because that gets complicated. A hotplug event would have
 190	   done an unconditional modprobe anyway.
 191	   We don't do normal hotplug because it won't work for MDIO
 192	   -- because it relies on the device staying around for long
 193	   enough for the driver to get loaded. With MDIO, the NIC
 194	   driver will get bored and give up as soon as it finds that
 195	   there's no driver _already_ loaded. */
 196	request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
 197
 198	return dev;
 199}
 200
 201/**
 202 * get_phy_id - reads the specified addr for its ID.
 203 * @bus: the target MII bus
 204 * @addr: PHY address on the MII bus
 205 * @phy_id: where to store the ID retrieved.
 206 *
 207 * Description: Reads the ID registers of the PHY at @addr on the
 208 *   @bus, stores it in @phy_id and returns zero on success.
 209 */
 210int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id)
 211{
 212	int phy_reg;
 213
 214	/* Grab the bits from PHYIR1, and put them
 215	 * in the upper half */
 216	phy_reg = bus->read(bus, addr, MII_PHYSID1);
 217
 218	if (phy_reg < 0)
 219		return -EIO;
 220
 221	*phy_id = (phy_reg & 0xffff) << 16;
 222
 223	/* Grab the bits from PHYIR2, and put them in the lower half */
 224	phy_reg = bus->read(bus, addr, MII_PHYSID2);
 225
 226	if (phy_reg < 0)
 227		return -EIO;
 228
 229	*phy_id |= (phy_reg & 0xffff);
 230
 231	return 0;
 232}
 233EXPORT_SYMBOL(get_phy_id);
 234
 235/**
 236 * get_phy_device - reads the specified PHY device and returns its @phy_device struct
 237 * @bus: the target MII bus
 238 * @addr: PHY address on the MII bus
 239 *
 240 * Description: Reads the ID registers of the PHY at @addr on the
 241 *   @bus, then allocates and returns the phy_device to represent it.
 242 */
 243struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
 244{
 245	struct phy_device *dev = NULL;
 246	u32 phy_id;
 247	int r;
 248
 249	r = get_phy_id(bus, addr, &phy_id);
 250	if (r)
 251		return ERR_PTR(r);
 252
 253	/* If the phy_id is mostly Fs, there is no device there */
 254	if ((phy_id & 0x1fffffff) == 0x1fffffff)
 255		return NULL;
 256
 257	dev = phy_device_create(bus, addr, phy_id);
 258
 259	return dev;
 260}
 261EXPORT_SYMBOL(get_phy_device);
 262
 263/**
 264 * phy_device_register - Register the phy device on the MDIO bus
 265 * @phydev: phy_device structure to be added to the MDIO bus
 266 */
 267int phy_device_register(struct phy_device *phydev)
 268{
 269	int err;
 270
 271	/* Don't register a phy if one is already registered at this
 272	 * address */
 273	if (phydev->bus->phy_map[phydev->addr])
 274		return -EINVAL;
 275	phydev->bus->phy_map[phydev->addr] = phydev;
 276
 277	/* Run all of the fixups for this PHY */
 278	phy_scan_fixups(phydev);
 279
 280	err = device_register(&phydev->dev);
 281	if (err) {
 282		pr_err("phy %d failed to register\n", phydev->addr);
 283		goto out;
 284	}
 285
 286	return 0;
 287
 288 out:
 289	phydev->bus->phy_map[phydev->addr] = NULL;
 290	return err;
 291}
 292EXPORT_SYMBOL(phy_device_register);
 293
 294/**
 295 * phy_find_first - finds the first PHY device on the bus
 296 * @bus: the target MII bus
 297 */
 298struct phy_device *phy_find_first(struct mii_bus *bus)
 299{
 300	int addr;
 301
 302	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
 303		if (bus->phy_map[addr])
 304			return bus->phy_map[addr];
 305	}
 306	return NULL;
 307}
 308EXPORT_SYMBOL(phy_find_first);
 309
 310/**
 311 * phy_prepare_link - prepares the PHY layer to monitor link status
 312 * @phydev: target phy_device struct
 313 * @handler: callback function for link status change notifications
 314 *
 315 * Description: Tells the PHY infrastructure to handle the
 316 *   gory details on monitoring link status (whether through
 317 *   polling or an interrupt), and to call back to the
 318 *   connected device driver when the link status changes.
 319 *   If you want to monitor your own link state, don't call
 320 *   this function.
 321 */
 322static void phy_prepare_link(struct phy_device *phydev,
 323		void (*handler)(struct net_device *))
 324{
 325	phydev->adjust_link = handler;
 326}
 327
 328/**
 329 * phy_connect_direct - connect an ethernet device to a specific phy_device
 330 * @dev: the network device to connect
 331 * @phydev: the pointer to the phy device
 332 * @handler: callback function for state change notifications
 333 * @flags: PHY device's dev_flags
 334 * @interface: PHY device's interface
 335 */
 336int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
 337		       void (*handler)(struct net_device *), u32 flags,
 338		       phy_interface_t interface)
 339{
 340	int rc;
 341
 342	rc = phy_attach_direct(dev, phydev, flags, interface);
 343	if (rc)
 344		return rc;
 345
 346	phy_prepare_link(phydev, handler);
 347	phy_start_machine(phydev, NULL);
 348	if (phydev->irq > 0)
 349		phy_start_interrupts(phydev);
 350
 351	return 0;
 352}
 353EXPORT_SYMBOL(phy_connect_direct);
 354
 355/**
 356 * phy_connect - connect an ethernet device to a PHY device
 357 * @dev: the network device to connect
 358 * @bus_id: the id string of the PHY device to connect
 359 * @handler: callback function for state change notifications
 360 * @flags: PHY device's dev_flags
 361 * @interface: PHY device's interface
 362 *
 363 * Description: Convenience function for connecting ethernet
 364 *   devices to PHY devices.  The default behavior is for
 365 *   the PHY infrastructure to handle everything, and only notify
 366 *   the connected driver when the link status changes.  If you
 367 *   don't want, or can't use the provided functionality, you may
 368 *   choose to call only the subset of functions which provide
 369 *   the desired functionality.
 370 */
 371struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
 372		void (*handler)(struct net_device *), u32 flags,
 373		phy_interface_t interface)
 374{
 375	struct phy_device *phydev;
 376	struct device *d;
 377	int rc;
 378
 379	/* Search the list of PHY devices on the mdio bus for the
 380	 * PHY with the requested name */
 381	d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
 382	if (!d) {
 383		pr_err("PHY %s not found\n", bus_id);
 384		return ERR_PTR(-ENODEV);
 385	}
 386	phydev = to_phy_device(d);
 387
 388	rc = phy_connect_direct(dev, phydev, handler, flags, interface);
 389	if (rc)
 390		return ERR_PTR(rc);
 391
 392	return phydev;
 393}
 394EXPORT_SYMBOL(phy_connect);
 395
 396/**
 397 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device
 398 * @phydev: target phy_device struct
 399 */
 400void phy_disconnect(struct phy_device *phydev)
 401{
 402	if (phydev->irq > 0)
 403		phy_stop_interrupts(phydev);
 404
 405	phy_stop_machine(phydev);
 406	
 407	phydev->adjust_link = NULL;
 408
 409	phy_detach(phydev);
 410}
 411EXPORT_SYMBOL(phy_disconnect);
 412
 413int phy_init_hw(struct phy_device *phydev)
 414{
 415	int ret;
 416
 417	if (!phydev->drv || !phydev->drv->config_init)
 418		return 0;
 419
 420	ret = phy_scan_fixups(phydev);
 421	if (ret < 0)
 422		return ret;
 423
 424	return phydev->drv->config_init(phydev);
 425}
 426
 427/**
 428 * phy_attach_direct - attach a network device to a given PHY device pointer
 429 * @dev: network device to attach
 430 * @phydev: Pointer to phy_device to attach
 431 * @flags: PHY device's dev_flags
 432 * @interface: PHY device's interface
 433 *
 434 * Description: Called by drivers to attach to a particular PHY
 435 *     device. The phy_device is found, and properly hooked up
 436 *     to the phy_driver.  If no driver is attached, then the
 437 *     genphy_driver is used.  The phy_device is given a ptr to
 438 *     the attaching device, and given a callback for link status
 439 *     change.  The phy_device is returned to the attaching driver.
 440 */
 441static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
 442			     u32 flags, phy_interface_t interface)
 443{
 444	struct device *d = &phydev->dev;
 445	int err;
 446
 447	/* Assume that if there is no driver, that it doesn't
 448	 * exist, and we should use the genphy driver. */
 449	if (NULL == d->driver) {
 450		d->driver = &genphy_driver.driver;
 451
 452		err = d->driver->probe(d);
 453		if (err >= 0)
 454			err = device_bind_driver(d);
 455
 456		if (err)
 457			return err;
 458	}
 459
 460	if (phydev->attached_dev) {
 461		dev_err(&dev->dev, "PHY already attached\n");
 462		return -EBUSY;
 463	}
 464
 465	phydev->attached_dev = dev;
 466	dev->phydev = phydev;
 467
 468	phydev->dev_flags = flags;
 469
 470	phydev->interface = interface;
 471
 472	phydev->state = PHY_READY;
 473
 474	/* Do initial configuration here, now that
 475	 * we have certain key parameters
 476	 * (dev_flags and interface) */
 477	err = phy_init_hw(phydev);
 478	if (err)
 479		phy_detach(phydev);
 480
 481	return err;
 482}
 483
 484/**
 485 * phy_attach - attach a network device to a particular PHY device
 486 * @dev: network device to attach
 487 * @bus_id: Bus ID of PHY device to attach
 488 * @flags: PHY device's dev_flags
 489 * @interface: PHY device's interface
 490 *
 491 * Description: Same as phy_attach_direct() except that a PHY bus_id
 492 *     string is passed instead of a pointer to a struct phy_device.
 493 */
 494struct phy_device *phy_attach(struct net_device *dev,
 495		const char *bus_id, u32 flags, phy_interface_t interface)
 496{
 497	struct bus_type *bus = &mdio_bus_type;
 498	struct phy_device *phydev;
 499	struct device *d;
 500	int rc;
 501
 502	/* Search the list of PHY devices on the mdio bus for the
 503	 * PHY with the requested name */
 504	d = bus_find_device_by_name(bus, NULL, bus_id);
 505	if (!d) {
 506		pr_err("PHY %s not found\n", bus_id);
 507		return ERR_PTR(-ENODEV);
 508	}
 509	phydev = to_phy_device(d);
 510
 511	rc = phy_attach_direct(dev, phydev, flags, interface);
 512	if (rc)
 513		return ERR_PTR(rc);
 514
 515	return phydev;
 516}
 517EXPORT_SYMBOL(phy_attach);
 518
 519/**
 520 * phy_detach - detach a PHY device from its network device
 521 * @phydev: target phy_device struct
 522 */
 523void phy_detach(struct phy_device *phydev)
 524{
 525	phydev->attached_dev->phydev = NULL;
 526	phydev->attached_dev = NULL;
 527
 528	/* If the device had no specific driver before (i.e. - it
 529	 * was using the generic driver), we unbind the device
 530	 * from the generic driver so that there's a chance a
 531	 * real driver could be loaded */
 532	if (phydev->dev.driver == &genphy_driver.driver)
 533		device_release_driver(&phydev->dev);
 534}
 535EXPORT_SYMBOL(phy_detach);
 536
 537
 538/* Generic PHY support and helper functions */
 539
 540/**
 541 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
 542 * @phydev: target phy_device struct
 543 *
 544 * Description: Writes MII_ADVERTISE with the appropriate values,
 545 *   after sanitizing the values to make sure we only advertise
 546 *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
 547 *   hasn't changed, and > 0 if it has changed.
 548 */
 549static int genphy_config_advert(struct phy_device *phydev)
 550{
 551	u32 advertise;
 552	int oldadv, adv;
 553	int err, changed = 0;
 554
 555	/* Only allow advertising what
 556	 * this PHY supports */
 557	phydev->advertising &= phydev->supported;
 558	advertise = phydev->advertising;
 559
 560	/* Setup standard advertisement */
 561	oldadv = adv = phy_read(phydev, MII_ADVERTISE);
 562
 563	if (adv < 0)
 564		return adv;
 565
 566	adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 
 567		 ADVERTISE_PAUSE_ASYM);
 568	if (advertise & ADVERTISED_10baseT_Half)
 569		adv |= ADVERTISE_10HALF;
 570	if (advertise & ADVERTISED_10baseT_Full)
 571		adv |= ADVERTISE_10FULL;
 572	if (advertise & ADVERTISED_100baseT_Half)
 573		adv |= ADVERTISE_100HALF;
 574	if (advertise & ADVERTISED_100baseT_Full)
 575		adv |= ADVERTISE_100FULL;
 576	if (advertise & ADVERTISED_Pause)
 577		adv |= ADVERTISE_PAUSE_CAP;
 578	if (advertise & ADVERTISED_Asym_Pause)
 579		adv |= ADVERTISE_PAUSE_ASYM;
 580
 581	if (adv != oldadv) {
 582		err = phy_write(phydev, MII_ADVERTISE, adv);
 583
 584		if (err < 0)
 585			return err;
 586		changed = 1;
 587	}
 588
 589	/* Configure gigabit if it's supported */
 590	if (phydev->supported & (SUPPORTED_1000baseT_Half |
 591				SUPPORTED_1000baseT_Full)) {
 592		oldadv = adv = phy_read(phydev, MII_CTRL1000);
 593
 594		if (adv < 0)
 595			return adv;
 596
 597		adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
 598		if (advertise & SUPPORTED_1000baseT_Half)
 599			adv |= ADVERTISE_1000HALF;
 600		if (advertise & SUPPORTED_1000baseT_Full)
 601			adv |= ADVERTISE_1000FULL;
 602
 603		if (adv != oldadv) {
 604			err = phy_write(phydev, MII_CTRL1000, adv);
 605
 606			if (err < 0)
 607				return err;
 608			changed = 1;
 609		}
 610	}
 611
 612	return changed;
 613}
 614
 615/**
 616 * genphy_setup_forced - configures/forces speed/duplex from @phydev
 617 * @phydev: target phy_device struct
 618 *
 619 * Description: Configures MII_BMCR to force speed/duplex
 620 *   to the values in phydev. Assumes that the values are valid.
 621 *   Please see phy_sanitize_settings().
 622 */
 623static int genphy_setup_forced(struct phy_device *phydev)
 624{
 625	int err;
 626	int ctl = 0;
 627
 628	phydev->pause = phydev->asym_pause = 0;
 629
 630	if (SPEED_1000 == phydev->speed)
 631		ctl |= BMCR_SPEED1000;
 632	else if (SPEED_100 == phydev->speed)
 633		ctl |= BMCR_SPEED100;
 634
 635	if (DUPLEX_FULL == phydev->duplex)
 636		ctl |= BMCR_FULLDPLX;
 637	
 638	err = phy_write(phydev, MII_BMCR, ctl);
 639
 640	return err;
 641}
 642
 643
 644/**
 645 * genphy_restart_aneg - Enable and Restart Autonegotiation
 646 * @phydev: target phy_device struct
 647 */
 648int genphy_restart_aneg(struct phy_device *phydev)
 649{
 650	int ctl;
 651
 652	ctl = phy_read(phydev, MII_BMCR);
 653
 654	if (ctl < 0)
 655		return ctl;
 656
 657	ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
 658
 659	/* Don't isolate the PHY if we're negotiating */
 660	ctl &= ~(BMCR_ISOLATE);
 661
 662	ctl = phy_write(phydev, MII_BMCR, ctl);
 663
 664	return ctl;
 665}
 666EXPORT_SYMBOL(genphy_restart_aneg);
 667
 668
 669/**
 670 * genphy_config_aneg - restart auto-negotiation or write BMCR
 671 * @phydev: target phy_device struct
 672 *
 673 * Description: If auto-negotiation is enabled, we configure the
 674 *   advertising, and then restart auto-negotiation.  If it is not
 675 *   enabled, then we write the BMCR.
 676 */
 677int genphy_config_aneg(struct phy_device *phydev)
 678{
 679	int result;
 680
 681	if (AUTONEG_ENABLE != phydev->autoneg)
 682		return genphy_setup_forced(phydev);
 683
 684	result = genphy_config_advert(phydev);
 685
 686	if (result < 0) /* error */
 687		return result;
 688
 689	if (result == 0) {
 690		/* Advertisement hasn't changed, but maybe aneg was never on to
 691		 * begin with?  Or maybe phy was isolated? */
 692		int ctl = phy_read(phydev, MII_BMCR);
 693
 694		if (ctl < 0)
 695			return ctl;
 696
 697		if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
 698			result = 1; /* do restart aneg */
 699	}
 700
 701	/* Only restart aneg if we are advertising something different
 702	 * than we were before.	 */
 703	if (result > 0)
 704		result = genphy_restart_aneg(phydev);
 705
 706	return result;
 707}
 708EXPORT_SYMBOL(genphy_config_aneg);
 709
 710/**
 711 * genphy_update_link - update link status in @phydev
 712 * @phydev: target phy_device struct
 713 *
 714 * Description: Update the value in phydev->link to reflect the
 715 *   current link value.  In order to do this, we need to read
 716 *   the status register twice, keeping the second value.
 717 */
 718int genphy_update_link(struct phy_device *phydev)
 719{
 720	int status;
 721
 722	/* Do a fake read */
 723	status = phy_read(phydev, MII_BMSR);
 724
 725	if (status < 0)
 726		return status;
 727
 728	/* Read link and autonegotiation status */
 729	status = phy_read(phydev, MII_BMSR);
 730
 731	if (status < 0)
 732		return status;
 733
 734	if ((status & BMSR_LSTATUS) == 0)
 735		phydev->link = 0;
 736	else
 737		phydev->link = 1;
 738
 739	return 0;
 740}
 741EXPORT_SYMBOL(genphy_update_link);
 742
 743/**
 744 * genphy_read_status - check the link status and update current link state
 745 * @phydev: target phy_device struct
 746 *
 747 * Description: Check the link, then figure out the current state
 748 *   by comparing what we advertise with what the link partner
 749 *   advertises.  Start by checking the gigabit possibilities,
 750 *   then move on to 10/100.
 751 */
 752int genphy_read_status(struct phy_device *phydev)
 753{
 754	int adv;
 755	int err;
 756	int lpa;
 757	int lpagb = 0;
 758
 759	/* Update the link, but return if there
 760	 * was an error */
 761	err = genphy_update_link(phydev);
 762	if (err)
 763		return err;
 764
 765	if (AUTONEG_ENABLE == phydev->autoneg) {
 766		if (phydev->supported & (SUPPORTED_1000baseT_Half
 767					| SUPPORTED_1000baseT_Full)) {
 768			lpagb = phy_read(phydev, MII_STAT1000);
 769
 770			if (lpagb < 0)
 771				return lpagb;
 772
 773			adv = phy_read(phydev, MII_CTRL1000);
 774
 775			if (adv < 0)
 776				return adv;
 777
 778			lpagb &= adv << 2;
 779		}
 780
 781		lpa = phy_read(phydev, MII_LPA);
 782
 783		if (lpa < 0)
 784			return lpa;
 785
 786		adv = phy_read(phydev, MII_ADVERTISE);
 787
 788		if (adv < 0)
 789			return adv;
 790
 791		lpa &= adv;
 792
 793		phydev->speed = SPEED_10;
 794		phydev->duplex = DUPLEX_HALF;
 795		phydev->pause = phydev->asym_pause = 0;
 796
 797		if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
 798			phydev->speed = SPEED_1000;
 799
 800			if (lpagb & LPA_1000FULL)
 801				phydev->duplex = DUPLEX_FULL;
 802		} else if (lpa & (LPA_100FULL | LPA_100HALF)) {
 803			phydev->speed = SPEED_100;
 804			
 805			if (lpa & LPA_100FULL)
 806				phydev->duplex = DUPLEX_FULL;
 807		} else
 808			if (lpa & LPA_10FULL)
 809				phydev->duplex = DUPLEX_FULL;
 810
 811		if (phydev->duplex == DUPLEX_FULL){
 812			phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
 813			phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
 814		}
 815	} else {
 816		int bmcr = phy_read(phydev, MII_BMCR);
 817		if (bmcr < 0)
 818			return bmcr;
 819
 820		if (bmcr & BMCR_FULLDPLX)
 821			phydev->duplex = DUPLEX_FULL;
 822		else
 823			phydev->duplex = DUPLEX_HALF;
 824
 825		if (bmcr & BMCR_SPEED1000)
 826			phydev->speed = SPEED_1000;
 827		else if (bmcr & BMCR_SPEED100)
 828			phydev->speed = SPEED_100;
 829		else
 830			phydev->speed = SPEED_10;
 831
 832		phydev->pause = phydev->asym_pause = 0;
 833	}
 834
 835	return 0;
 836}
 837EXPORT_SYMBOL(genphy_read_status);
 838
 839static int genphy_config_init(struct phy_device *phydev)
 840{
 841	int val;
 842	u32 features;
 843
 844	/* For now, I'll claim that the generic driver supports
 845	 * all possible port types */
 846	features = (SUPPORTED_TP | SUPPORTED_MII
 847			| SUPPORTED_AUI | SUPPORTED_FIBRE |
 848			SUPPORTED_BNC);
 849
 850	/* Do we support autonegotiation? */
 851	val = phy_read(phydev, MII_BMSR);
 852
 853	if (val < 0)
 854		return val;
 855
 856	if (val & BMSR_ANEGCAPABLE)
 857		features |= SUPPORTED_Autoneg;
 858
 859	if (val & BMSR_100FULL)
 860		features |= SUPPORTED_100baseT_Full;
 861	if (val & BMSR_100HALF)
 862		features |= SUPPORTED_100baseT_Half;
 863	if (val & BMSR_10FULL)
 864		features |= SUPPORTED_10baseT_Full;
 865	if (val & BMSR_10HALF)
 866		features |= SUPPORTED_10baseT_Half;
 867
 868	if (val & BMSR_ESTATEN) {
 869		val = phy_read(phydev, MII_ESTATUS);
 870
 871		if (val < 0)
 872			return val;
 873
 874		if (val & ESTATUS_1000_TFULL)
 875			features |= SUPPORTED_1000baseT_Full;
 876		if (val & ESTATUS_1000_THALF)
 877			features |= SUPPORTED_1000baseT_Half;
 878	}
 879
 880	phydev->supported = features;
 881	phydev->advertising = features;
 882
 883	return 0;
 884}
 885int genphy_suspend(struct phy_device *phydev)
 886{
 887	int value;
 888
 889	mutex_lock(&phydev->lock);
 890
 891	value = phy_read(phydev, MII_BMCR);
 892	phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN));
 893
 894	mutex_unlock(&phydev->lock);
 895
 896	return 0;
 897}
 898EXPORT_SYMBOL(genphy_suspend);
 899
 900int genphy_resume(struct phy_device *phydev)
 901{
 902	int value;
 903
 904	mutex_lock(&phydev->lock);
 905
 906	value = phy_read(phydev, MII_BMCR);
 907	phy_write(phydev, MII_BMCR, (value & ~BMCR_PDOWN));
 908
 909	mutex_unlock(&phydev->lock);
 910
 911	return 0;
 912}
 913EXPORT_SYMBOL(genphy_resume);
 914
 915/**
 916 * phy_probe - probe and init a PHY device
 917 * @dev: device to probe and init
 918 *
 919 * Description: Take care of setting up the phy_device structure,
 920 *   set the state to READY (the driver's init function should
 921 *   set it to STARTING if needed).
 922 */
 923static int phy_probe(struct device *dev)
 924{
 925	struct phy_device *phydev;
 926	struct phy_driver *phydrv;
 927	struct device_driver *drv;
 928	int err = 0;
 929
 930	phydev = to_phy_device(dev);
 931
 932	/* Make sure the driver is held.
 933	 * XXX -- Is this correct? */
 934	drv = get_driver(phydev->dev.driver);
 935	phydrv = to_phy_driver(drv);
 936	phydev->drv = phydrv;
 937
 938	/* Disable the interrupt if the PHY doesn't support it */
 939	if (!(phydrv->flags & PHY_HAS_INTERRUPT))
 940		phydev->irq = PHY_POLL;
 941
 942	mutex_lock(&phydev->lock);
 943
 944	/* Start out supporting everything. Eventually,
 945	 * a controller will attach, and may modify one
 946	 * or both of these values */
 947	phydev->supported = phydrv->features;
 948	phydev->advertising = phydrv->features;
 949
 950	/* Set the state to READY by default */
 951	phydev->state = PHY_READY;
 952
 953	if (phydev->drv->probe)
 954		err = phydev->drv->probe(phydev);
 955
 956	mutex_unlock(&phydev->lock);
 957
 958	return err;
 959
 960}
 961
 962static int phy_remove(struct device *dev)
 963{
 964	struct phy_device *phydev;
 965
 966	phydev = to_phy_device(dev);
 967
 968	mutex_lock(&phydev->lock);
 969	phydev->state = PHY_DOWN;
 970	mutex_unlock(&phydev->lock);
 971
 972	if (phydev->drv->remove)
 973		phydev->drv->remove(phydev);
 974
 975	put_driver(dev->driver);
 976	phydev->drv = NULL;
 977
 978	return 0;
 979}
 980
 981/**
 982 * phy_driver_register - register a phy_driver with the PHY layer
 983 * @new_driver: new phy_driver to register
 984 */
 985int phy_driver_register(struct phy_driver *new_driver)
 986{
 987	int retval;
 988
 989	new_driver->driver.name = new_driver->name;
 990	new_driver->driver.bus = &mdio_bus_type;
 991	new_driver->driver.probe = phy_probe;
 992	new_driver->driver.remove = phy_remove;
 993
 994	retval = driver_register(&new_driver->driver);
 995
 996	if (retval) {
 997		printk(KERN_ERR "%s: Error %d in registering driver\n",
 998				new_driver->name, retval);
 999
1000		return retval;
1001	}
1002
1003	pr_debug("%s: Registered new driver\n", new_driver->name);
1004
1005	return 0;
1006}
1007EXPORT_SYMBOL(phy_driver_register);
1008
1009void phy_driver_unregister(struct phy_driver *drv)
1010{
1011	driver_unregister(&drv->driver);
1012}
1013EXPORT_SYMBOL(phy_driver_unregister);
1014
1015static struct phy_driver genphy_driver = {
1016	.phy_id		= 0xffffffff,
1017	.phy_id_mask	= 0xffffffff,
1018	.name		= "Generic PHY",
1019	.config_init	= genphy_config_init,
1020	.features	= 0,
1021	.config_aneg	= genphy_config_aneg,
1022	.read_status	= genphy_read_status,
1023	.suspend	= genphy_suspend,
1024	.resume		= genphy_resume,
1025	.driver		= {.owner= THIS_MODULE, },
1026};
1027
1028static int __init phy_init(void)
1029{
1030	int rc;
1031
1032	rc = mdio_bus_init();
1033	if (rc)
1034		return rc;
1035
1036	rc = phy_driver_register(&genphy_driver);
1037	if (rc)
1038		mdio_bus_exit();
1039
1040	return rc;
1041}
1042
1043static void __exit phy_exit(void)
1044{
1045	phy_driver_unregister(&genphy_driver);
1046	mdio_bus_exit();
1047}
1048
1049subsys_initcall(phy_init);
1050module_exit(phy_exit);