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 38 MODULE_DESCRIPTION("PHY library"); 39 MODULE_AUTHOR("Andy Fleming"); 40 MODULE_LICENSE("GPL"); 41 42 void phy_device_free(struct phy_device *phydev) 43 { 44 kfree(phydev); 45 } 46 EXPORT_SYMBOL(phy_device_free); 47 48 static void phy_device_release(struct device *dev) 49 { 50 phy_device_free(to_phy_device(dev)); 51 } 52 53 static struct phy_driver genphy_driver; 54 extern int mdio_bus_init(void); 55 extern void mdio_bus_exit(void); 56 57 static LIST_HEAD(phy_fixup_list); 58 static DEFINE_MUTEX(phy_fixup_lock); 59 60 static 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 */ 72 int 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 } 92 EXPORT_SYMBOL(phy_register_fixup); 93 94 /* Registers a fixup to be run on any PHY with the UID in phy_uid */ 95 int 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 } 100 EXPORT_SYMBOL(phy_register_fixup_for_uid); 101 102 /* Registers a fixup to be run on the PHY with id string bus_id */ 103 int 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 } 108 EXPORT_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 */ 114 static 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 */ 129 int 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 } 150 EXPORT_SYMBOL(phy_scan_fixups); 151 152 static 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 */ 210 static int 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 = mdiobus_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 = mdiobus_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 } 233 234 /** 235 * get_phy_device - reads the specified PHY device and returns its @phy_device struct 236 * @bus: the target MII bus 237 * @addr: PHY address on the MII bus 238 * 239 * Description: Reads the ID registers of the PHY at @addr on the 240 * @bus, then allocates and returns the phy_device to represent it. 241 */ 242 struct phy_device * get_phy_device(struct mii_bus *bus, int addr) 243 { 244 struct phy_device *dev = NULL; 245 u32 phy_id; 246 int r; 247 248 r = get_phy_id(bus, addr, &phy_id); 249 if (r) 250 return ERR_PTR(r); 251 252 /* If the phy_id is mostly Fs, there is no device there */ 253 if ((phy_id & 0x1fffffff) == 0x1fffffff) 254 return NULL; 255 256 dev = phy_device_create(bus, addr, phy_id); 257 258 return dev; 259 } 260 EXPORT_SYMBOL(get_phy_device); 261 262 /** 263 * phy_device_register - Register the phy device on the MDIO bus 264 * @phydev: phy_device structure to be added to the MDIO bus 265 */ 266 int phy_device_register(struct phy_device *phydev) 267 { 268 int err; 269 270 /* Don't register a phy if one is already registered at this 271 * address */ 272 if (phydev->bus->phy_map[phydev->addr]) 273 return -EINVAL; 274 phydev->bus->phy_map[phydev->addr] = phydev; 275 276 /* Run all of the fixups for this PHY */ 277 phy_scan_fixups(phydev); 278 279 err = device_register(&phydev->dev); 280 if (err) { 281 pr_err("phy %d failed to register\n", phydev->addr); 282 goto out; 283 } 284 285 return 0; 286 287 out: 288 phydev->bus->phy_map[phydev->addr] = NULL; 289 return err; 290 } 291 EXPORT_SYMBOL(phy_device_register); 292 293 /** 294 * phy_find_first - finds the first PHY device on the bus 295 * @bus: the target MII bus 296 */ 297 struct phy_device *phy_find_first(struct mii_bus *bus) 298 { 299 int addr; 300 301 for (addr = 0; addr < PHY_MAX_ADDR; addr++) { 302 if (bus->phy_map[addr]) 303 return bus->phy_map[addr]; 304 } 305 return NULL; 306 } 307 EXPORT_SYMBOL(phy_find_first); 308 309 /** 310 * phy_prepare_link - prepares the PHY layer to monitor link status 311 * @phydev: target phy_device struct 312 * @handler: callback function for link status change notifications 313 * 314 * Description: Tells the PHY infrastructure to handle the 315 * gory details on monitoring link status (whether through 316 * polling or an interrupt), and to call back to the 317 * connected device driver when the link status changes. 318 * If you want to monitor your own link state, don't call 319 * this function. 320 */ 321 static void phy_prepare_link(struct phy_device *phydev, 322 void (*handler)(struct net_device *)) 323 { 324 phydev->adjust_link = handler; 325 } 326 327 /** 328 * phy_connect_direct - connect an ethernet device to a specific phy_device 329 * @dev: the network device to connect 330 * @phydev: the pointer to the phy device 331 * @handler: callback function for state change notifications 332 * @flags: PHY device's dev_flags 333 * @interface: PHY device's interface 334 */ 335 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, 336 void (*handler)(struct net_device *), u32 flags, 337 phy_interface_t interface) 338 { 339 int rc; 340 341 rc = phy_attach_direct(dev, phydev, flags, interface); 342 if (rc) 343 return rc; 344 345 phy_prepare_link(phydev, handler); 346 phy_start_machine(phydev, NULL); 347 if (phydev->irq > 0) 348 phy_start_interrupts(phydev); 349 350 return 0; 351 } 352 EXPORT_SYMBOL(phy_connect_direct); 353 354 /** 355 * phy_connect - connect an ethernet device to a PHY device 356 * @dev: the network device to connect 357 * @bus_id: the id string of the PHY device to connect 358 * @handler: callback function for state change notifications 359 * @flags: PHY device's dev_flags 360 * @interface: PHY device's interface 361 * 362 * Description: Convenience function for connecting ethernet 363 * devices to PHY devices. The default behavior is for 364 * the PHY infrastructure to handle everything, and only notify 365 * the connected driver when the link status changes. If you 366 * don't want, or can't use the provided functionality, you may 367 * choose to call only the subset of functions which provide 368 * the desired functionality. 369 */ 370 struct phy_device * phy_connect(struct net_device *dev, const char *bus_id, 371 void (*handler)(struct net_device *), u32 flags, 372 phy_interface_t interface) 373 { 374 struct phy_device *phydev; 375 struct device *d; 376 int rc; 377 378 /* Search the list of PHY devices on the mdio bus for the 379 * PHY with the requested name */ 380 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id); 381 if (!d) { 382 pr_err("PHY %s not found\n", bus_id); 383 return ERR_PTR(-ENODEV); 384 } 385 phydev = to_phy_device(d); 386 387 rc = phy_connect_direct(dev, phydev, handler, flags, interface); 388 if (rc) 389 return ERR_PTR(rc); 390 391 return phydev; 392 } 393 EXPORT_SYMBOL(phy_connect); 394 395 /** 396 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device 397 * @phydev: target phy_device struct 398 */ 399 void phy_disconnect(struct phy_device *phydev) 400 { 401 if (phydev->irq > 0) 402 phy_stop_interrupts(phydev); 403 404 phy_stop_machine(phydev); 405 406 phydev->adjust_link = NULL; 407 408 phy_detach(phydev); 409 } 410 EXPORT_SYMBOL(phy_disconnect); 411 412 int phy_init_hw(struct phy_device *phydev) 413 { 414 int ret; 415 416 if (!phydev->drv || !phydev->drv->config_init) 417 return 0; 418 419 ret = phy_scan_fixups(phydev); 420 if (ret < 0) 421 return ret; 422 423 return phydev->drv->config_init(phydev); 424 } 425 426 /** 427 * phy_attach_direct - attach a network device to a given PHY device pointer 428 * @dev: network device to attach 429 * @phydev: Pointer to phy_device to attach 430 * @flags: PHY device's dev_flags 431 * @interface: PHY device's interface 432 * 433 * Description: Called by drivers to attach to a particular PHY 434 * device. The phy_device is found, and properly hooked up 435 * to the phy_driver. If no driver is attached, then the 436 * genphy_driver is used. The phy_device is given a ptr to 437 * the attaching device, and given a callback for link status 438 * change. The phy_device is returned to the attaching driver. 439 */ 440 static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, 441 u32 flags, phy_interface_t interface) 442 { 443 struct device *d = &phydev->dev; 444 int err; 445 446 /* Assume that if there is no driver, that it doesn't 447 * exist, and we should use the genphy driver. */ 448 if (NULL == d->driver) { 449 d->driver = &genphy_driver.driver; 450 451 err = d->driver->probe(d); 452 if (err >= 0) 453 err = device_bind_driver(d); 454 455 if (err) 456 return err; 457 } 458 459 if (phydev->attached_dev) { 460 dev_err(&dev->dev, "PHY already attached\n"); 461 return -EBUSY; 462 } 463 464 phydev->attached_dev = dev; 465 dev->phydev = phydev; 466 467 phydev->dev_flags = flags; 468 469 phydev->interface = interface; 470 471 phydev->state = PHY_READY; 472 473 /* Do initial configuration here, now that 474 * we have certain key parameters 475 * (dev_flags and interface) */ 476 err = phy_init_hw(phydev); 477 if (err) 478 phy_detach(phydev); 479 480 return err; 481 } 482 483 /** 484 * phy_attach - attach a network device to a particular PHY device 485 * @dev: network device to attach 486 * @bus_id: Bus ID of PHY device to attach 487 * @flags: PHY device's dev_flags 488 * @interface: PHY device's interface 489 * 490 * Description: Same as phy_attach_direct() except that a PHY bus_id 491 * string is passed instead of a pointer to a struct phy_device. 492 */ 493 struct phy_device *phy_attach(struct net_device *dev, 494 const char *bus_id, u32 flags, phy_interface_t interface) 495 { 496 struct bus_type *bus = &mdio_bus_type; 497 struct phy_device *phydev; 498 struct device *d; 499 int rc; 500 501 /* Search the list of PHY devices on the mdio bus for the 502 * PHY with the requested name */ 503 d = bus_find_device_by_name(bus, NULL, bus_id); 504 if (!d) { 505 pr_err("PHY %s not found\n", bus_id); 506 return ERR_PTR(-ENODEV); 507 } 508 phydev = to_phy_device(d); 509 510 rc = phy_attach_direct(dev, phydev, flags, interface); 511 if (rc) 512 return ERR_PTR(rc); 513 514 return phydev; 515 } 516 EXPORT_SYMBOL(phy_attach); 517 518 /** 519 * phy_detach - detach a PHY device from its network device 520 * @phydev: target phy_device struct 521 */ 522 void phy_detach(struct phy_device *phydev) 523 { 524 phydev->attached_dev->phydev = NULL; 525 phydev->attached_dev = NULL; 526 527 /* If the device had no specific driver before (i.e. - it 528 * was using the generic driver), we unbind the device 529 * from the generic driver so that there's a chance a 530 * real driver could be loaded */ 531 if (phydev->dev.driver == &genphy_driver.driver) 532 device_release_driver(&phydev->dev); 533 } 534 EXPORT_SYMBOL(phy_detach); 535 536 537 /* Generic PHY support and helper functions */ 538 539 /** 540 * genphy_config_advert - sanitize and advertise auto-negotiation parameters 541 * @phydev: target phy_device struct 542 * 543 * Description: Writes MII_ADVERTISE with the appropriate values, 544 * after sanitizing the values to make sure we only advertise 545 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 546 * hasn't changed, and > 0 if it has changed. 547 */ 548 static int genphy_config_advert(struct phy_device *phydev) 549 { 550 u32 advertise; 551 int oldadv, adv; 552 int err, changed = 0; 553 554 /* Only allow advertising what 555 * this PHY supports */ 556 phydev->advertising &= phydev->supported; 557 advertise = phydev->advertising; 558 559 /* Setup standard advertisement */ 560 oldadv = adv = phy_read(phydev, MII_ADVERTISE); 561 562 if (adv < 0) 563 return adv; 564 565 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 566 ADVERTISE_PAUSE_ASYM); 567 adv |= ethtool_adv_to_mii_adv_t(advertise); 568 569 if (adv != oldadv) { 570 err = phy_write(phydev, MII_ADVERTISE, adv); 571 572 if (err < 0) 573 return err; 574 changed = 1; 575 } 576 577 /* Configure gigabit if it's supported */ 578 if (phydev->supported & (SUPPORTED_1000baseT_Half | 579 SUPPORTED_1000baseT_Full)) { 580 oldadv = adv = phy_read(phydev, MII_CTRL1000); 581 582 if (adv < 0) 583 return adv; 584 585 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF); 586 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise); 587 588 if (adv != oldadv) { 589 err = phy_write(phydev, MII_CTRL1000, adv); 590 591 if (err < 0) 592 return err; 593 changed = 1; 594 } 595 } 596 597 return changed; 598 } 599 600 /** 601 * genphy_setup_forced - configures/forces speed/duplex from @phydev 602 * @phydev: target phy_device struct 603 * 604 * Description: Configures MII_BMCR to force speed/duplex 605 * to the values in phydev. Assumes that the values are valid. 606 * Please see phy_sanitize_settings(). 607 */ 608 static int genphy_setup_forced(struct phy_device *phydev) 609 { 610 int err; 611 int ctl = 0; 612 613 phydev->pause = phydev->asym_pause = 0; 614 615 if (SPEED_1000 == phydev->speed) 616 ctl |= BMCR_SPEED1000; 617 else if (SPEED_100 == phydev->speed) 618 ctl |= BMCR_SPEED100; 619 620 if (DUPLEX_FULL == phydev->duplex) 621 ctl |= BMCR_FULLDPLX; 622 623 err = phy_write(phydev, MII_BMCR, ctl); 624 625 return err; 626 } 627 628 629 /** 630 * genphy_restart_aneg - Enable and Restart Autonegotiation 631 * @phydev: target phy_device struct 632 */ 633 int genphy_restart_aneg(struct phy_device *phydev) 634 { 635 int ctl; 636 637 ctl = phy_read(phydev, MII_BMCR); 638 639 if (ctl < 0) 640 return ctl; 641 642 ctl |= (BMCR_ANENABLE | BMCR_ANRESTART); 643 644 /* Don't isolate the PHY if we're negotiating */ 645 ctl &= ~(BMCR_ISOLATE); 646 647 ctl = phy_write(phydev, MII_BMCR, ctl); 648 649 return ctl; 650 } 651 EXPORT_SYMBOL(genphy_restart_aneg); 652 653 654 /** 655 * genphy_config_aneg - restart auto-negotiation or write BMCR 656 * @phydev: target phy_device struct 657 * 658 * Description: If auto-negotiation is enabled, we configure the 659 * advertising, and then restart auto-negotiation. If it is not 660 * enabled, then we write the BMCR. 661 */ 662 int genphy_config_aneg(struct phy_device *phydev) 663 { 664 int result; 665 666 if (AUTONEG_ENABLE != phydev->autoneg) 667 return genphy_setup_forced(phydev); 668 669 result = genphy_config_advert(phydev); 670 671 if (result < 0) /* error */ 672 return result; 673 674 if (result == 0) { 675 /* Advertisement hasn't changed, but maybe aneg was never on to 676 * begin with? Or maybe phy was isolated? */ 677 int ctl = phy_read(phydev, MII_BMCR); 678 679 if (ctl < 0) 680 return ctl; 681 682 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 683 result = 1; /* do restart aneg */ 684 } 685 686 /* Only restart aneg if we are advertising something different 687 * than we were before. */ 688 if (result > 0) 689 result = genphy_restart_aneg(phydev); 690 691 return result; 692 } 693 EXPORT_SYMBOL(genphy_config_aneg); 694 695 /** 696 * genphy_update_link - update link status in @phydev 697 * @phydev: target phy_device struct 698 * 699 * Description: Update the value in phydev->link to reflect the 700 * current link value. In order to do this, we need to read 701 * the status register twice, keeping the second value. 702 */ 703 int genphy_update_link(struct phy_device *phydev) 704 { 705 int status; 706 707 /* Do a fake read */ 708 status = phy_read(phydev, MII_BMSR); 709 710 if (status < 0) 711 return status; 712 713 /* Read link and autonegotiation status */ 714 status = phy_read(phydev, MII_BMSR); 715 716 if (status < 0) 717 return status; 718 719 if ((status & BMSR_LSTATUS) == 0) 720 phydev->link = 0; 721 else 722 phydev->link = 1; 723 724 return 0; 725 } 726 EXPORT_SYMBOL(genphy_update_link); 727 728 /** 729 * genphy_read_status - check the link status and update current link state 730 * @phydev: target phy_device struct 731 * 732 * Description: Check the link, then figure out the current state 733 * by comparing what we advertise with what the link partner 734 * advertises. Start by checking the gigabit possibilities, 735 * then move on to 10/100. 736 */ 737 int genphy_read_status(struct phy_device *phydev) 738 { 739 int adv; 740 int err; 741 int lpa; 742 int lpagb = 0; 743 744 /* Update the link, but return if there 745 * was an error */ 746 err = genphy_update_link(phydev); 747 if (err) 748 return err; 749 750 if (AUTONEG_ENABLE == phydev->autoneg) { 751 if (phydev->supported & (SUPPORTED_1000baseT_Half 752 | SUPPORTED_1000baseT_Full)) { 753 lpagb = phy_read(phydev, MII_STAT1000); 754 755 if (lpagb < 0) 756 return lpagb; 757 758 adv = phy_read(phydev, MII_CTRL1000); 759 760 if (adv < 0) 761 return adv; 762 763 lpagb &= adv << 2; 764 } 765 766 lpa = phy_read(phydev, MII_LPA); 767 768 if (lpa < 0) 769 return lpa; 770 771 adv = phy_read(phydev, MII_ADVERTISE); 772 773 if (adv < 0) 774 return adv; 775 776 lpa &= adv; 777 778 phydev->speed = SPEED_10; 779 phydev->duplex = DUPLEX_HALF; 780 phydev->pause = phydev->asym_pause = 0; 781 782 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) { 783 phydev->speed = SPEED_1000; 784 785 if (lpagb & LPA_1000FULL) 786 phydev->duplex = DUPLEX_FULL; 787 } else if (lpa & (LPA_100FULL | LPA_100HALF)) { 788 phydev->speed = SPEED_100; 789 790 if (lpa & LPA_100FULL) 791 phydev->duplex = DUPLEX_FULL; 792 } else 793 if (lpa & LPA_10FULL) 794 phydev->duplex = DUPLEX_FULL; 795 796 if (phydev->duplex == DUPLEX_FULL){ 797 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0; 798 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0; 799 } 800 } else { 801 int bmcr = phy_read(phydev, MII_BMCR); 802 if (bmcr < 0) 803 return bmcr; 804 805 if (bmcr & BMCR_FULLDPLX) 806 phydev->duplex = DUPLEX_FULL; 807 else 808 phydev->duplex = DUPLEX_HALF; 809 810 if (bmcr & BMCR_SPEED1000) 811 phydev->speed = SPEED_1000; 812 else if (bmcr & BMCR_SPEED100) 813 phydev->speed = SPEED_100; 814 else 815 phydev->speed = SPEED_10; 816 817 phydev->pause = phydev->asym_pause = 0; 818 } 819 820 return 0; 821 } 822 EXPORT_SYMBOL(genphy_read_status); 823 824 static int genphy_config_init(struct phy_device *phydev) 825 { 826 int val; 827 u32 features; 828 829 /* For now, I'll claim that the generic driver supports 830 * all possible port types */ 831 features = (SUPPORTED_TP | SUPPORTED_MII 832 | SUPPORTED_AUI | SUPPORTED_FIBRE | 833 SUPPORTED_BNC); 834 835 /* Do we support autonegotiation? */ 836 val = phy_read(phydev, MII_BMSR); 837 838 if (val < 0) 839 return val; 840 841 if (val & BMSR_ANEGCAPABLE) 842 features |= SUPPORTED_Autoneg; 843 844 if (val & BMSR_100FULL) 845 features |= SUPPORTED_100baseT_Full; 846 if (val & BMSR_100HALF) 847 features |= SUPPORTED_100baseT_Half; 848 if (val & BMSR_10FULL) 849 features |= SUPPORTED_10baseT_Full; 850 if (val & BMSR_10HALF) 851 features |= SUPPORTED_10baseT_Half; 852 853 if (val & BMSR_ESTATEN) { 854 val = phy_read(phydev, MII_ESTATUS); 855 856 if (val < 0) 857 return val; 858 859 if (val & ESTATUS_1000_TFULL) 860 features |= SUPPORTED_1000baseT_Full; 861 if (val & ESTATUS_1000_THALF) 862 features |= SUPPORTED_1000baseT_Half; 863 } 864 865 phydev->supported = features; 866 phydev->advertising = features; 867 868 return 0; 869 } 870 int genphy_suspend(struct phy_device *phydev) 871 { 872 int value; 873 874 mutex_lock(&phydev->lock); 875 876 value = phy_read(phydev, MII_BMCR); 877 phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN)); 878 879 mutex_unlock(&phydev->lock); 880 881 return 0; 882 } 883 EXPORT_SYMBOL(genphy_suspend); 884 885 int genphy_resume(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 } 898 EXPORT_SYMBOL(genphy_resume); 899 900 /** 901 * phy_probe - probe and init a PHY device 902 * @dev: device to probe and init 903 * 904 * Description: Take care of setting up the phy_device structure, 905 * set the state to READY (the driver's init function should 906 * set it to STARTING if needed). 907 */ 908 static int phy_probe(struct device *dev) 909 { 910 struct phy_device *phydev; 911 struct phy_driver *phydrv; 912 struct device_driver *drv; 913 int err = 0; 914 915 phydev = to_phy_device(dev); 916 917 drv = phydev->dev.driver; 918 phydrv = to_phy_driver(drv); 919 phydev->drv = phydrv; 920 921 /* Disable the interrupt if the PHY doesn't support it */ 922 if (!(phydrv->flags & PHY_HAS_INTERRUPT)) 923 phydev->irq = PHY_POLL; 924 925 mutex_lock(&phydev->lock); 926 927 /* Start out supporting everything. Eventually, 928 * a controller will attach, and may modify one 929 * or both of these values */ 930 phydev->supported = phydrv->features; 931 phydev->advertising = phydrv->features; 932 933 /* Set the state to READY by default */ 934 phydev->state = PHY_READY; 935 936 if (phydev->drv->probe) 937 err = phydev->drv->probe(phydev); 938 939 mutex_unlock(&phydev->lock); 940 941 return err; 942 943 } 944 945 static int phy_remove(struct device *dev) 946 { 947 struct phy_device *phydev; 948 949 phydev = to_phy_device(dev); 950 951 mutex_lock(&phydev->lock); 952 phydev->state = PHY_DOWN; 953 mutex_unlock(&phydev->lock); 954 955 if (phydev->drv->remove) 956 phydev->drv->remove(phydev); 957 phydev->drv = NULL; 958 959 return 0; 960 } 961 962 /** 963 * phy_driver_register - register a phy_driver with the PHY layer 964 * @new_driver: new phy_driver to register 965 */ 966 int phy_driver_register(struct phy_driver *new_driver) 967 { 968 int retval; 969 970 new_driver->driver.name = new_driver->name; 971 new_driver->driver.bus = &mdio_bus_type; 972 new_driver->driver.probe = phy_probe; 973 new_driver->driver.remove = phy_remove; 974 975 retval = driver_register(&new_driver->driver); 976 977 if (retval) { 978 printk(KERN_ERR "%s: Error %d in registering driver\n", 979 new_driver->name, retval); 980 981 return retval; 982 } 983 984 pr_debug("%s: Registered new driver\n", new_driver->name); 985 986 return 0; 987 } 988 EXPORT_SYMBOL(phy_driver_register); 989 990 void phy_driver_unregister(struct phy_driver *drv) 991 { 992 driver_unregister(&drv->driver); 993 } 994 EXPORT_SYMBOL(phy_driver_unregister); 995 996 static struct phy_driver genphy_driver = { 997 .phy_id = 0xffffffff, 998 .phy_id_mask = 0xffffffff, 999 .name = "Generic PHY", 1000 .config_init = genphy_config_init, 1001 .features = 0, 1002 .config_aneg = genphy_config_aneg, 1003 .read_status = genphy_read_status, 1004 .suspend = genphy_suspend, 1005 .resume = genphy_resume, 1006 .driver = {.owner= THIS_MODULE, }, 1007 }; 1008 1009 static int __init phy_init(void) 1010 { 1011 int rc; 1012 1013 rc = mdio_bus_init(); 1014 if (rc) 1015 return rc; 1016 1017 rc = phy_driver_register(&genphy_driver); 1018 if (rc) 1019 mdio_bus_exit(); 1020 1021 return rc; 1022 } 1023 1024 static void __exit phy_exit(void) 1025 { 1026 phy_driver_unregister(&genphy_driver); 1027 mdio_bus_exit(); 1028 } 1029 1030 subsys_initcall(phy_init); 1031 module_exit(phy_exit); 1032