3842 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/* Framework for finding and configuring PHYs.3 * Also contains generic PHY driver4 *5 * Author: Andy Fleming6 *7 * Copyright (c) 2004 Freescale Semiconductor, Inc.8 */9 10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt11 12#include <linux/acpi.h>13#include <linux/bitmap.h>14#include <linux/delay.h>15#include <linux/errno.h>16#include <linux/etherdevice.h>17#include <linux/ethtool.h>18#include <linux/init.h>19#include <linux/interrupt.h>20#include <linux/io.h>21#include <linux/kernel.h>22#include <linux/list.h>23#include <linux/mdio.h>24#include <linux/mii.h>25#include <linux/mm.h>26#include <linux/module.h>27#include <linux/of.h>28#include <linux/netdevice.h>29#include <linux/phy.h>30#include <linux/phylib_stubs.h>31#include <linux/phy_led_triggers.h>32#include <linux/phy_link_topology.h>33#include <linux/pse-pd/pse.h>34#include <linux/property.h>35#include <linux/rtnetlink.h>36#include <linux/sfp.h>37#include <linux/skbuff.h>38#include <linux/slab.h>39#include <linux/string.h>40#include <linux/uaccess.h>41#include <linux/unistd.h>42 43MODULE_DESCRIPTION("PHY library");44MODULE_AUTHOR("Andy Fleming");45MODULE_LICENSE("GPL");46 47__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;48EXPORT_SYMBOL_GPL(phy_basic_features);49 50__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;51EXPORT_SYMBOL_GPL(phy_basic_t1_features);52 53__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1s_p2mp_features) __ro_after_init;54EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features);55 56__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;57EXPORT_SYMBOL_GPL(phy_gbit_features);58 59__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;60EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);61 62__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;63EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);64 65__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;66EXPORT_SYMBOL_GPL(phy_10gbit_features);67 68__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;69EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);70 71const int phy_basic_ports_array[3] = {72 ETHTOOL_LINK_MODE_Autoneg_BIT,73 ETHTOOL_LINK_MODE_TP_BIT,74 ETHTOOL_LINK_MODE_MII_BIT,75};76EXPORT_SYMBOL_GPL(phy_basic_ports_array);77 78const int phy_fibre_port_array[1] = {79 ETHTOOL_LINK_MODE_FIBRE_BIT,80};81EXPORT_SYMBOL_GPL(phy_fibre_port_array);82 83const int phy_all_ports_features_array[7] = {84 ETHTOOL_LINK_MODE_Autoneg_BIT,85 ETHTOOL_LINK_MODE_TP_BIT,86 ETHTOOL_LINK_MODE_MII_BIT,87 ETHTOOL_LINK_MODE_FIBRE_BIT,88 ETHTOOL_LINK_MODE_AUI_BIT,89 ETHTOOL_LINK_MODE_BNC_BIT,90 ETHTOOL_LINK_MODE_Backplane_BIT,91};92EXPORT_SYMBOL_GPL(phy_all_ports_features_array);93 94const int phy_10_100_features_array[4] = {95 ETHTOOL_LINK_MODE_10baseT_Half_BIT,96 ETHTOOL_LINK_MODE_10baseT_Full_BIT,97 ETHTOOL_LINK_MODE_100baseT_Half_BIT,98 ETHTOOL_LINK_MODE_100baseT_Full_BIT,99};100EXPORT_SYMBOL_GPL(phy_10_100_features_array);101 102const int phy_basic_t1_features_array[3] = {103 ETHTOOL_LINK_MODE_TP_BIT,104 ETHTOOL_LINK_MODE_10baseT1L_Full_BIT,105 ETHTOOL_LINK_MODE_100baseT1_Full_BIT,106};107EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);108 109const int phy_basic_t1s_p2mp_features_array[2] = {110 ETHTOOL_LINK_MODE_TP_BIT,111 ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT,112};113EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features_array);114 115const int phy_gbit_features_array[2] = {116 ETHTOOL_LINK_MODE_1000baseT_Half_BIT,117 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,118};119EXPORT_SYMBOL_GPL(phy_gbit_features_array);120 121const int phy_10gbit_features_array[1] = {122 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,123};124EXPORT_SYMBOL_GPL(phy_10gbit_features_array);125 126static const int phy_10gbit_fec_features_array[1] = {127 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,128};129 130__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;131EXPORT_SYMBOL_GPL(phy_10gbit_full_features);132 133static const int phy_10gbit_full_features_array[] = {134 ETHTOOL_LINK_MODE_10baseT_Full_BIT,135 ETHTOOL_LINK_MODE_100baseT_Full_BIT,136 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,137 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,138};139 140static const int phy_eee_cap1_features_array[] = {141 ETHTOOL_LINK_MODE_100baseT_Full_BIT,142 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,143 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,144 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,145 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,146 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,147};148 149__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap1_features) __ro_after_init;150EXPORT_SYMBOL_GPL(phy_eee_cap1_features);151 152static const int phy_eee_cap2_features_array[] = {153 ETHTOOL_LINK_MODE_2500baseT_Full_BIT,154 ETHTOOL_LINK_MODE_5000baseT_Full_BIT,155};156 157__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap2_features) __ro_after_init;158EXPORT_SYMBOL_GPL(phy_eee_cap2_features);159 160static void features_init(void)161{162 /* 10/100 half/full*/163 linkmode_set_bit_array(phy_basic_ports_array,164 ARRAY_SIZE(phy_basic_ports_array),165 phy_basic_features);166 linkmode_set_bit_array(phy_10_100_features_array,167 ARRAY_SIZE(phy_10_100_features_array),168 phy_basic_features);169 170 /* 100 full, TP */171 linkmode_set_bit_array(phy_basic_t1_features_array,172 ARRAY_SIZE(phy_basic_t1_features_array),173 phy_basic_t1_features);174 175 /* 10 half, P2MP, TP */176 linkmode_set_bit_array(phy_basic_t1s_p2mp_features_array,177 ARRAY_SIZE(phy_basic_t1s_p2mp_features_array),178 phy_basic_t1s_p2mp_features);179 180 /* 10/100 half/full + 1000 half/full */181 linkmode_set_bit_array(phy_basic_ports_array,182 ARRAY_SIZE(phy_basic_ports_array),183 phy_gbit_features);184 linkmode_set_bit_array(phy_10_100_features_array,185 ARRAY_SIZE(phy_10_100_features_array),186 phy_gbit_features);187 linkmode_set_bit_array(phy_gbit_features_array,188 ARRAY_SIZE(phy_gbit_features_array),189 phy_gbit_features);190 191 /* 10/100 half/full + 1000 half/full + fibre*/192 linkmode_set_bit_array(phy_basic_ports_array,193 ARRAY_SIZE(phy_basic_ports_array),194 phy_gbit_fibre_features);195 linkmode_set_bit_array(phy_10_100_features_array,196 ARRAY_SIZE(phy_10_100_features_array),197 phy_gbit_fibre_features);198 linkmode_set_bit_array(phy_gbit_features_array,199 ARRAY_SIZE(phy_gbit_features_array),200 phy_gbit_fibre_features);201 linkmode_set_bit_array(phy_fibre_port_array,202 ARRAY_SIZE(phy_fibre_port_array),203 phy_gbit_fibre_features);204 205 /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/206 linkmode_set_bit_array(phy_all_ports_features_array,207 ARRAY_SIZE(phy_all_ports_features_array),208 phy_gbit_all_ports_features);209 linkmode_set_bit_array(phy_10_100_features_array,210 ARRAY_SIZE(phy_10_100_features_array),211 phy_gbit_all_ports_features);212 linkmode_set_bit_array(phy_gbit_features_array,213 ARRAY_SIZE(phy_gbit_features_array),214 phy_gbit_all_ports_features);215 216 /* 10/100 half/full + 1000 half/full + 10G full*/217 linkmode_set_bit_array(phy_all_ports_features_array,218 ARRAY_SIZE(phy_all_ports_features_array),219 phy_10gbit_features);220 linkmode_set_bit_array(phy_10_100_features_array,221 ARRAY_SIZE(phy_10_100_features_array),222 phy_10gbit_features);223 linkmode_set_bit_array(phy_gbit_features_array,224 ARRAY_SIZE(phy_gbit_features_array),225 phy_10gbit_features);226 linkmode_set_bit_array(phy_10gbit_features_array,227 ARRAY_SIZE(phy_10gbit_features_array),228 phy_10gbit_features);229 230 /* 10/100/1000/10G full */231 linkmode_set_bit_array(phy_all_ports_features_array,232 ARRAY_SIZE(phy_all_ports_features_array),233 phy_10gbit_full_features);234 linkmode_set_bit_array(phy_10gbit_full_features_array,235 ARRAY_SIZE(phy_10gbit_full_features_array),236 phy_10gbit_full_features);237 /* 10G FEC only */238 linkmode_set_bit_array(phy_10gbit_fec_features_array,239 ARRAY_SIZE(phy_10gbit_fec_features_array),240 phy_10gbit_fec_features);241 linkmode_set_bit_array(phy_eee_cap1_features_array,242 ARRAY_SIZE(phy_eee_cap1_features_array),243 phy_eee_cap1_features);244 linkmode_set_bit_array(phy_eee_cap2_features_array,245 ARRAY_SIZE(phy_eee_cap2_features_array),246 phy_eee_cap2_features);247 248}249 250void phy_device_free(struct phy_device *phydev)251{252 put_device(&phydev->mdio.dev);253}254EXPORT_SYMBOL(phy_device_free);255 256static void phy_mdio_device_free(struct mdio_device *mdiodev)257{258 struct phy_device *phydev;259 260 phydev = container_of(mdiodev, struct phy_device, mdio);261 phy_device_free(phydev);262}263 264static void phy_device_release(struct device *dev)265{266 fwnode_handle_put(dev->fwnode);267 kfree(to_phy_device(dev));268}269 270static void phy_mdio_device_remove(struct mdio_device *mdiodev)271{272 struct phy_device *phydev;273 274 phydev = container_of(mdiodev, struct phy_device, mdio);275 phy_device_remove(phydev);276}277 278static struct phy_driver genphy_driver;279 280static LIST_HEAD(phy_fixup_list);281static DEFINE_MUTEX(phy_fixup_lock);282 283static bool phy_drv_wol_enabled(struct phy_device *phydev)284{285 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };286 287 phy_ethtool_get_wol(phydev, &wol);288 289 return wol.wolopts != 0;290}291 292static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)293{294 struct device_driver *drv = phydev->mdio.dev.driver;295 struct phy_driver *phydrv = to_phy_driver(drv);296 struct net_device *netdev = phydev->attached_dev;297 298 if (!drv || !phydrv->suspend)299 return false;300 301 /* If the PHY on the mido bus is not attached but has WOL enabled302 * we cannot suspend the PHY.303 */304 if (!netdev && phy_drv_wol_enabled(phydev))305 return false;306 307 /* PHY not attached? May suspend if the PHY has not already been308 * suspended as part of a prior call to phy_disconnect() ->309 * phy_detach() -> phy_suspend() because the parent netdev might be the310 * MDIO bus driver and clock gated at this point.311 */312 if (!netdev)313 goto out;314 315 if (netdev->ethtool->wol_enabled)316 return false;317 318 /* As long as not all affected network drivers support the319 * wol_enabled flag, let's check for hints that WoL is enabled.320 * Don't suspend PHY if the attached netdev parent may wake up.321 * The parent may point to a PCI device, as in tg3 driver.322 */323 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))324 return false;325 326 /* Also don't suspend PHY if the netdev itself may wakeup. This327 * is the case for devices w/o underlaying pwr. mgmt. aware bus,328 * e.g. SoC devices.329 */330 if (device_may_wakeup(&netdev->dev))331 return false;332 333out:334 return !phydev->suspended;335}336 337static __maybe_unused int mdio_bus_phy_suspend(struct device *dev)338{339 struct phy_device *phydev = to_phy_device(dev);340 341 if (phydev->mac_managed_pm)342 return 0;343 344 /* Wakeup interrupts may occur during the system sleep transition when345 * the PHY is inaccessible. Set flag to postpone handling until the PHY346 * has resumed. Wait for concurrent interrupt handler to complete.347 */348 if (phy_interrupt_is_valid(phydev)) {349 phydev->irq_suspended = 1;350 synchronize_irq(phydev->irq);351 }352 353 /* We must stop the state machine manually, otherwise it stops out of354 * control, possibly with the phydev->lock held. Upon resume, netdev355 * may call phy routines that try to grab the same lock, and that may356 * lead to a deadlock.357 */358 if (phydev->attached_dev && phydev->adjust_link)359 phy_stop_machine(phydev);360 361 if (!mdio_bus_phy_may_suspend(phydev))362 return 0;363 364 phydev->suspended_by_mdio_bus = 1;365 366 return phy_suspend(phydev);367}368 369static __maybe_unused int mdio_bus_phy_resume(struct device *dev)370{371 struct phy_device *phydev = to_phy_device(dev);372 int ret;373 374 if (phydev->mac_managed_pm)375 return 0;376 377 if (!phydev->suspended_by_mdio_bus)378 goto no_resume;379 380 phydev->suspended_by_mdio_bus = 0;381 382 /* If we managed to get here with the PHY state machine in a state383 * neither PHY_HALTED, PHY_READY nor PHY_UP, this is an indication384 * that something went wrong and we should most likely be using385 * MAC managed PM, but we are not.386 */387 WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY &&388 phydev->state != PHY_UP);389 390 ret = phy_init_hw(phydev);391 if (ret < 0)392 return ret;393 394 ret = phy_resume(phydev);395 if (ret < 0)396 return ret;397no_resume:398 if (phy_interrupt_is_valid(phydev)) {399 phydev->irq_suspended = 0;400 synchronize_irq(phydev->irq);401 402 /* Rerun interrupts which were postponed by phy_interrupt()403 * because they occurred during the system sleep transition.404 */405 if (phydev->irq_rerun) {406 phydev->irq_rerun = 0;407 enable_irq(phydev->irq);408 irq_wake_thread(phydev->irq, phydev);409 }410 }411 412 if (phydev->attached_dev && phydev->adjust_link)413 phy_start_machine(phydev);414 415 return 0;416}417 418static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend,419 mdio_bus_phy_resume);420 421/**422 * phy_register_fixup - creates a new phy_fixup and adds it to the list423 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)424 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)425 * It can also be PHY_ANY_UID426 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before427 * comparison428 * @run: The actual code to be run when a matching PHY is found429 */430int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,431 int (*run)(struct phy_device *))432{433 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);434 435 if (!fixup)436 return -ENOMEM;437 438 strscpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));439 fixup->phy_uid = phy_uid;440 fixup->phy_uid_mask = phy_uid_mask;441 fixup->run = run;442 443 mutex_lock(&phy_fixup_lock);444 list_add_tail(&fixup->list, &phy_fixup_list);445 mutex_unlock(&phy_fixup_lock);446 447 return 0;448}449EXPORT_SYMBOL(phy_register_fixup);450 451/* Registers a fixup to be run on any PHY with the UID in phy_uid */452int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,453 int (*run)(struct phy_device *))454{455 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);456}457EXPORT_SYMBOL(phy_register_fixup_for_uid);458 459/* Registers a fixup to be run on the PHY with id string bus_id */460int phy_register_fixup_for_id(const char *bus_id,461 int (*run)(struct phy_device *))462{463 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);464}465EXPORT_SYMBOL(phy_register_fixup_for_id);466 467/**468 * phy_unregister_fixup - remove a phy_fixup from the list469 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list470 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list471 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison472 */473int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)474{475 struct list_head *pos, *n;476 struct phy_fixup *fixup;477 int ret;478 479 ret = -ENODEV;480 481 mutex_lock(&phy_fixup_lock);482 list_for_each_safe(pos, n, &phy_fixup_list) {483 fixup = list_entry(pos, struct phy_fixup, list);484 485 if ((!strcmp(fixup->bus_id, bus_id)) &&486 phy_id_compare(fixup->phy_uid, phy_uid, phy_uid_mask)) {487 list_del(&fixup->list);488 kfree(fixup);489 ret = 0;490 break;491 }492 }493 mutex_unlock(&phy_fixup_lock);494 495 return ret;496}497EXPORT_SYMBOL(phy_unregister_fixup);498 499/* Unregisters a fixup of any PHY with the UID in phy_uid */500int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)501{502 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);503}504EXPORT_SYMBOL(phy_unregister_fixup_for_uid);505 506/* Unregisters a fixup of the PHY with id string bus_id */507int phy_unregister_fixup_for_id(const char *bus_id)508{509 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);510}511EXPORT_SYMBOL(phy_unregister_fixup_for_id);512 513/* Returns 1 if fixup matches phydev in bus_id and phy_uid.514 * Fixups can be set to match any in one or more fields.515 */516static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)517{518 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)519 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)520 return 0;521 522 if (!phy_id_compare(phydev->phy_id, fixup->phy_uid,523 fixup->phy_uid_mask))524 if (fixup->phy_uid != PHY_ANY_UID)525 return 0;526 527 return 1;528}529 530/* Runs any matching fixups for this phydev */531static int phy_scan_fixups(struct phy_device *phydev)532{533 struct phy_fixup *fixup;534 535 mutex_lock(&phy_fixup_lock);536 list_for_each_entry(fixup, &phy_fixup_list, list) {537 if (phy_needs_fixup(phydev, fixup)) {538 int err = fixup->run(phydev);539 540 if (err < 0) {541 mutex_unlock(&phy_fixup_lock);542 return err;543 }544 phydev->has_fixups = true;545 }546 }547 mutex_unlock(&phy_fixup_lock);548 549 return 0;550}551 552static int phy_bus_match(struct device *dev, const struct device_driver *drv)553{554 struct phy_device *phydev = to_phy_device(dev);555 const struct phy_driver *phydrv = to_phy_driver(drv);556 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);557 int i;558 559 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))560 return 0;561 562 if (phydrv->match_phy_device)563 return phydrv->match_phy_device(phydev);564 565 if (phydev->is_c45) {566 for (i = 1; i < num_ids; i++) {567 if (phydev->c45_ids.device_ids[i] == 0xffffffff)568 continue;569 570 if (phy_id_compare(phydev->c45_ids.device_ids[i],571 phydrv->phy_id, phydrv->phy_id_mask))572 return 1;573 }574 return 0;575 } else {576 return phy_id_compare(phydev->phy_id, phydrv->phy_id,577 phydrv->phy_id_mask);578 }579}580 581static ssize_t582phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)583{584 struct phy_device *phydev = to_phy_device(dev);585 586 return sysfs_emit(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);587}588static DEVICE_ATTR_RO(phy_id);589 590static ssize_t591phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)592{593 struct phy_device *phydev = to_phy_device(dev);594 const char *mode = NULL;595 596 if (phy_is_internal(phydev))597 mode = "internal";598 else599 mode = phy_modes(phydev->interface);600 601 return sysfs_emit(buf, "%s\n", mode);602}603static DEVICE_ATTR_RO(phy_interface);604 605static ssize_t606phy_has_fixups_show(struct device *dev, struct device_attribute *attr,607 char *buf)608{609 struct phy_device *phydev = to_phy_device(dev);610 611 return sysfs_emit(buf, "%d\n", phydev->has_fixups);612}613static DEVICE_ATTR_RO(phy_has_fixups);614 615static ssize_t phy_dev_flags_show(struct device *dev,616 struct device_attribute *attr,617 char *buf)618{619 struct phy_device *phydev = to_phy_device(dev);620 621 return sysfs_emit(buf, "0x%08x\n", phydev->dev_flags);622}623static DEVICE_ATTR_RO(phy_dev_flags);624 625static struct attribute *phy_dev_attrs[] = {626 &dev_attr_phy_id.attr,627 &dev_attr_phy_interface.attr,628 &dev_attr_phy_has_fixups.attr,629 &dev_attr_phy_dev_flags.attr,630 NULL,631};632ATTRIBUTE_GROUPS(phy_dev);633 634static const struct device_type mdio_bus_phy_type = {635 .name = "PHY",636 .groups = phy_dev_groups,637 .release = phy_device_release,638 .pm = pm_ptr(&mdio_bus_phy_pm_ops),639};640 641static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)642{643 int ret;644 645 ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,646 MDIO_ID_ARGS(phy_id));647 /* We only check for failures in executing the usermode binary,648 * not whether a PHY driver module exists for the PHY ID.649 * Accept -ENOENT because this may occur in case no initramfs exists,650 * then modprobe isn't available.651 */652 if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {653 phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",654 ret, (unsigned long)phy_id);655 return ret;656 }657 658 return 0;659}660 661struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,662 bool is_c45,663 struct phy_c45_device_ids *c45_ids)664{665 struct phy_device *dev;666 struct mdio_device *mdiodev;667 int ret = 0;668 669 /* We allocate the device, and initialize the default values */670 dev = kzalloc(sizeof(*dev), GFP_KERNEL);671 if (!dev)672 return ERR_PTR(-ENOMEM);673 674 mdiodev = &dev->mdio;675 mdiodev->dev.parent = &bus->dev;676 mdiodev->dev.bus = &mdio_bus_type;677 mdiodev->dev.type = &mdio_bus_phy_type;678 mdiodev->bus = bus;679 mdiodev->bus_match = phy_bus_match;680 mdiodev->addr = addr;681 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;682 mdiodev->device_free = phy_mdio_device_free;683 mdiodev->device_remove = phy_mdio_device_remove;684 mdiodev->reset_state = -1;685 686 dev->speed = SPEED_UNKNOWN;687 dev->duplex = DUPLEX_UNKNOWN;688 dev->pause = 0;689 dev->asym_pause = 0;690 dev->link = 0;691 dev->port = PORT_TP;692 dev->interface = PHY_INTERFACE_MODE_GMII;693 694 dev->autoneg = AUTONEG_ENABLE;695 696 dev->pma_extable = -ENODATA;697 dev->is_c45 = is_c45;698 dev->phy_id = phy_id;699 if (c45_ids)700 dev->c45_ids = *c45_ids;701 dev->irq = bus->irq[addr];702 703 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);704 device_initialize(&mdiodev->dev);705 706 dev->state = PHY_DOWN;707 INIT_LIST_HEAD(&dev->leds);708 709 mutex_init(&dev->lock);710 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);711 712 /* Request the appropriate module unconditionally; don't713 * bother trying to do so only if it isn't already loaded,714 * because that gets complicated. A hotplug event would have715 * done an unconditional modprobe anyway.716 * We don't do normal hotplug because it won't work for MDIO717 * -- because it relies on the device staying around for long718 * enough for the driver to get loaded. With MDIO, the NIC719 * driver will get bored and give up as soon as it finds that720 * there's no driver _already_ loaded.721 */722 if (is_c45 && c45_ids) {723 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);724 int i;725 726 for (i = 1; i < num_ids; i++) {727 if (c45_ids->device_ids[i] == 0xffffffff)728 continue;729 730 ret = phy_request_driver_module(dev,731 c45_ids->device_ids[i]);732 if (ret)733 break;734 }735 } else {736 ret = phy_request_driver_module(dev, phy_id);737 }738 739 if (ret) {740 put_device(&mdiodev->dev);741 dev = ERR_PTR(ret);742 }743 744 return dev;745}746EXPORT_SYMBOL(phy_device_create);747 748/* phy_c45_probe_present - checks to see if a MMD is present in the package749 * @bus: the target MII bus750 * @prtad: PHY package address on the MII bus751 * @devad: PHY device (MMD) address752 *753 * Read the MDIO_STAT2 register, and check whether a device is responding754 * at this address.755 *756 * Returns: negative error number on bus access error, zero if no device757 * is responding, or positive if a device is present.758 */759static int phy_c45_probe_present(struct mii_bus *bus, int prtad, int devad)760{761 int stat2;762 763 stat2 = mdiobus_c45_read(bus, prtad, devad, MDIO_STAT2);764 if (stat2 < 0)765 return stat2;766 767 return (stat2 & MDIO_STAT2_DEVPRST) == MDIO_STAT2_DEVPRST_VAL;768}769 770/* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.771 * @bus: the target MII bus772 * @addr: PHY address on the MII bus773 * @dev_addr: MMD address in the PHY.774 * @devices_in_package: where to store the devices in package information.775 *776 * Description: reads devices in package registers of a MMD at @dev_addr777 * from PHY at @addr on @bus.778 *779 * Returns: 0 on success, -EIO on failure.780 */781static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,782 u32 *devices_in_package)783{784 int phy_reg;785 786 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS2);787 if (phy_reg < 0)788 return -EIO;789 *devices_in_package = phy_reg << 16;790 791 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS1);792 if (phy_reg < 0)793 return -EIO;794 *devices_in_package |= phy_reg;795 796 return 0;797}798 799/**800 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.801 * @bus: the target MII bus802 * @addr: PHY address on the MII bus803 * @c45_ids: where to store the c45 ID information.804 *805 * Read the PHY "devices in package". If this appears to be valid, read806 * the PHY identifiers for each device. Return the "devices in package"807 * and identifiers in @c45_ids.808 *809 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if810 * the "devices in package" is invalid or no device responds.811 */812static int get_phy_c45_ids(struct mii_bus *bus, int addr,813 struct phy_c45_device_ids *c45_ids)814{815 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);816 u32 devs_in_pkg = 0;817 int i, ret, phy_reg;818 819 /* Find first non-zero Devices In package. Device zero is reserved820 * for 802.3 c45 complied PHYs, so don't probe it at first.821 */822 for (i = 1; i < MDIO_MMD_NUM && (devs_in_pkg == 0 ||823 (devs_in_pkg & 0x1fffffff) == 0x1fffffff); i++) {824 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {825 /* Check that there is a device present at this826 * address before reading the devices-in-package827 * register to avoid reading garbage from the PHY.828 * Some PHYs (88x3310) vendor space is not IEEE802.3829 * compliant.830 */831 ret = phy_c45_probe_present(bus, addr, i);832 if (ret < 0)833 /* returning -ENODEV doesn't stop bus834 * scanning835 */836 return (phy_reg == -EIO ||837 phy_reg == -ENODEV) ? -ENODEV : -EIO;838 839 if (!ret)840 continue;841 }842 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, &devs_in_pkg);843 if (phy_reg < 0)844 return -EIO;845 }846 847 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff) {848 /* If mostly Fs, there is no device there, then let's probe849 * MMD 0, as some 10G PHYs have zero Devices In package,850 * e.g. Cortina CS4315/CS4340 PHY.851 */852 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, &devs_in_pkg);853 if (phy_reg < 0)854 return -EIO;855 856 /* no device there, let's get out of here */857 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff)858 return -ENODEV;859 }860 861 /* Now probe Device Identifiers for each device present. */862 for (i = 1; i < num_ids; i++) {863 if (!(devs_in_pkg & (1 << i)))864 continue;865 866 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {867 /* Probe the "Device Present" bits for the vendor MMDs868 * to ignore these if they do not contain IEEE 802.3869 * registers.870 */871 ret = phy_c45_probe_present(bus, addr, i);872 if (ret < 0)873 return ret;874 875 if (!ret)876 continue;877 }878 879 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID1);880 if (phy_reg < 0)881 return -EIO;882 c45_ids->device_ids[i] = phy_reg << 16;883 884 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID2);885 if (phy_reg < 0)886 return -EIO;887 c45_ids->device_ids[i] |= phy_reg;888 }889 890 c45_ids->devices_in_package = devs_in_pkg;891 /* Bit 0 doesn't represent a device, it indicates c22 regs presence */892 c45_ids->mmds_present = devs_in_pkg & ~BIT(0);893 894 return 0;895}896 897/**898 * get_phy_c22_id - reads the specified addr for its clause 22 ID.899 * @bus: the target MII bus900 * @addr: PHY address on the MII bus901 * @phy_id: where to store the ID retrieved.902 *903 * Read the 802.3 clause 22 PHY ID from the PHY at @addr on the @bus,904 * placing it in @phy_id. Return zero on successful read and the ID is905 * valid, %-EIO on bus access error, or %-ENODEV if no device responds906 * or invalid ID.907 */908static int get_phy_c22_id(struct mii_bus *bus, int addr, u32 *phy_id)909{910 int phy_reg;911 912 /* Grab the bits from PHYIR1, and put them in the upper half */913 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);914 if (phy_reg < 0) {915 /* returning -ENODEV doesn't stop bus scanning */916 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;917 }918 919 *phy_id = phy_reg << 16;920 921 /* Grab the bits from PHYIR2, and put them in the lower half */922 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);923 if (phy_reg < 0) {924 /* returning -ENODEV doesn't stop bus scanning */925 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;926 }927 928 *phy_id |= phy_reg;929 930 /* If the phy_id is mostly Fs, there is no device there */931 if ((*phy_id & 0x1fffffff) == 0x1fffffff)932 return -ENODEV;933 934 return 0;935}936 937/* Extract the phy ID from the compatible string of the form938 * ethernet-phy-idAAAA.BBBB.939 */940int fwnode_get_phy_id(struct fwnode_handle *fwnode, u32 *phy_id)941{942 unsigned int upper, lower;943 const char *cp;944 int ret;945 946 ret = fwnode_property_read_string(fwnode, "compatible", &cp);947 if (ret)948 return ret;949 950 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) != 2)951 return -EINVAL;952 953 *phy_id = ((upper & GENMASK(15, 0)) << 16) | (lower & GENMASK(15, 0));954 return 0;955}956EXPORT_SYMBOL(fwnode_get_phy_id);957 958/**959 * get_phy_device - reads the specified PHY device and returns its @phy_device960 * struct961 * @bus: the target MII bus962 * @addr: PHY address on the MII bus963 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol964 *965 * Probe for a PHY at @addr on @bus.966 *967 * When probing for a clause 22 PHY, then read the ID registers. If we find968 * a valid ID, allocate and return a &struct phy_device.969 *970 * When probing for a clause 45 PHY, read the "devices in package" registers.971 * If the "devices in package" appears valid, read the ID registers for each972 * MMD, allocate and return a &struct phy_device.973 *974 * Returns an allocated &struct phy_device on success, %-ENODEV if there is975 * no PHY present, or %-EIO on bus access error.976 */977struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)978{979 struct phy_c45_device_ids c45_ids;980 u32 phy_id = 0;981 int r;982 983 c45_ids.devices_in_package = 0;984 c45_ids.mmds_present = 0;985 memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));986 987 if (is_c45)988 r = get_phy_c45_ids(bus, addr, &c45_ids);989 else990 r = get_phy_c22_id(bus, addr, &phy_id);991 992 if (r)993 return ERR_PTR(r);994 995 /* PHY device such as the Marvell Alaska 88E2110 will return a PHY ID996 * of 0 when probed using get_phy_c22_id() with no error. Proceed to997 * probe with C45 to see if we're able to get a valid PHY ID in the C45998 * space, if successful, create the C45 PHY device.999 */1000 if (!is_c45 && phy_id == 0 && bus->read_c45) {1001 r = get_phy_c45_ids(bus, addr, &c45_ids);1002 if (!r)1003 return phy_device_create(bus, addr, phy_id,1004 true, &c45_ids);1005 }1006 1007 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);1008}1009EXPORT_SYMBOL(get_phy_device);1010 1011/**1012 * phy_device_register - Register the phy device on the MDIO bus1013 * @phydev: phy_device structure to be added to the MDIO bus1014 */1015int phy_device_register(struct phy_device *phydev)1016{1017 int err;1018 1019 err = mdiobus_register_device(&phydev->mdio);1020 if (err)1021 return err;1022 1023 /* Deassert the reset signal */1024 phy_device_reset(phydev, 0);1025 1026 /* Run all of the fixups for this PHY */1027 err = phy_scan_fixups(phydev);1028 if (err) {1029 phydev_err(phydev, "failed to initialize\n");1030 goto out;1031 }1032 1033 err = device_add(&phydev->mdio.dev);1034 if (err) {1035 phydev_err(phydev, "failed to add\n");1036 goto out;1037 }1038 1039 return 0;1040 1041 out:1042 /* Assert the reset signal */1043 phy_device_reset(phydev, 1);1044 1045 mdiobus_unregister_device(&phydev->mdio);1046 return err;1047}1048EXPORT_SYMBOL(phy_device_register);1049 1050/**1051 * phy_device_remove - Remove a previously registered phy device from the MDIO bus1052 * @phydev: phy_device structure to remove1053 *1054 * This doesn't free the phy_device itself, it merely reverses the effects1055 * of phy_device_register(). Use phy_device_free() to free the device1056 * after calling this function.1057 */1058void phy_device_remove(struct phy_device *phydev)1059{1060 unregister_mii_timestamper(phydev->mii_ts);1061 pse_control_put(phydev->psec);1062 1063 device_del(&phydev->mdio.dev);1064 1065 /* Assert the reset signal */1066 phy_device_reset(phydev, 1);1067 1068 mdiobus_unregister_device(&phydev->mdio);1069}1070EXPORT_SYMBOL(phy_device_remove);1071 1072/**1073 * phy_get_c45_ids - Read 802.3-c45 IDs for phy device.1074 * @phydev: phy_device structure to read 802.3-c45 IDs1075 *1076 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if1077 * the "devices in package" is invalid.1078 */1079int phy_get_c45_ids(struct phy_device *phydev)1080{1081 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr,1082 &phydev->c45_ids);1083}1084EXPORT_SYMBOL(phy_get_c45_ids);1085 1086/**1087 * phy_find_first - finds the first PHY device on the bus1088 * @bus: the target MII bus1089 */1090struct phy_device *phy_find_first(struct mii_bus *bus)1091{1092 struct phy_device *phydev;1093 int addr;1094 1095 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {1096 phydev = mdiobus_get_phy(bus, addr);1097 if (phydev)1098 return phydev;1099 }1100 return NULL;1101}1102EXPORT_SYMBOL(phy_find_first);1103 1104static void phy_link_change(struct phy_device *phydev, bool up)1105{1106 struct net_device *netdev = phydev->attached_dev;1107 1108 if (up)1109 netif_carrier_on(netdev);1110 else1111 netif_carrier_off(netdev);1112 phydev->adjust_link(netdev);1113 if (phydev->mii_ts && phydev->mii_ts->link_state)1114 phydev->mii_ts->link_state(phydev->mii_ts, phydev);1115}1116 1117/**1118 * phy_prepare_link - prepares the PHY layer to monitor link status1119 * @phydev: target phy_device struct1120 * @handler: callback function for link status change notifications1121 *1122 * Description: Tells the PHY infrastructure to handle the1123 * gory details on monitoring link status (whether through1124 * polling or an interrupt), and to call back to the1125 * connected device driver when the link status changes.1126 * If you want to monitor your own link state, don't call1127 * this function.1128 */1129static void phy_prepare_link(struct phy_device *phydev,1130 void (*handler)(struct net_device *))1131{1132 phydev->adjust_link = handler;1133}1134 1135/**1136 * phy_connect_direct - connect an ethernet device to a specific phy_device1137 * @dev: the network device to connect1138 * @phydev: the pointer to the phy device1139 * @handler: callback function for state change notifications1140 * @interface: PHY device's interface1141 */1142int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,1143 void (*handler)(struct net_device *),1144 phy_interface_t interface)1145{1146 int rc;1147 1148 if (!dev)1149 return -EINVAL;1150 1151 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);1152 if (rc)1153 return rc;1154 1155 phy_prepare_link(phydev, handler);1156 if (phy_interrupt_is_valid(phydev))1157 phy_request_interrupt(phydev);1158 1159 return 0;1160}1161EXPORT_SYMBOL(phy_connect_direct);1162 1163/**1164 * phy_connect - connect an ethernet device to a PHY device1165 * @dev: the network device to connect1166 * @bus_id: the id string of the PHY device to connect1167 * @handler: callback function for state change notifications1168 * @interface: PHY device's interface1169 *1170 * Description: Convenience function for connecting ethernet1171 * devices to PHY devices. The default behavior is for1172 * the PHY infrastructure to handle everything, and only notify1173 * the connected driver when the link status changes. If you1174 * don't want, or can't use the provided functionality, you may1175 * choose to call only the subset of functions which provide1176 * the desired functionality.1177 */1178struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,1179 void (*handler)(struct net_device *),1180 phy_interface_t interface)1181{1182 struct phy_device *phydev;1183 struct device *d;1184 int rc;1185 1186 /* Search the list of PHY devices on the mdio bus for the1187 * PHY with the requested name1188 */1189 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);1190 if (!d) {1191 pr_err("PHY %s not found\n", bus_id);1192 return ERR_PTR(-ENODEV);1193 }1194 phydev = to_phy_device(d);1195 1196 rc = phy_connect_direct(dev, phydev, handler, interface);1197 put_device(d);1198 if (rc)1199 return ERR_PTR(rc);1200 1201 return phydev;1202}1203EXPORT_SYMBOL(phy_connect);1204 1205/**1206 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY1207 * device1208 * @phydev: target phy_device struct1209 */1210void phy_disconnect(struct phy_device *phydev)1211{1212 if (phy_is_started(phydev))1213 phy_stop(phydev);1214 1215 if (phy_interrupt_is_valid(phydev))1216 phy_free_interrupt(phydev);1217 1218 phydev->adjust_link = NULL;1219 1220 phy_detach(phydev);1221}1222EXPORT_SYMBOL(phy_disconnect);1223 1224/**1225 * phy_poll_reset - Safely wait until a PHY reset has properly completed1226 * @phydev: The PHY device to poll1227 *1228 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as1229 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR1230 * register must be polled until the BMCR_RESET bit clears.1231 *1232 * Furthermore, any attempts to write to PHY registers may have no effect1233 * or even generate MDIO bus errors until this is complete.1234 *1235 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the1236 * standard and do not fully reset after the BMCR_RESET bit is set, and may1237 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an1238 * effort to support such broken PHYs, this function is separate from the1239 * standard phy_init_hw() which will zero all the other bits in the BMCR1240 * and reapply all driver-specific and board-specific fixups.1241 */1242static int phy_poll_reset(struct phy_device *phydev)1243{1244 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */1245 int ret, val;1246 1247 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),1248 50000, 600000, true);1249 if (ret)1250 return ret;1251 /* Some chips (smsc911x) may still need up to another 1ms after the1252 * BMCR_RESET bit is cleared before they are usable.1253 */1254 msleep(1);1255 return 0;1256}1257 1258int phy_init_hw(struct phy_device *phydev)1259{1260 int ret = 0;1261 1262 /* Deassert the reset signal */1263 phy_device_reset(phydev, 0);1264 1265 if (!phydev->drv)1266 return 0;1267 1268 if (phydev->drv->soft_reset) {1269 ret = phydev->drv->soft_reset(phydev);1270 if (ret < 0)1271 return ret;1272 1273 /* see comment in genphy_soft_reset for an explanation */1274 phydev->suspended = 0;1275 }1276 1277 ret = phy_scan_fixups(phydev);1278 if (ret < 0)1279 return ret;1280 1281 phy_interface_zero(phydev->possible_interfaces);1282 1283 if (phydev->drv->config_init) {1284 ret = phydev->drv->config_init(phydev);1285 if (ret < 0)1286 return ret;1287 }1288 1289 if (phydev->drv->config_intr) {1290 ret = phydev->drv->config_intr(phydev);1291 if (ret < 0)1292 return ret;1293 }1294 1295 return 0;1296}1297EXPORT_SYMBOL(phy_init_hw);1298 1299void phy_attached_info(struct phy_device *phydev)1300{1301 phy_attached_print(phydev, NULL);1302}1303EXPORT_SYMBOL(phy_attached_info);1304 1305#define ATTACHED_FMT "attached PHY driver %s(mii_bus:phy_addr=%s, irq=%s)"1306char *phy_attached_info_irq(struct phy_device *phydev)1307{1308 char *irq_str;1309 char irq_num[8];1310 1311 switch(phydev->irq) {1312 case PHY_POLL:1313 irq_str = "POLL";1314 break;1315 case PHY_MAC_INTERRUPT:1316 irq_str = "MAC";1317 break;1318 default:1319 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);1320 irq_str = irq_num;1321 break;1322 }1323 1324 return kasprintf(GFP_KERNEL, "%s", irq_str);1325}1326EXPORT_SYMBOL(phy_attached_info_irq);1327 1328void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)1329{1330 const char *unbound = phydev->drv ? "" : "[unbound] ";1331 char *irq_str = phy_attached_info_irq(phydev);1332 1333 if (!fmt) {1334 phydev_info(phydev, ATTACHED_FMT "\n", unbound,1335 phydev_name(phydev), irq_str);1336 } else {1337 va_list ap;1338 1339 phydev_info(phydev, ATTACHED_FMT, unbound,1340 phydev_name(phydev), irq_str);1341 1342 va_start(ap, fmt);1343 vprintk(fmt, ap);1344 va_end(ap);1345 }1346 kfree(irq_str);1347}1348EXPORT_SYMBOL(phy_attached_print);1349 1350static void phy_sysfs_create_links(struct phy_device *phydev)1351{1352 struct net_device *dev = phydev->attached_dev;1353 int err;1354 1355 if (!dev)1356 return;1357 1358 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,1359 "attached_dev");1360 if (err)1361 return;1362 1363 err = sysfs_create_link_nowarn(&dev->dev.kobj,1364 &phydev->mdio.dev.kobj,1365 "phydev");1366 if (err) {1367 dev_err(&dev->dev, "could not add device link to %s err %d\n",1368 kobject_name(&phydev->mdio.dev.kobj),1369 err);1370 /* non-fatal - some net drivers can use one netdevice1371 * with more then one phy1372 */1373 }1374 1375 phydev->sysfs_links = true;1376}1377 1378static ssize_t1379phy_standalone_show(struct device *dev, struct device_attribute *attr,1380 char *buf)1381{1382 struct phy_device *phydev = to_phy_device(dev);1383 1384 return sysfs_emit(buf, "%d\n", !phydev->attached_dev);1385}1386static DEVICE_ATTR_RO(phy_standalone);1387 1388/**1389 * phy_sfp_connect_phy - Connect the SFP module's PHY to the upstream PHY1390 * @upstream: pointer to the upstream phy device1391 * @phy: pointer to the SFP module's phy device1392 *1393 * This helper allows keeping track of PHY devices on the link. It adds the1394 * SFP module's phy to the phy namespace of the upstream phy1395 *1396 * Return: 0 on success, otherwise a negative error code.1397 */1398int phy_sfp_connect_phy(void *upstream, struct phy_device *phy)1399{1400 struct phy_device *phydev = upstream;1401 struct net_device *dev = phydev->attached_dev;1402 1403 if (dev)1404 return phy_link_topo_add_phy(dev, phy, PHY_UPSTREAM_PHY, phydev);1405 1406 return 0;1407}1408EXPORT_SYMBOL(phy_sfp_connect_phy);1409 1410/**1411 * phy_sfp_disconnect_phy - Disconnect the SFP module's PHY from the upstream PHY1412 * @upstream: pointer to the upstream phy device1413 * @phy: pointer to the SFP module's phy device1414 *1415 * This helper allows keeping track of PHY devices on the link. It removes the1416 * SFP module's phy to the phy namespace of the upstream phy. As the module phy1417 * will be destroyed, re-inserting the same module will add a new phy with a1418 * new index.1419 */1420void phy_sfp_disconnect_phy(void *upstream, struct phy_device *phy)1421{1422 struct phy_device *phydev = upstream;1423 struct net_device *dev = phydev->attached_dev;1424 1425 if (dev)1426 phy_link_topo_del_phy(dev, phy);1427}1428EXPORT_SYMBOL(phy_sfp_disconnect_phy);1429 1430/**1431 * phy_sfp_attach - attach the SFP bus to the PHY upstream network device1432 * @upstream: pointer to the phy device1433 * @bus: sfp bus representing cage being attached1434 *1435 * This is used to fill in the sfp_upstream_ops .attach member.1436 */1437void phy_sfp_attach(void *upstream, struct sfp_bus *bus)1438{1439 struct phy_device *phydev = upstream;1440 1441 if (phydev->attached_dev)1442 phydev->attached_dev->sfp_bus = bus;1443 phydev->sfp_bus_attached = true;1444}1445EXPORT_SYMBOL(phy_sfp_attach);1446 1447/**1448 * phy_sfp_detach - detach the SFP bus from the PHY upstream network device1449 * @upstream: pointer to the phy device1450 * @bus: sfp bus representing cage being attached1451 *1452 * This is used to fill in the sfp_upstream_ops .detach member.1453 */1454void phy_sfp_detach(void *upstream, struct sfp_bus *bus)1455{1456 struct phy_device *phydev = upstream;1457 1458 if (phydev->attached_dev)1459 phydev->attached_dev->sfp_bus = NULL;1460 phydev->sfp_bus_attached = false;1461}1462EXPORT_SYMBOL(phy_sfp_detach);1463 1464/**1465 * phy_sfp_probe - probe for a SFP cage attached to this PHY device1466 * @phydev: Pointer to phy_device1467 * @ops: SFP's upstream operations1468 */1469int phy_sfp_probe(struct phy_device *phydev,1470 const struct sfp_upstream_ops *ops)1471{1472 struct sfp_bus *bus;1473 int ret = 0;1474 1475 if (phydev->mdio.dev.fwnode) {1476 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);1477 if (IS_ERR(bus))1478 return PTR_ERR(bus);1479 1480 phydev->sfp_bus = bus;1481 1482 ret = sfp_bus_add_upstream(bus, phydev, ops);1483 sfp_bus_put(bus);1484 }1485 return ret;1486}1487EXPORT_SYMBOL(phy_sfp_probe);1488 1489static bool phy_drv_supports_irq(const struct phy_driver *phydrv)1490{1491 return phydrv->config_intr && phydrv->handle_interrupt;1492}1493 1494/**1495 * phy_attach_direct - attach a network device to a given PHY device pointer1496 * @dev: network device to attach1497 * @phydev: Pointer to phy_device to attach1498 * @flags: PHY device's dev_flags1499 * @interface: PHY device's interface1500 *1501 * Description: Called by drivers to attach to a particular PHY1502 * device. The phy_device is found, and properly hooked up1503 * to the phy_driver. If no driver is attached, then a1504 * generic driver is used. The phy_device is given a ptr to1505 * the attaching device, and given a callback for link status1506 * change. The phy_device is returned to the attaching driver.1507 * This function takes a reference on the phy device.1508 */1509int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,1510 u32 flags, phy_interface_t interface)1511{1512 struct mii_bus *bus = phydev->mdio.bus;1513 struct device *d = &phydev->mdio.dev;1514 struct module *ndev_owner = NULL;1515 bool using_genphy = false;1516 int err;1517 1518 /* For Ethernet device drivers that register their own MDIO bus, we1519 * will have bus->owner match ndev_mod, so we do not want to increment1520 * our own module->refcnt here, otherwise we would not be able to1521 * unload later on.1522 */1523 if (dev)1524 ndev_owner = dev->dev.parent->driver->owner;1525 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {1526 phydev_err(phydev, "failed to get the bus module\n");1527 return -EIO;1528 }1529 1530 get_device(d);1531 1532 /* Assume that if there is no driver, that it doesn't1533 * exist, and we should use the genphy driver.1534 */1535 if (!d->driver) {1536 if (phydev->is_c45)1537 d->driver = &genphy_c45_driver.mdiodrv.driver;1538 else1539 d->driver = &genphy_driver.mdiodrv.driver;1540 1541 using_genphy = true;1542 }1543 1544 if (!try_module_get(d->driver->owner)) {1545 phydev_err(phydev, "failed to get the device driver module\n");1546 err = -EIO;1547 goto error_put_device;1548 }1549 1550 if (using_genphy) {1551 err = d->driver->probe(d);1552 if (err >= 0)1553 err = device_bind_driver(d);1554 1555 if (err)1556 goto error_module_put;1557 }1558 1559 if (phydev->attached_dev) {1560 dev_err(&dev->dev, "PHY already attached\n");1561 err = -EBUSY;1562 goto error;1563 }1564 1565 phydev->phy_link_change = phy_link_change;1566 if (dev) {1567 phydev->attached_dev = dev;1568 dev->phydev = phydev;1569 1570 if (phydev->sfp_bus_attached)1571 dev->sfp_bus = phydev->sfp_bus;1572 1573 err = phy_link_topo_add_phy(dev, phydev, PHY_UPSTREAM_MAC, dev);1574 if (err)1575 goto error;1576 }1577 1578 /* Some Ethernet drivers try to connect to a PHY device before1579 * calling register_netdevice() -> netdev_register_kobject() and1580 * does the dev->dev.kobj initialization. Here we only check for1581 * success which indicates that the network device kobject is1582 * ready. Once we do that we still need to keep track of whether1583 * links were successfully set up or not for phy_detach() to1584 * remove them accordingly.1585 */1586 phydev->sysfs_links = false;1587 1588 phy_sysfs_create_links(phydev);1589 1590 if (!phydev->attached_dev) {1591 err = sysfs_create_file(&phydev->mdio.dev.kobj,1592 &dev_attr_phy_standalone.attr);1593 if (err)1594 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");1595 }1596 1597 phydev->dev_flags |= flags;1598 1599 phydev->interface = interface;1600 1601 phydev->state = PHY_READY;1602 1603 phydev->interrupts = PHY_INTERRUPT_DISABLED;1604 1605 /* PHYs can request to use poll mode even though they have an1606 * associated interrupt line. This could be the case if they1607 * detect a broken interrupt handling.1608 */1609 if (phydev->dev_flags & PHY_F_NO_IRQ)1610 phydev->irq = PHY_POLL;1611 1612 if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev))1613 phydev->irq = PHY_POLL;1614 1615 /* Port is set to PORT_TP by default and the actual PHY driver will set1616 * it to different value depending on the PHY configuration. If we have1617 * the generic PHY driver we can't figure it out, thus set the old1618 * legacy PORT_MII value.1619 */1620 if (using_genphy)1621 phydev->port = PORT_MII;1622 1623 /* Initial carrier state is off as the phy is about to be1624 * (re)initialized.1625 */1626 if (dev)1627 netif_carrier_off(phydev->attached_dev);1628 1629 /* Do initial configuration here, now that1630 * we have certain key parameters1631 * (dev_flags and interface)1632 */1633 err = phy_init_hw(phydev);1634 if (err)1635 goto error;1636 1637 phy_resume(phydev);1638 if (!phydev->is_on_sfp_module)1639 phy_led_triggers_register(phydev);1640 1641 /**1642 * If the external phy used by current mac interface is managed by1643 * another mac interface, so we should create a device link between1644 * phy dev and mac dev.1645 */1646 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent)1647 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev,1648 DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS);1649 1650 return err;1651 1652error:1653 /* phy_detach() does all of the cleanup below */1654 phy_detach(phydev);1655 return err;1656 1657error_module_put:1658 module_put(d->driver->owner);1659 d->driver = NULL;1660error_put_device:1661 put_device(d);1662 if (ndev_owner != bus->owner)1663 module_put(bus->owner);1664 return err;1665}1666EXPORT_SYMBOL(phy_attach_direct);1667 1668/**1669 * phy_attach - attach a network device to a particular PHY device1670 * @dev: network device to attach1671 * @bus_id: Bus ID of PHY device to attach1672 * @interface: PHY device's interface1673 *1674 * Description: Same as phy_attach_direct() except that a PHY bus_id1675 * string is passed instead of a pointer to a struct phy_device.1676 */1677struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,1678 phy_interface_t interface)1679{1680 struct phy_device *phydev;1681 struct device *d;1682 int rc;1683 1684 if (!dev)1685 return ERR_PTR(-EINVAL);1686 1687 /* Search the list of PHY devices on the mdio bus for the1688 * PHY with the requested name1689 */1690 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);1691 if (!d) {1692 pr_err("PHY %s not found\n", bus_id);1693 return ERR_PTR(-ENODEV);1694 }1695 phydev = to_phy_device(d);1696 1697 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);1698 put_device(d);1699 if (rc)1700 return ERR_PTR(rc);1701 1702 return phydev;1703}1704EXPORT_SYMBOL(phy_attach);1705 1706static bool phy_driver_is_genphy_kind(struct phy_device *phydev,1707 struct device_driver *driver)1708{1709 struct device *d = &phydev->mdio.dev;1710 bool ret = false;1711 1712 if (!phydev->drv)1713 return ret;1714 1715 get_device(d);1716 ret = d->driver == driver;1717 put_device(d);1718 1719 return ret;1720}1721 1722bool phy_driver_is_genphy(struct phy_device *phydev)1723{1724 return phy_driver_is_genphy_kind(phydev,1725 &genphy_driver.mdiodrv.driver);1726}1727EXPORT_SYMBOL_GPL(phy_driver_is_genphy);1728 1729bool phy_driver_is_genphy_10g(struct phy_device *phydev)1730{1731 return phy_driver_is_genphy_kind(phydev,1732 &genphy_c45_driver.mdiodrv.driver);1733}1734EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);1735 1736/**1737 * phy_package_join - join a common PHY group1738 * @phydev: target phy_device struct1739 * @base_addr: cookie and base PHY address of PHY package for offset1740 * calculation of global register access1741 * @priv_size: if non-zero allocate this amount of bytes for private data1742 *1743 * This joins a PHY group and provides a shared storage for all phydevs in1744 * this group. This is intended to be used for packages which contain1745 * more than one PHY, for example a quad PHY transceiver.1746 *1747 * The base_addr parameter serves as cookie which has to have the same values1748 * for all members of one group and as the base PHY address of the PHY package1749 * for offset calculation to access generic registers of a PHY package.1750 * Usually, one of the PHY addresses of the different PHYs in the package1751 * provides access to these global registers.1752 * The address which is given here, will be used in the phy_package_read()1753 * and phy_package_write() convenience functions as base and added to the1754 * passed offset in those functions.1755 *1756 * This will set the shared pointer of the phydev to the shared storage.1757 * If this is the first call for a this cookie the shared storage will be1758 * allocated. If priv_size is non-zero, the given amount of bytes are1759 * allocated for the priv member.1760 *1761 * Returns < 1 on error, 0 on success. Esp. calling phy_package_join()1762 * with the same cookie but a different priv_size is an error.1763 */1764int phy_package_join(struct phy_device *phydev, int base_addr, size_t priv_size)1765{1766 struct mii_bus *bus = phydev->mdio.bus;1767 struct phy_package_shared *shared;1768 int ret;1769 1770 if (base_addr < 0 || base_addr >= PHY_MAX_ADDR)1771 return -EINVAL;1772 1773 mutex_lock(&bus->shared_lock);1774 shared = bus->shared[base_addr];1775 if (!shared) {1776 ret = -ENOMEM;1777 shared = kzalloc(sizeof(*shared), GFP_KERNEL);1778 if (!shared)1779 goto err_unlock;1780 if (priv_size) {1781 shared->priv = kzalloc(priv_size, GFP_KERNEL);1782 if (!shared->priv)1783 goto err_free;1784 shared->priv_size = priv_size;1785 }1786 shared->base_addr = base_addr;1787 shared->np = NULL;1788 refcount_set(&shared->refcnt, 1);1789 bus->shared[base_addr] = shared;1790 } else {1791 ret = -EINVAL;1792 if (priv_size && priv_size != shared->priv_size)1793 goto err_unlock;1794 refcount_inc(&shared->refcnt);1795 }1796 mutex_unlock(&bus->shared_lock);1797 1798 phydev->shared = shared;1799 1800 return 0;1801 1802err_free:1803 kfree(shared);1804err_unlock:1805 mutex_unlock(&bus->shared_lock);1806 return ret;1807}1808EXPORT_SYMBOL_GPL(phy_package_join);1809 1810/**1811 * of_phy_package_join - join a common PHY group in PHY package1812 * @phydev: target phy_device struct1813 * @priv_size: if non-zero allocate this amount of bytes for private data1814 *1815 * This is a variant of phy_package_join for PHY package defined in DT.1816 *1817 * The parent node of the @phydev is checked as a valid PHY package node1818 * structure (by matching the node name "ethernet-phy-package") and the1819 * base_addr for the PHY package is passed to phy_package_join.1820 *1821 * With this configuration the shared struct will also have the np value1822 * filled to use additional DT defined properties in PHY specific1823 * probe_once and config_init_once PHY package OPs.1824 *1825 * Returns < 0 on error, 0 on success. Esp. calling phy_package_join()1826 * with the same cookie but a different priv_size is an error. Or a parent1827 * node is not detected or is not valid or doesn't match the expected node1828 * name for PHY package.1829 */1830int of_phy_package_join(struct phy_device *phydev, size_t priv_size)1831{1832 struct device_node *node = phydev->mdio.dev.of_node;1833 struct device_node *package_node;1834 u32 base_addr;1835 int ret;1836 1837 if (!node)1838 return -EINVAL;1839 1840 package_node = of_get_parent(node);1841 if (!package_node)1842 return -EINVAL;1843 1844 if (!of_node_name_eq(package_node, "ethernet-phy-package")) {1845 ret = -EINVAL;1846 goto exit;1847 }1848 1849 if (of_property_read_u32(package_node, "reg", &base_addr)) {1850 ret = -EINVAL;1851 goto exit;1852 }1853 1854 ret = phy_package_join(phydev, base_addr, priv_size);1855 if (ret)1856 goto exit;1857 1858 phydev->shared->np = package_node;1859 1860 return 0;1861exit:1862 of_node_put(package_node);1863 return ret;1864}1865EXPORT_SYMBOL_GPL(of_phy_package_join);1866 1867/**1868 * phy_package_leave - leave a common PHY group1869 * @phydev: target phy_device struct1870 *1871 * This leaves a PHY group created by phy_package_join(). If this phydev1872 * was the last user of the shared data between the group, this data is1873 * freed. Resets the phydev->shared pointer to NULL.1874 */1875void phy_package_leave(struct phy_device *phydev)1876{1877 struct phy_package_shared *shared = phydev->shared;1878 struct mii_bus *bus = phydev->mdio.bus;1879 1880 if (!shared)1881 return;1882 1883 /* Decrease the node refcount on leave if present */1884 if (shared->np)1885 of_node_put(shared->np);1886 1887 if (refcount_dec_and_mutex_lock(&shared->refcnt, &bus->shared_lock)) {1888 bus->shared[shared->base_addr] = NULL;1889 mutex_unlock(&bus->shared_lock);1890 kfree(shared->priv);1891 kfree(shared);1892 }1893 1894 phydev->shared = NULL;1895}1896EXPORT_SYMBOL_GPL(phy_package_leave);1897 1898static void devm_phy_package_leave(struct device *dev, void *res)1899{1900 phy_package_leave(*(struct phy_device **)res);1901}1902 1903/**1904 * devm_phy_package_join - resource managed phy_package_join()1905 * @dev: device that is registering this PHY package1906 * @phydev: target phy_device struct1907 * @base_addr: cookie and base PHY address of PHY package for offset1908 * calculation of global register access1909 * @priv_size: if non-zero allocate this amount of bytes for private data1910 *1911 * Managed phy_package_join(). Shared storage fetched by this function,1912 * phy_package_leave() is automatically called on driver detach. See1913 * phy_package_join() for more information.1914 */1915int devm_phy_package_join(struct device *dev, struct phy_device *phydev,1916 int base_addr, size_t priv_size)1917{1918 struct phy_device **ptr;1919 int ret;1920 1921 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr),1922 GFP_KERNEL);1923 if (!ptr)1924 return -ENOMEM;1925 1926 ret = phy_package_join(phydev, base_addr, priv_size);1927 1928 if (!ret) {1929 *ptr = phydev;1930 devres_add(dev, ptr);1931 } else {1932 devres_free(ptr);1933 }1934 1935 return ret;1936}1937EXPORT_SYMBOL_GPL(devm_phy_package_join);1938 1939/**1940 * devm_of_phy_package_join - resource managed of_phy_package_join()1941 * @dev: device that is registering this PHY package1942 * @phydev: target phy_device struct1943 * @priv_size: if non-zero allocate this amount of bytes for private data1944 *1945 * Managed of_phy_package_join(). Shared storage fetched by this function,1946 * phy_package_leave() is automatically called on driver detach. See1947 * of_phy_package_join() for more information.1948 */1949int devm_of_phy_package_join(struct device *dev, struct phy_device *phydev,1950 size_t priv_size)1951{1952 struct phy_device **ptr;1953 int ret;1954 1955 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr),1956 GFP_KERNEL);1957 if (!ptr)1958 return -ENOMEM;1959 1960 ret = of_phy_package_join(phydev, priv_size);1961 1962 if (!ret) {1963 *ptr = phydev;1964 devres_add(dev, ptr);1965 } else {1966 devres_free(ptr);1967 }1968 1969 return ret;1970}1971EXPORT_SYMBOL_GPL(devm_of_phy_package_join);1972 1973/**1974 * phy_detach - detach a PHY device from its network device1975 * @phydev: target phy_device struct1976 *1977 * This detaches the phy device from its network device and the phy1978 * driver, and drops the reference count taken in phy_attach_direct().1979 */1980void phy_detach(struct phy_device *phydev)1981{1982 struct net_device *dev = phydev->attached_dev;1983 struct module *ndev_owner = NULL;1984 struct mii_bus *bus;1985 1986 if (phydev->devlink)1987 device_link_del(phydev->devlink);1988 1989 if (phydev->sysfs_links) {1990 if (dev)1991 sysfs_remove_link(&dev->dev.kobj, "phydev");1992 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");1993 }1994 1995 if (!phydev->attached_dev)1996 sysfs_remove_file(&phydev->mdio.dev.kobj,1997 &dev_attr_phy_standalone.attr);1998 1999 phy_suspend(phydev);2000 if (dev) {2001 phydev->attached_dev->phydev = NULL;2002 phydev->attached_dev = NULL;2003 phy_link_topo_del_phy(dev, phydev);2004 }2005 phydev->phylink = NULL;2006 2007 if (!phydev->is_on_sfp_module)2008 phy_led_triggers_unregister(phydev);2009 2010 if (phydev->mdio.dev.driver)2011 module_put(phydev->mdio.dev.driver->owner);2012 2013 /* If the device had no specific driver before (i.e. - it2014 * was using the generic driver), we unbind the device2015 * from the generic driver so that there's a chance a2016 * real driver could be loaded2017 */2018 if (phy_driver_is_genphy(phydev) ||2019 phy_driver_is_genphy_10g(phydev))2020 device_release_driver(&phydev->mdio.dev);2021 2022 /* Assert the reset signal */2023 phy_device_reset(phydev, 1);2024 2025 /*2026 * The phydev might go away on the put_device() below, so avoid2027 * a use-after-free bug by reading the underlying bus first.2028 */2029 bus = phydev->mdio.bus;2030 2031 put_device(&phydev->mdio.dev);2032 if (dev)2033 ndev_owner = dev->dev.parent->driver->owner;2034 if (ndev_owner != bus->owner)2035 module_put(bus->owner);2036}2037EXPORT_SYMBOL(phy_detach);2038 2039int phy_suspend(struct phy_device *phydev)2040{2041 struct net_device *netdev = phydev->attached_dev;2042 const struct phy_driver *phydrv = phydev->drv;2043 int ret;2044 2045 if (phydev->suspended || !phydrv)2046 return 0;2047 2048 phydev->wol_enabled = phy_drv_wol_enabled(phydev) ||2049 (netdev && netdev->ethtool->wol_enabled);2050 /* If the device has WOL enabled, we cannot suspend the PHY */2051 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND))2052 return -EBUSY;2053 2054 if (!phydrv->suspend)2055 return 0;2056 2057 ret = phydrv->suspend(phydev);2058 if (!ret)2059 phydev->suspended = true;2060 2061 return ret;2062}2063EXPORT_SYMBOL(phy_suspend);2064 2065int __phy_resume(struct phy_device *phydev)2066{2067 const struct phy_driver *phydrv = phydev->drv;2068 int ret;2069 2070 lockdep_assert_held(&phydev->lock);2071 2072 if (!phydrv || !phydrv->resume)2073 return 0;2074 2075 ret = phydrv->resume(phydev);2076 if (!ret)2077 phydev->suspended = false;2078 2079 return ret;2080}2081EXPORT_SYMBOL(__phy_resume);2082 2083int phy_resume(struct phy_device *phydev)2084{2085 int ret;2086 2087 mutex_lock(&phydev->lock);2088 ret = __phy_resume(phydev);2089 mutex_unlock(&phydev->lock);2090 2091 return ret;2092}2093EXPORT_SYMBOL(phy_resume);2094 2095int phy_loopback(struct phy_device *phydev, bool enable)2096{2097 int ret = 0;2098 2099 if (!phydev->drv)2100 return -EIO;2101 2102 mutex_lock(&phydev->lock);2103 2104 if (enable && phydev->loopback_enabled) {2105 ret = -EBUSY;2106 goto out;2107 }2108 2109 if (!enable && !phydev->loopback_enabled) {2110 ret = -EINVAL;2111 goto out;2112 }2113 2114 if (phydev->drv->set_loopback)2115 ret = phydev->drv->set_loopback(phydev, enable);2116 else2117 ret = genphy_loopback(phydev, enable);2118 2119 if (ret)2120 goto out;2121 2122 phydev->loopback_enabled = enable;2123 2124out:2125 mutex_unlock(&phydev->lock);2126 return ret;2127}2128EXPORT_SYMBOL(phy_loopback);2129 2130/**2131 * phy_reset_after_clk_enable - perform a PHY reset if needed2132 * @phydev: target phy_device struct2133 *2134 * Description: Some PHYs are known to need a reset after their refclk was2135 * enabled. This function evaluates the flags and perform the reset if it's2136 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy2137 * was reset.2138 */2139int phy_reset_after_clk_enable(struct phy_device *phydev)2140{2141 if (!phydev || !phydev->drv)2142 return -ENODEV;2143 2144 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {2145 phy_device_reset(phydev, 1);2146 phy_device_reset(phydev, 0);2147 return 1;2148 }2149 2150 return 0;2151}2152EXPORT_SYMBOL(phy_reset_after_clk_enable);2153 2154/* Generic PHY support and helper functions */2155 2156/**2157 * genphy_config_advert - sanitize and advertise auto-negotiation parameters2158 * @phydev: target phy_device struct2159 * @advert: auto-negotiation parameters to advertise2160 *2161 * Description: Writes MII_ADVERTISE with the appropriate values,2162 * after sanitizing the values to make sure we only advertise2163 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement2164 * hasn't changed, and > 0 if it has changed.2165 */2166static int genphy_config_advert(struct phy_device *phydev,2167 const unsigned long *advert)2168{2169 int err, bmsr, changed = 0;2170 u32 adv;2171 2172 adv = linkmode_adv_to_mii_adv_t(advert);2173 2174 /* Setup standard advertisement */2175 err = phy_modify_changed(phydev, MII_ADVERTISE,2176 ADVERTISE_ALL | ADVERTISE_100BASE4 |2177 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,2178 adv);2179 if (err < 0)2180 return err;2181 if (err > 0)2182 changed = 1;2183 2184 bmsr = phy_read(phydev, MII_BMSR);2185 if (bmsr < 0)2186 return bmsr;2187 2188 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all2189 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a2190 * logical 1.2191 */2192 if (!(bmsr & BMSR_ESTATEN))2193 return changed;2194 2195 adv = linkmode_adv_to_mii_ctrl1000_t(advert);2196 2197 err = phy_modify_changed(phydev, MII_CTRL1000,2198 ADVERTISE_1000FULL | ADVERTISE_1000HALF,2199 adv);2200 if (err < 0)2201 return err;2202 if (err > 0)2203 changed = 1;2204 2205 return changed;2206}2207 2208/**2209 * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters2210 * @phydev: target phy_device struct2211 *2212 * Description: Writes MII_ADVERTISE with the appropriate values,2213 * after sanitizing the values to make sure we only advertise2214 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement2215 * hasn't changed, and > 0 if it has changed. This function is intended2216 * for Clause 37 1000Base-X mode.2217 */2218static int genphy_c37_config_advert(struct phy_device *phydev)2219{2220 u16 adv = 0;2221 2222 /* Only allow advertising what this PHY supports */2223 linkmode_and(phydev->advertising, phydev->advertising,2224 phydev->supported);2225 2226 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,2227 phydev->advertising))2228 adv |= ADVERTISE_1000XFULL;2229 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,2230 phydev->advertising))2231 adv |= ADVERTISE_1000XPAUSE;2232 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,2233 phydev->advertising))2234 adv |= ADVERTISE_1000XPSE_ASYM;2235 2236 return phy_modify_changed(phydev, MII_ADVERTISE,2237 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |2238 ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,2239 adv);2240}2241 2242/**2243 * genphy_config_eee_advert - disable unwanted eee mode advertisement2244 * @phydev: target phy_device struct2245 *2246 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy2247 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't2248 * changed, and 1 if it has changed.2249 */2250int genphy_config_eee_advert(struct phy_device *phydev)2251{2252 int err;2253 2254 /* Nothing to disable */2255 if (!phydev->eee_broken_modes)2256 return 0;2257 2258 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,2259 phydev->eee_broken_modes, 0);2260 /* If the call failed, we assume that EEE is not supported */2261 return err < 0 ? 0 : err;2262}2263EXPORT_SYMBOL(genphy_config_eee_advert);2264 2265/**2266 * genphy_setup_forced - configures/forces speed/duplex from @phydev2267 * @phydev: target phy_device struct2268 *2269 * Description: Configures MII_BMCR to force speed/duplex2270 * to the values in phydev. Assumes that the values are valid.2271 * Please see phy_sanitize_settings().2272 */2273int genphy_setup_forced(struct phy_device *phydev)2274{2275 u16 ctl;2276 2277 phydev->pause = 0;2278 phydev->asym_pause = 0;2279 2280 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);2281 2282 return phy_modify(phydev, MII_BMCR,2283 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);2284}2285EXPORT_SYMBOL(genphy_setup_forced);2286 2287static int genphy_setup_master_slave(struct phy_device *phydev)2288{2289 u16 ctl = 0;2290 2291 if (!phydev->is_gigabit_capable)2292 return 0;2293 2294 switch (phydev->master_slave_set) {2295 case MASTER_SLAVE_CFG_MASTER_PREFERRED:2296 ctl |= CTL1000_PREFER_MASTER;2297 break;2298 case MASTER_SLAVE_CFG_SLAVE_PREFERRED:2299 break;2300 case MASTER_SLAVE_CFG_MASTER_FORCE:2301 ctl |= CTL1000_AS_MASTER;2302 fallthrough;2303 case MASTER_SLAVE_CFG_SLAVE_FORCE:2304 ctl |= CTL1000_ENABLE_MASTER;2305 break;2306 case MASTER_SLAVE_CFG_UNKNOWN:2307 case MASTER_SLAVE_CFG_UNSUPPORTED:2308 return 0;2309 default:2310 phydev_warn(phydev, "Unsupported Master/Slave mode\n");2311 return -EOPNOTSUPP;2312 }2313 2314 return phy_modify_changed(phydev, MII_CTRL1000,2315 (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |2316 CTL1000_PREFER_MASTER), ctl);2317}2318 2319int genphy_read_master_slave(struct phy_device *phydev)2320{2321 int cfg, state;2322 int val;2323 2324 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;2325 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;2326 2327 val = phy_read(phydev, MII_CTRL1000);2328 if (val < 0)2329 return val;2330 2331 if (val & CTL1000_ENABLE_MASTER) {2332 if (val & CTL1000_AS_MASTER)2333 cfg = MASTER_SLAVE_CFG_MASTER_FORCE;2334 else2335 cfg = MASTER_SLAVE_CFG_SLAVE_FORCE;2336 } else {2337 if (val & CTL1000_PREFER_MASTER)2338 cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED;2339 else2340 cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED;2341 }2342 2343 val = phy_read(phydev, MII_STAT1000);2344 if (val < 0)2345 return val;2346 2347 if (val & LPA_1000MSFAIL) {2348 state = MASTER_SLAVE_STATE_ERR;2349 } else if (phydev->link) {2350 /* this bits are valid only for active link */2351 if (val & LPA_1000MSRES)2352 state = MASTER_SLAVE_STATE_MASTER;2353 else2354 state = MASTER_SLAVE_STATE_SLAVE;2355 } else {2356 state = MASTER_SLAVE_STATE_UNKNOWN;2357 }2358 2359 phydev->master_slave_get = cfg;2360 phydev->master_slave_state = state;2361 2362 return 0;2363}2364EXPORT_SYMBOL(genphy_read_master_slave);2365 2366/**2367 * genphy_restart_aneg - Enable and Restart Autonegotiation2368 * @phydev: target phy_device struct2369 */2370int genphy_restart_aneg(struct phy_device *phydev)2371{2372 /* Don't isolate the PHY if we're negotiating */2373 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,2374 BMCR_ANENABLE | BMCR_ANRESTART);2375}2376EXPORT_SYMBOL(genphy_restart_aneg);2377 2378/**2379 * genphy_check_and_restart_aneg - Enable and restart auto-negotiation2380 * @phydev: target phy_device struct2381 * @restart: whether aneg restart is requested2382 *2383 * Check, and restart auto-negotiation if needed.2384 */2385int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)2386{2387 int ret;2388 2389 if (!restart) {2390 /* Advertisement hasn't changed, but maybe aneg was never on to2391 * begin with? Or maybe phy was isolated?2392 */2393 ret = phy_read(phydev, MII_BMCR);2394 if (ret < 0)2395 return ret;2396 2397 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))2398 restart = true;2399 }2400 2401 if (restart)2402 return genphy_restart_aneg(phydev);2403 2404 return 0;2405}2406EXPORT_SYMBOL(genphy_check_and_restart_aneg);2407 2408/**2409 * __genphy_config_aneg - restart auto-negotiation or write BMCR2410 * @phydev: target phy_device struct2411 * @changed: whether autoneg is requested2412 *2413 * Description: If auto-negotiation is enabled, we configure the2414 * advertising, and then restart auto-negotiation. If it is not2415 * enabled, then we write the BMCR.2416 */2417int __genphy_config_aneg(struct phy_device *phydev, bool changed)2418{2419 __ETHTOOL_DECLARE_LINK_MODE_MASK(fixed_advert);2420 const struct phy_setting *set;2421 unsigned long *advert;2422 int err;2423 2424 err = genphy_c45_an_config_eee_aneg(phydev);2425 if (err < 0)2426 return err;2427 else if (err)2428 changed = true;2429 2430 err = genphy_setup_master_slave(phydev);2431 if (err < 0)2432 return err;2433 else if (err)2434 changed = true;2435 2436 if (phydev->autoneg == AUTONEG_ENABLE) {2437 /* Only allow advertising what this PHY supports */2438 linkmode_and(phydev->advertising, phydev->advertising,2439 phydev->supported);2440 advert = phydev->advertising;2441 } else if (phydev->speed < SPEED_1000) {2442 return genphy_setup_forced(phydev);2443 } else {2444 linkmode_zero(fixed_advert);2445 2446 set = phy_lookup_setting(phydev->speed, phydev->duplex,2447 phydev->supported, true);2448 if (set)2449 linkmode_set_bit(set->bit, fixed_advert);2450 2451 advert = fixed_advert;2452 }2453 2454 err = genphy_config_advert(phydev, advert);2455 if (err < 0) /* error */2456 return err;2457 else if (err)2458 changed = true;2459 2460 return genphy_check_and_restart_aneg(phydev, changed);2461}2462EXPORT_SYMBOL(__genphy_config_aneg);2463 2464/**2465 * genphy_c37_config_aneg - restart auto-negotiation or write BMCR2466 * @phydev: target phy_device struct2467 *2468 * Description: If auto-negotiation is enabled, we configure the2469 * advertising, and then restart auto-negotiation. If it is not2470 * enabled, then we write the BMCR. This function is intended2471 * for use with Clause 37 1000Base-X mode.2472 */2473int genphy_c37_config_aneg(struct phy_device *phydev)2474{2475 int err, changed;2476 2477 if (phydev->autoneg != AUTONEG_ENABLE)2478 return genphy_setup_forced(phydev);2479 2480 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,2481 BMCR_SPEED1000);2482 if (err)2483 return err;2484 2485 changed = genphy_c37_config_advert(phydev);2486 if (changed < 0) /* error */2487 return changed;2488 2489 if (!changed) {2490 /* Advertisement hasn't changed, but maybe aneg was never on to2491 * begin with? Or maybe phy was isolated?2492 */2493 int ctl = phy_read(phydev, MII_BMCR);2494 2495 if (ctl < 0)2496 return ctl;2497 2498 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))2499 changed = 1; /* do restart aneg */2500 }2501 2502 /* Only restart aneg if we are advertising something different2503 * than we were before.2504 */2505 if (changed > 0)2506 return genphy_restart_aneg(phydev);2507 2508 return 0;2509}2510EXPORT_SYMBOL(genphy_c37_config_aneg);2511 2512/**2513 * genphy_aneg_done - return auto-negotiation status2514 * @phydev: target phy_device struct2515 *2516 * Description: Reads the status register and returns 0 either if2517 * auto-negotiation is incomplete, or if there was an error.2518 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.2519 */2520int genphy_aneg_done(struct phy_device *phydev)2521{2522 int retval = phy_read(phydev, MII_BMSR);2523 2524 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);2525}2526EXPORT_SYMBOL(genphy_aneg_done);2527 2528/**2529 * genphy_update_link - update link status in @phydev2530 * @phydev: target phy_device struct2531 *2532 * Description: Update the value in phydev->link to reflect the2533 * current link value. In order to do this, we need to read2534 * the status register twice, keeping the second value.2535 */2536int genphy_update_link(struct phy_device *phydev)2537{2538 int status = 0, bmcr;2539 2540 bmcr = phy_read(phydev, MII_BMCR);2541 if (bmcr < 0)2542 return bmcr;2543 2544 /* Autoneg is being started, therefore disregard BMSR value and2545 * report link as down.2546 */2547 if (bmcr & BMCR_ANRESTART)2548 goto done;2549 2550 /* The link state is latched low so that momentary link2551 * drops can be detected. Do not double-read the status2552 * in polling mode to detect such short link drops except2553 * the link was already down.2554 */2555 if (!phy_polling_mode(phydev) || !phydev->link) {2556 status = phy_read(phydev, MII_BMSR);2557 if (status < 0)2558 return status;2559 else if (status & BMSR_LSTATUS)2560 goto done;2561 }2562 2563 /* Read link and autonegotiation status */2564 status = phy_read(phydev, MII_BMSR);2565 if (status < 0)2566 return status;2567done:2568 phydev->link = status & BMSR_LSTATUS ? 1 : 0;2569 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;2570 2571 /* Consider the case that autoneg was started and "aneg complete"2572 * bit has been reset, but "link up" bit not yet.2573 */2574 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)2575 phydev->link = 0;2576 2577 return 0;2578}2579EXPORT_SYMBOL(genphy_update_link);2580 2581int genphy_read_lpa(struct phy_device *phydev)2582{2583 int lpa, lpagb;2584 2585 if (phydev->autoneg == AUTONEG_ENABLE) {2586 if (!phydev->autoneg_complete) {2587 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,2588 0);2589 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);2590 return 0;2591 }2592 2593 if (phydev->is_gigabit_capable) {2594 lpagb = phy_read(phydev, MII_STAT1000);2595 if (lpagb < 0)2596 return lpagb;2597 2598 if (lpagb & LPA_1000MSFAIL) {2599 int adv = phy_read(phydev, MII_CTRL1000);2600 2601 if (adv < 0)2602 return adv;2603 2604 if (adv & CTL1000_ENABLE_MASTER)2605 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");2606 else2607 phydev_err(phydev, "Master/Slave resolution failed\n");2608 return -ENOLINK;2609 }2610 2611 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,2612 lpagb);2613 }2614 2615 lpa = phy_read(phydev, MII_LPA);2616 if (lpa < 0)2617 return lpa;2618 2619 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);2620 } else {2621 linkmode_zero(phydev->lp_advertising);2622 }2623 2624 return 0;2625}2626EXPORT_SYMBOL(genphy_read_lpa);2627 2628/**2629 * genphy_read_status_fixed - read the link parameters for !aneg mode2630 * @phydev: target phy_device struct2631 *2632 * Read the current duplex and speed state for a PHY operating with2633 * autonegotiation disabled.2634 */2635int genphy_read_status_fixed(struct phy_device *phydev)2636{2637 int bmcr = phy_read(phydev, MII_BMCR);2638 2639 if (bmcr < 0)2640 return bmcr;2641 2642 if (bmcr & BMCR_FULLDPLX)2643 phydev->duplex = DUPLEX_FULL;2644 else2645 phydev->duplex = DUPLEX_HALF;2646 2647 if (bmcr & BMCR_SPEED1000)2648 phydev->speed = SPEED_1000;2649 else if (bmcr & BMCR_SPEED100)2650 phydev->speed = SPEED_100;2651 else2652 phydev->speed = SPEED_10;2653 2654 return 0;2655}2656EXPORT_SYMBOL(genphy_read_status_fixed);2657 2658/**2659 * genphy_read_status - check the link status and update current link state2660 * @phydev: target phy_device struct2661 *2662 * Description: Check the link, then figure out the current state2663 * by comparing what we advertise with what the link partner2664 * advertises. Start by checking the gigabit possibilities,2665 * then move on to 10/100.2666 */2667int genphy_read_status(struct phy_device *phydev)2668{2669 int err, old_link = phydev->link;2670 2671 /* Update the link, but return if there was an error */2672 err = genphy_update_link(phydev);2673 if (err)2674 return err;2675 2676 /* why bother the PHY if nothing can have changed */2677 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)2678 return 0;2679 2680 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;2681 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;2682 phydev->speed = SPEED_UNKNOWN;2683 phydev->duplex = DUPLEX_UNKNOWN;2684 phydev->pause = 0;2685 phydev->asym_pause = 0;2686 2687 if (phydev->is_gigabit_capable) {2688 err = genphy_read_master_slave(phydev);2689 if (err < 0)2690 return err;2691 }2692 2693 err = genphy_read_lpa(phydev);2694 if (err < 0)2695 return err;2696 2697 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {2698 phy_resolve_aneg_linkmode(phydev);2699 } else if (phydev->autoneg == AUTONEG_DISABLE) {2700 err = genphy_read_status_fixed(phydev);2701 if (err < 0)2702 return err;2703 }2704 2705 return 0;2706}2707EXPORT_SYMBOL(genphy_read_status);2708 2709/**2710 * genphy_c37_read_status - check the link status and update current link state2711 * @phydev: target phy_device struct2712 * @changed: pointer where to store if link changed2713 *2714 * Description: Check the link, then figure out the current state2715 * by comparing what we advertise with what the link partner2716 * advertises. This function is for Clause 37 1000Base-X mode.2717 *2718 * If link has changed, @changed is set to true, false otherwise.2719 */2720int genphy_c37_read_status(struct phy_device *phydev, bool *changed)2721{2722 int lpa, err, old_link = phydev->link;2723 2724 /* Update the link, but return if there was an error */2725 err = genphy_update_link(phydev);2726 if (err)2727 return err;2728 2729 /* why bother the PHY if nothing can have changed */2730 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) {2731 *changed = false;2732 return 0;2733 }2734 2735 /* Signal link has changed */2736 *changed = true;2737 phydev->duplex = DUPLEX_UNKNOWN;2738 phydev->pause = 0;2739 phydev->asym_pause = 0;2740 2741 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {2742 lpa = phy_read(phydev, MII_LPA);2743 if (lpa < 0)2744 return lpa;2745 2746 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,2747 phydev->lp_advertising, lpa & LPA_LPACK);2748 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,2749 phydev->lp_advertising, lpa & LPA_1000XFULL);2750 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,2751 phydev->lp_advertising, lpa & LPA_1000XPAUSE);2752 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,2753 phydev->lp_advertising,2754 lpa & LPA_1000XPAUSE_ASYM);2755 2756 phy_resolve_aneg_linkmode(phydev);2757 } else if (phydev->autoneg == AUTONEG_DISABLE) {2758 int bmcr = phy_read(phydev, MII_BMCR);2759 2760 if (bmcr < 0)2761 return bmcr;2762 2763 if (bmcr & BMCR_FULLDPLX)2764 phydev->duplex = DUPLEX_FULL;2765 else2766 phydev->duplex = DUPLEX_HALF;2767 }2768 2769 return 0;2770}2771EXPORT_SYMBOL(genphy_c37_read_status);2772 2773/**2774 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit2775 * @phydev: target phy_device struct2776 *2777 * Description: Perform a software PHY reset using the standard2778 * BMCR_RESET bit and poll for the reset bit to be cleared.2779 *2780 * Returns: 0 on success, < 0 on failure2781 */2782int genphy_soft_reset(struct phy_device *phydev)2783{2784 u16 res = BMCR_RESET;2785 int ret;2786 2787 if (phydev->autoneg == AUTONEG_ENABLE)2788 res |= BMCR_ANRESTART;2789 2790 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);2791 if (ret < 0)2792 return ret;2793 2794 /* Clause 22 states that setting bit BMCR_RESET sets control registers2795 * to their default value. Therefore the POWER DOWN bit is supposed to2796 * be cleared after soft reset.2797 */2798 phydev->suspended = 0;2799 2800 ret = phy_poll_reset(phydev);2801 if (ret)2802 return ret;2803 2804 /* BMCR may be reset to defaults */2805 if (phydev->autoneg == AUTONEG_DISABLE)2806 ret = genphy_setup_forced(phydev);2807 2808 return ret;2809}2810EXPORT_SYMBOL(genphy_soft_reset);2811 2812irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)2813{2814 /* It seems there are cases where the interrupts are handled by another2815 * entity (ie an IRQ controller embedded inside the PHY) and do not2816 * need any other interraction from phylib. In this case, just trigger2817 * the state machine directly.2818 */2819 phy_trigger_machine(phydev);2820 2821 return 0;2822}2823EXPORT_SYMBOL(genphy_handle_interrupt_no_ack);2824 2825/**2826 * genphy_read_abilities - read PHY abilities from Clause 22 registers2827 * @phydev: target phy_device struct2828 *2829 * Description: Reads the PHY's abilities and populates2830 * phydev->supported accordingly.2831 *2832 * Returns: 0 on success, < 0 on failure2833 */2834int genphy_read_abilities(struct phy_device *phydev)2835{2836 int val;2837 2838 linkmode_set_bit_array(phy_basic_ports_array,2839 ARRAY_SIZE(phy_basic_ports_array),2840 phydev->supported);2841 2842 val = phy_read(phydev, MII_BMSR);2843 if (val < 0)2844 return val;2845 2846 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,2847 val & BMSR_ANEGCAPABLE);2848 2849 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,2850 val & BMSR_100FULL);2851 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,2852 val & BMSR_100HALF);2853 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,2854 val & BMSR_10FULL);2855 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,2856 val & BMSR_10HALF);2857 2858 if (val & BMSR_ESTATEN) {2859 val = phy_read(phydev, MII_ESTATUS);2860 if (val < 0)2861 return val;2862 2863 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,2864 phydev->supported, val & ESTATUS_1000_TFULL);2865 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,2866 phydev->supported, val & ESTATUS_1000_THALF);2867 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,2868 phydev->supported, val & ESTATUS_1000_XFULL);2869 }2870 2871 /* This is optional functionality. If not supported, we may get an error2872 * which should be ignored.2873 */2874 genphy_c45_read_eee_abilities(phydev);2875 2876 return 0;2877}2878EXPORT_SYMBOL(genphy_read_abilities);2879 2880/* This is used for the phy device which doesn't support the MMD extended2881 * register access, but it does have side effect when we are trying to access2882 * the MMD register via indirect method.2883 */2884int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)2885{2886 return -EOPNOTSUPP;2887}2888EXPORT_SYMBOL(genphy_read_mmd_unsupported);2889 2890int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,2891 u16 regnum, u16 val)2892{2893 return -EOPNOTSUPP;2894}2895EXPORT_SYMBOL(genphy_write_mmd_unsupported);2896 2897int genphy_suspend(struct phy_device *phydev)2898{2899 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);2900}2901EXPORT_SYMBOL(genphy_suspend);2902 2903int genphy_resume(struct phy_device *phydev)2904{2905 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);2906}2907EXPORT_SYMBOL(genphy_resume);2908 2909int genphy_loopback(struct phy_device *phydev, bool enable)2910{2911 if (enable) {2912 u16 ctl = BMCR_LOOPBACK;2913 int ret, val;2914 2915 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);2916 2917 phy_modify(phydev, MII_BMCR, ~0, ctl);2918 2919 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,2920 val & BMSR_LSTATUS,2921 5000, 500000, true);2922 if (ret)2923 return ret;2924 } else {2925 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);2926 2927 phy_config_aneg(phydev);2928 }2929 2930 return 0;2931}2932EXPORT_SYMBOL(genphy_loopback);2933 2934/**2935 * phy_remove_link_mode - Remove a supported link mode2936 * @phydev: phy_device structure to remove link mode from2937 * @link_mode: Link mode to be removed2938 *2939 * Description: Some MACs don't support all link modes which the PHY2940 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper2941 * to remove a link mode.2942 */2943void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)2944{2945 linkmode_clear_bit(link_mode, phydev->supported);2946 phy_advertise_supported(phydev);2947}2948EXPORT_SYMBOL(phy_remove_link_mode);2949 2950static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)2951{2952 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,2953 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));2954 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,2955 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));2956}2957 2958/**2959 * phy_advertise_supported - Advertise all supported modes2960 * @phydev: target phy_device struct2961 *2962 * Description: Called to advertise all supported modes, doesn't touch2963 * pause mode advertising.2964 */2965void phy_advertise_supported(struct phy_device *phydev)2966{2967 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);2968 2969 linkmode_copy(new, phydev->supported);2970 phy_copy_pause_bits(new, phydev->advertising);2971 linkmode_copy(phydev->advertising, new);2972}2973EXPORT_SYMBOL(phy_advertise_supported);2974 2975/**2976 * phy_advertise_eee_all - Advertise all supported EEE modes2977 * @phydev: target phy_device struct2978 *2979 * Description: Per default phylib preserves the EEE advertising at the time of2980 * phy probing, which might be a subset of the supported EEE modes. Use this2981 * function when all supported EEE modes should be advertised. This does not2982 * trigger auto-negotiation, so must be called before phy_start()/2983 * phylink_start() which will start auto-negotiation.2984 */2985void phy_advertise_eee_all(struct phy_device *phydev)2986{2987 linkmode_copy(phydev->advertising_eee, phydev->supported_eee);2988}2989EXPORT_SYMBOL_GPL(phy_advertise_eee_all);2990 2991/**2992 * phy_support_eee - Set initial EEE policy configuration2993 * @phydev: Target phy_device struct2994 *2995 * This function configures the initial policy for Energy Efficient Ethernet2996 * (EEE) on the specified PHY device, influencing that EEE capabilities are2997 * advertised before the link is established. It should be called during PHY2998 * registration by the MAC driver and/or the PHY driver (for SmartEEE PHYs)2999 * if MAC supports LPI or PHY is capable to compensate missing LPI functionality3000 * of the MAC.3001 *3002 * The function sets default EEE policy parameters, including preparing the PHY3003 * to advertise EEE capabilities based on hardware support.3004 *3005 * It also sets the expected configuration for Low Power Idle (LPI) in the MAC3006 * driver. If the PHY framework determines that both local and remote3007 * advertisements support EEE, and the negotiated link mode is compatible with3008 * EEE, it will set enable_tx_lpi = true. The MAC driver is expected to act on3009 * this setting by enabling the LPI timer if enable_tx_lpi is set.3010 */3011void phy_support_eee(struct phy_device *phydev)3012{3013 linkmode_copy(phydev->advertising_eee, phydev->supported_eee);3014 phydev->eee_cfg.tx_lpi_enabled = true;3015 phydev->eee_cfg.eee_enabled = true;3016}3017EXPORT_SYMBOL(phy_support_eee);3018 3019/**3020 * phy_support_sym_pause - Enable support of symmetrical pause3021 * @phydev: target phy_device struct3022 *3023 * Description: Called by the MAC to indicate is supports symmetrical3024 * Pause, but not asym pause.3025 */3026void phy_support_sym_pause(struct phy_device *phydev)3027{3028 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);3029 phy_copy_pause_bits(phydev->advertising, phydev->supported);3030}3031EXPORT_SYMBOL(phy_support_sym_pause);3032 3033/**3034 * phy_support_asym_pause - Enable support of asym pause3035 * @phydev: target phy_device struct3036 *3037 * Description: Called by the MAC to indicate is supports Asym Pause.3038 */3039void phy_support_asym_pause(struct phy_device *phydev)3040{3041 phy_copy_pause_bits(phydev->advertising, phydev->supported);3042}3043EXPORT_SYMBOL(phy_support_asym_pause);3044 3045/**3046 * phy_set_sym_pause - Configure symmetric Pause3047 * @phydev: target phy_device struct3048 * @rx: Receiver Pause is supported3049 * @tx: Transmit Pause is supported3050 * @autoneg: Auto neg should be used3051 *3052 * Description: Configure advertised Pause support depending on if3053 * receiver pause and pause auto neg is supported. Generally called3054 * from the set_pauseparam .ndo.3055 */3056void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,3057 bool autoneg)3058{3059 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);3060 3061 if (rx && tx && autoneg)3062 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,3063 phydev->supported);3064 3065 linkmode_copy(phydev->advertising, phydev->supported);3066}3067EXPORT_SYMBOL(phy_set_sym_pause);3068 3069/**3070 * phy_set_asym_pause - Configure Pause and Asym Pause3071 * @phydev: target phy_device struct3072 * @rx: Receiver Pause is supported3073 * @tx: Transmit Pause is supported3074 *3075 * Description: Configure advertised Pause support depending on if3076 * transmit and receiver pause is supported. If there has been a3077 * change in adverting, trigger a new autoneg. Generally called from3078 * the set_pauseparam .ndo.3079 */3080void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)3081{3082 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);3083 3084 linkmode_copy(oldadv, phydev->advertising);3085 linkmode_set_pause(phydev->advertising, tx, rx);3086 3087 if (!linkmode_equal(oldadv, phydev->advertising) &&3088 phydev->autoneg)3089 phy_start_aneg(phydev);3090}3091EXPORT_SYMBOL(phy_set_asym_pause);3092 3093/**3094 * phy_validate_pause - Test if the PHY/MAC support the pause configuration3095 * @phydev: phy_device struct3096 * @pp: requested pause configuration3097 *3098 * Description: Test if the PHY/MAC combination supports the Pause3099 * configuration the user is requesting. Returns True if it is3100 * supported, false otherwise.3101 */3102bool phy_validate_pause(struct phy_device *phydev,3103 struct ethtool_pauseparam *pp)3104{3105 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,3106 phydev->supported) && pp->rx_pause)3107 return false;3108 3109 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,3110 phydev->supported) &&3111 pp->rx_pause != pp->tx_pause)3112 return false;3113 3114 return true;3115}3116EXPORT_SYMBOL(phy_validate_pause);3117 3118/**3119 * phy_get_pause - resolve negotiated pause modes3120 * @phydev: phy_device struct3121 * @tx_pause: pointer to bool to indicate whether transmit pause should be3122 * enabled.3123 * @rx_pause: pointer to bool to indicate whether receive pause should be3124 * enabled.3125 *3126 * Resolve and return the flow control modes according to the negotiation3127 * result. This includes checking that we are operating in full duplex mode.3128 * See linkmode_resolve_pause() for further details.3129 */3130void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)3131{3132 if (phydev->duplex != DUPLEX_FULL) {3133 *tx_pause = false;3134 *rx_pause = false;3135 return;3136 }3137 3138 return linkmode_resolve_pause(phydev->advertising,3139 phydev->lp_advertising,3140 tx_pause, rx_pause);3141}3142EXPORT_SYMBOL(phy_get_pause);3143 3144#if IS_ENABLED(CONFIG_OF_MDIO)3145static int phy_get_int_delay_property(struct device *dev, const char *name)3146{3147 s32 int_delay;3148 int ret;3149 3150 ret = device_property_read_u32(dev, name, &int_delay);3151 if (ret)3152 return ret;3153 3154 return int_delay;3155}3156#else3157static int phy_get_int_delay_property(struct device *dev, const char *name)3158{3159 return -EINVAL;3160}3161#endif3162 3163/**3164 * phy_get_internal_delay - returns the index of the internal delay3165 * @phydev: phy_device struct3166 * @dev: pointer to the devices device struct3167 * @delay_values: array of delays the PHY supports3168 * @size: the size of the delay array3169 * @is_rx: boolean to indicate to get the rx internal delay3170 *3171 * Returns the index within the array of internal delay passed in.3172 * If the device property is not present then the interface type is checked3173 * if the interface defines use of internal delay then a 1 is returned otherwise3174 * a 0 is returned.3175 * The array must be in ascending order. If PHY does not have an ascending order3176 * array then size = 0 and the value of the delay property is returned.3177 * Return -EINVAL if the delay is invalid or cannot be found.3178 */3179s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev,3180 const int *delay_values, int size, bool is_rx)3181{3182 s32 delay;3183 int i;3184 3185 if (is_rx) {3186 delay = phy_get_int_delay_property(dev, "rx-internal-delay-ps");3187 if (delay < 0 && size == 0) {3188 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||3189 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)3190 return 1;3191 else3192 return 0;3193 }3194 3195 } else {3196 delay = phy_get_int_delay_property(dev, "tx-internal-delay-ps");3197 if (delay < 0 && size == 0) {3198 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||3199 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)3200 return 1;3201 else3202 return 0;3203 }3204 }3205 3206 if (delay < 0)3207 return delay;3208 3209 if (size == 0)3210 return delay;3211 3212 if (delay < delay_values[0] || delay > delay_values[size - 1]) {3213 phydev_err(phydev, "Delay %d is out of range\n", delay);3214 return -EINVAL;3215 }3216 3217 if (delay == delay_values[0])3218 return 0;3219 3220 for (i = 1; i < size; i++) {3221 if (delay == delay_values[i])3222 return i;3223 3224 /* Find an approximate index by looking up the table */3225 if (delay > delay_values[i - 1] &&3226 delay < delay_values[i]) {3227 if (delay - delay_values[i - 1] <3228 delay_values[i] - delay)3229 return i - 1;3230 else3231 return i;3232 }3233 }3234 3235 phydev_err(phydev, "error finding internal delay index for %d\n",3236 delay);3237 3238 return -EINVAL;3239}3240EXPORT_SYMBOL(phy_get_internal_delay);3241 3242static int phy_led_set_brightness(struct led_classdev *led_cdev,3243 enum led_brightness value)3244{3245 struct phy_led *phyled = to_phy_led(led_cdev);3246 struct phy_device *phydev = phyled->phydev;3247 int err;3248 3249 mutex_lock(&phydev->lock);3250 err = phydev->drv->led_brightness_set(phydev, phyled->index, value);3251 mutex_unlock(&phydev->lock);3252 3253 return err;3254}3255 3256static int phy_led_blink_set(struct led_classdev *led_cdev,3257 unsigned long *delay_on,3258 unsigned long *delay_off)3259{3260 struct phy_led *phyled = to_phy_led(led_cdev);3261 struct phy_device *phydev = phyled->phydev;3262 int err;3263 3264 mutex_lock(&phydev->lock);3265 err = phydev->drv->led_blink_set(phydev, phyled->index,3266 delay_on, delay_off);3267 mutex_unlock(&phydev->lock);3268 3269 return err;3270}3271 3272static __maybe_unused struct device *3273phy_led_hw_control_get_device(struct led_classdev *led_cdev)3274{3275 struct phy_led *phyled = to_phy_led(led_cdev);3276 struct phy_device *phydev = phyled->phydev;3277 3278 if (phydev->attached_dev)3279 return &phydev->attached_dev->dev;3280 return NULL;3281}3282 3283static int __maybe_unused3284phy_led_hw_control_get(struct led_classdev *led_cdev,3285 unsigned long *rules)3286{3287 struct phy_led *phyled = to_phy_led(led_cdev);3288 struct phy_device *phydev = phyled->phydev;3289 int err;3290 3291 mutex_lock(&phydev->lock);3292 err = phydev->drv->led_hw_control_get(phydev, phyled->index, rules);3293 mutex_unlock(&phydev->lock);3294 3295 return err;3296}3297 3298static int __maybe_unused3299phy_led_hw_control_set(struct led_classdev *led_cdev,3300 unsigned long rules)3301{3302 struct phy_led *phyled = to_phy_led(led_cdev);3303 struct phy_device *phydev = phyled->phydev;3304 int err;3305 3306 mutex_lock(&phydev->lock);3307 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules);3308 mutex_unlock(&phydev->lock);3309 3310 return err;3311}3312 3313static __maybe_unused int phy_led_hw_is_supported(struct led_classdev *led_cdev,3314 unsigned long rules)3315{3316 struct phy_led *phyled = to_phy_led(led_cdev);3317 struct phy_device *phydev = phyled->phydev;3318 int err;3319 3320 mutex_lock(&phydev->lock);3321 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules);3322 mutex_unlock(&phydev->lock);3323 3324 return err;3325}3326 3327static void phy_leds_unregister(struct phy_device *phydev)3328{3329 struct phy_led *phyled, *tmp;3330 3331 list_for_each_entry_safe(phyled, tmp, &phydev->leds, list) {3332 led_classdev_unregister(&phyled->led_cdev);3333 list_del(&phyled->list);3334 }3335}3336 3337static int of_phy_led(struct phy_device *phydev,3338 struct device_node *led)3339{3340 struct device *dev = &phydev->mdio.dev;3341 struct led_init_data init_data = {};3342 struct led_classdev *cdev;3343 unsigned long modes = 0;3344 struct phy_led *phyled;3345 u32 index;3346 int err;3347 3348 phyled = devm_kzalloc(dev, sizeof(*phyled), GFP_KERNEL);3349 if (!phyled)3350 return -ENOMEM;3351 3352 cdev = &phyled->led_cdev;3353 phyled->phydev = phydev;3354 3355 err = of_property_read_u32(led, "reg", &index);3356 if (err)3357 return err;3358 if (index > U8_MAX)3359 return -EINVAL;3360 3361 if (of_property_read_bool(led, "active-low"))3362 set_bit(PHY_LED_ACTIVE_LOW, &modes);3363 if (of_property_read_bool(led, "inactive-high-impedance"))3364 set_bit(PHY_LED_INACTIVE_HIGH_IMPEDANCE, &modes);3365 3366 if (modes) {3367 /* Return error if asked to set polarity modes but not supported */3368 if (!phydev->drv->led_polarity_set)3369 return -EINVAL;3370 3371 err = phydev->drv->led_polarity_set(phydev, index, modes);3372 if (err)3373 return err;3374 }3375 3376 phyled->index = index;3377 if (phydev->drv->led_brightness_set)3378 cdev->brightness_set_blocking = phy_led_set_brightness;3379 if (phydev->drv->led_blink_set)3380 cdev->blink_set = phy_led_blink_set;3381 3382#ifdef CONFIG_LEDS_TRIGGERS3383 if (phydev->drv->led_hw_is_supported &&3384 phydev->drv->led_hw_control_set &&3385 phydev->drv->led_hw_control_get) {3386 cdev->hw_control_is_supported = phy_led_hw_is_supported;3387 cdev->hw_control_set = phy_led_hw_control_set;3388 cdev->hw_control_get = phy_led_hw_control_get;3389 cdev->hw_control_trigger = "netdev";3390 }3391 3392 cdev->hw_control_get_device = phy_led_hw_control_get_device;3393#endif3394 cdev->max_brightness = 1;3395 init_data.devicename = dev_name(&phydev->mdio.dev);3396 init_data.fwnode = of_fwnode_handle(led);3397 init_data.devname_mandatory = true;3398 3399 err = led_classdev_register_ext(dev, cdev, &init_data);3400 if (err)3401 return err;3402 3403 list_add(&phyled->list, &phydev->leds);3404 3405 return 0;3406}3407 3408static int of_phy_leds(struct phy_device *phydev)3409{3410 struct device_node *node = phydev->mdio.dev.of_node;3411 struct device_node *leds;3412 int err;3413 3414 if (!IS_ENABLED(CONFIG_OF_MDIO))3415 return 0;3416 3417 if (!node)3418 return 0;3419 3420 leds = of_get_child_by_name(node, "leds");3421 if (!leds)3422 return 0;3423 3424 for_each_available_child_of_node_scoped(leds, led) {3425 err = of_phy_led(phydev, led);3426 if (err) {3427 of_node_put(leds);3428 phy_leds_unregister(phydev);3429 return err;3430 }3431 }3432 3433 of_node_put(leds);3434 return 0;3435}3436 3437/**3438 * fwnode_mdio_find_device - Given a fwnode, find the mdio_device3439 * @fwnode: pointer to the mdio_device's fwnode3440 *3441 * If successful, returns a pointer to the mdio_device with the embedded3442 * struct device refcount incremented by one, or NULL on failure.3443 * The caller should call put_device() on the mdio_device after its use.3444 */3445struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode)3446{3447 struct device *d;3448 3449 if (!fwnode)3450 return NULL;3451 3452 d = bus_find_device_by_fwnode(&mdio_bus_type, fwnode);3453 if (!d)3454 return NULL;3455 3456 return to_mdio_device(d);3457}3458EXPORT_SYMBOL(fwnode_mdio_find_device);3459 3460/**3461 * fwnode_phy_find_device - For provided phy_fwnode, find phy_device.3462 *3463 * @phy_fwnode: Pointer to the phy's fwnode.3464 *3465 * If successful, returns a pointer to the phy_device with the embedded3466 * struct device refcount incremented by one, or NULL on failure.3467 */3468struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode)3469{3470 struct mdio_device *mdiodev;3471 3472 mdiodev = fwnode_mdio_find_device(phy_fwnode);3473 if (!mdiodev)3474 return NULL;3475 3476 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)3477 return to_phy_device(&mdiodev->dev);3478 3479 put_device(&mdiodev->dev);3480 3481 return NULL;3482}3483EXPORT_SYMBOL(fwnode_phy_find_device);3484 3485/**3486 * device_phy_find_device - For the given device, get the phy_device3487 * @dev: Pointer to the given device3488 *3489 * Refer return conditions of fwnode_phy_find_device().3490 */3491struct phy_device *device_phy_find_device(struct device *dev)3492{3493 return fwnode_phy_find_device(dev_fwnode(dev));3494}3495EXPORT_SYMBOL_GPL(device_phy_find_device);3496 3497/**3498 * fwnode_get_phy_node - Get the phy_node using the named reference.3499 * @fwnode: Pointer to fwnode from which phy_node has to be obtained.3500 *3501 * Refer return conditions of fwnode_find_reference().3502 * For ACPI, only "phy-handle" is supported. Legacy DT properties "phy"3503 * and "phy-device" are not supported in ACPI. DT supports all the three3504 * named references to the phy node.3505 */3506struct fwnode_handle *fwnode_get_phy_node(const struct fwnode_handle *fwnode)3507{3508 struct fwnode_handle *phy_node;3509 3510 /* Only phy-handle is used for ACPI */3511 phy_node = fwnode_find_reference(fwnode, "phy-handle", 0);3512 if (is_acpi_node(fwnode) || !IS_ERR(phy_node))3513 return phy_node;3514 phy_node = fwnode_find_reference(fwnode, "phy", 0);3515 if (IS_ERR(phy_node))3516 phy_node = fwnode_find_reference(fwnode, "phy-device", 0);3517 return phy_node;3518}3519EXPORT_SYMBOL_GPL(fwnode_get_phy_node);3520 3521/**3522 * phy_probe - probe and init a PHY device3523 * @dev: device to probe and init3524 *3525 * Take care of setting up the phy_device structure, set the state to READY.3526 */3527static int phy_probe(struct device *dev)3528{3529 struct phy_device *phydev = to_phy_device(dev);3530 struct device_driver *drv = phydev->mdio.dev.driver;3531 struct phy_driver *phydrv = to_phy_driver(drv);3532 int err = 0;3533 3534 phydev->drv = phydrv;3535 3536 /* Disable the interrupt if the PHY doesn't support it3537 * but the interrupt is still a valid one3538 */3539 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))3540 phydev->irq = PHY_POLL;3541 3542 if (phydrv->flags & PHY_IS_INTERNAL)3543 phydev->is_internal = true;3544 3545 /* Deassert the reset signal */3546 phy_device_reset(phydev, 0);3547 3548 if (phydev->drv->probe) {3549 err = phydev->drv->probe(phydev);3550 if (err)3551 goto out;3552 }3553 3554 phy_disable_interrupts(phydev);3555 3556 /* Start out supporting everything. Eventually,3557 * a controller will attach, and may modify one3558 * or both of these values3559 */3560 if (phydrv->features) {3561 linkmode_copy(phydev->supported, phydrv->features);3562 genphy_c45_read_eee_abilities(phydev);3563 }3564 else if (phydrv->get_features)3565 err = phydrv->get_features(phydev);3566 else if (phydev->is_c45)3567 err = genphy_c45_pma_read_abilities(phydev);3568 else3569 err = genphy_read_abilities(phydev);3570 3571 if (err)3572 goto out;3573 3574 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,3575 phydev->supported))3576 phydev->autoneg = 0;3577 3578 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,3579 phydev->supported))3580 phydev->is_gigabit_capable = 1;3581 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,3582 phydev->supported))3583 phydev->is_gigabit_capable = 1;3584 3585 of_set_phy_supported(phydev);3586 phy_advertise_supported(phydev);3587 3588 /* Get PHY default EEE advertising modes and handle them as potentially3589 * safe initial configuration.3590 */3591 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee);3592 if (err)3593 goto out;3594 3595 /* There is no "enabled" flag. If PHY is advertising, assume it is3596 * kind of enabled.3597 */3598 phydev->eee_enabled = !linkmode_empty(phydev->advertising_eee);3599 3600 /* Some PHYs may advertise, by default, not support EEE modes. So,3601 * we need to clean them.3602 */3603 if (phydev->eee_enabled)3604 linkmode_and(phydev->advertising_eee, phydev->supported_eee,3605 phydev->advertising_eee);3606 3607 /* Get the EEE modes we want to prohibit. We will ask3608 * the PHY stop advertising these mode later on3609 */3610 of_set_phy_eee_broken(phydev);3611 3612 /* The Pause Frame bits indicate that the PHY can support passing3613 * pause frames. During autonegotiation, the PHYs will determine if3614 * they should allow pause frames to pass. The MAC driver should then3615 * use that result to determine whether to enable flow control via3616 * pause frames.3617 *3618 * Normally, PHY drivers should not set the Pause bits, and instead3619 * allow phylib to do that. However, there may be some situations3620 * (e.g. hardware erratum) where the driver wants to set only one3621 * of these bits.3622 */3623 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&3624 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {3625 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,3626 phydev->supported);3627 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,3628 phydev->supported);3629 }3630 3631 /* Set the state to READY by default */3632 phydev->state = PHY_READY;3633 3634 /* Get the LEDs from the device tree, and instantiate standard3635 * LEDs for them.3636 */3637 if (IS_ENABLED(CONFIG_PHYLIB_LEDS))3638 err = of_phy_leds(phydev);3639 3640out:3641 /* Re-assert the reset signal on error */3642 if (err)3643 phy_device_reset(phydev, 1);3644 3645 return err;3646}3647 3648static int phy_remove(struct device *dev)3649{3650 struct phy_device *phydev = to_phy_device(dev);3651 3652 cancel_delayed_work_sync(&phydev->state_queue);3653 3654 if (IS_ENABLED(CONFIG_PHYLIB_LEDS))3655 phy_leds_unregister(phydev);3656 3657 phydev->state = PHY_DOWN;3658 3659 sfp_bus_del_upstream(phydev->sfp_bus);3660 phydev->sfp_bus = NULL;3661 3662 if (phydev->drv && phydev->drv->remove)3663 phydev->drv->remove(phydev);3664 3665 /* Assert the reset signal */3666 phy_device_reset(phydev, 1);3667 3668 phydev->drv = NULL;3669 3670 return 0;3671}3672 3673/**3674 * phy_driver_register - register a phy_driver with the PHY layer3675 * @new_driver: new phy_driver to register3676 * @owner: module owning this PHY3677 */3678int phy_driver_register(struct phy_driver *new_driver, struct module *owner)3679{3680 int retval;3681 3682 /* Either the features are hard coded, or dynamically3683 * determined. It cannot be both.3684 */3685 if (WARN_ON(new_driver->features && new_driver->get_features)) {3686 pr_err("%s: features and get_features must not both be set\n",3687 new_driver->name);3688 return -EINVAL;3689 }3690 3691 /* PHYLIB device drivers must not match using a DT compatible table3692 * as this bypasses our checks that the mdiodev that is being matched3693 * is backed by a struct phy_device. If such a case happens, we will3694 * make out-of-bounds accesses and lockup in phydev->lock.3695 */3696 if (WARN(new_driver->mdiodrv.driver.of_match_table,3697 "%s: driver must not provide a DT match table\n",3698 new_driver->name))3699 return -EINVAL;3700 3701 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;3702 new_driver->mdiodrv.driver.name = new_driver->name;3703 new_driver->mdiodrv.driver.bus = &mdio_bus_type;3704 new_driver->mdiodrv.driver.probe = phy_probe;3705 new_driver->mdiodrv.driver.remove = phy_remove;3706 new_driver->mdiodrv.driver.owner = owner;3707 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;3708 3709 retval = driver_register(&new_driver->mdiodrv.driver);3710 if (retval) {3711 pr_err("%s: Error %d in registering driver\n",3712 new_driver->name, retval);3713 3714 return retval;3715 }3716 3717 pr_debug("%s: Registered new driver\n", new_driver->name);3718 3719 return 0;3720}3721EXPORT_SYMBOL(phy_driver_register);3722 3723int phy_drivers_register(struct phy_driver *new_driver, int n,3724 struct module *owner)3725{3726 int i, ret = 0;3727 3728 for (i = 0; i < n; i++) {3729 ret = phy_driver_register(new_driver + i, owner);3730 if (ret) {3731 while (i-- > 0)3732 phy_driver_unregister(new_driver + i);3733 break;3734 }3735 }3736 return ret;3737}3738EXPORT_SYMBOL(phy_drivers_register);3739 3740void phy_driver_unregister(struct phy_driver *drv)3741{3742 driver_unregister(&drv->mdiodrv.driver);3743}3744EXPORT_SYMBOL(phy_driver_unregister);3745 3746void phy_drivers_unregister(struct phy_driver *drv, int n)3747{3748 int i;3749 3750 for (i = 0; i < n; i++)3751 phy_driver_unregister(drv + i);3752}3753EXPORT_SYMBOL(phy_drivers_unregister);3754 3755static struct phy_driver genphy_driver = {3756 .phy_id = 0xffffffff,3757 .phy_id_mask = 0xffffffff,3758 .name = "Generic PHY",3759 .get_features = genphy_read_abilities,3760 .suspend = genphy_suspend,3761 .resume = genphy_resume,3762 .set_loopback = genphy_loopback,3763};3764 3765static const struct ethtool_phy_ops phy_ethtool_phy_ops = {3766 .get_sset_count = phy_ethtool_get_sset_count,3767 .get_strings = phy_ethtool_get_strings,3768 .get_stats = phy_ethtool_get_stats,3769 .get_plca_cfg = phy_ethtool_get_plca_cfg,3770 .set_plca_cfg = phy_ethtool_set_plca_cfg,3771 .get_plca_status = phy_ethtool_get_plca_status,3772 .start_cable_test = phy_start_cable_test,3773 .start_cable_test_tdr = phy_start_cable_test_tdr,3774};3775 3776static const struct phylib_stubs __phylib_stubs = {3777 .hwtstamp_get = __phy_hwtstamp_get,3778 .hwtstamp_set = __phy_hwtstamp_set,3779};3780 3781static void phylib_register_stubs(void)3782{3783 phylib_stubs = &__phylib_stubs;3784}3785 3786static void phylib_unregister_stubs(void)3787{3788 phylib_stubs = NULL;3789}3790 3791static int __init phy_init(void)3792{3793 int rc;3794 3795 rtnl_lock();3796 ethtool_set_ethtool_phy_ops(&phy_ethtool_phy_ops);3797 phylib_register_stubs();3798 rtnl_unlock();3799 3800 rc = mdio_bus_init();3801 if (rc)3802 goto err_ethtool_phy_ops;3803 3804 features_init();3805 3806 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);3807 if (rc)3808 goto err_mdio_bus;3809 3810 rc = phy_driver_register(&genphy_driver, THIS_MODULE);3811 if (rc)3812 goto err_c45;3813 3814 return 0;3815 3816err_c45:3817 phy_driver_unregister(&genphy_c45_driver);3818err_mdio_bus:3819 mdio_bus_exit();3820err_ethtool_phy_ops:3821 rtnl_lock();3822 phylib_unregister_stubs();3823 ethtool_set_ethtool_phy_ops(NULL);3824 rtnl_unlock();3825 3826 return rc;3827}3828 3829static void __exit phy_exit(void)3830{3831 phy_driver_unregister(&genphy_c45_driver);3832 phy_driver_unregister(&genphy_driver);3833 mdio_bus_exit();3834 rtnl_lock();3835 phylib_unregister_stubs();3836 ethtool_set_ethtool_phy_ops(NULL);3837 rtnl_unlock();3838}3839 3840subsys_initcall(phy_init);3841module_exit(phy_exit);3842