Lines Matching defs:phydev
201 void phy_device_free(struct phy_device *phydev)
203 put_device(&phydev->mdio.dev);
209 struct phy_device *phydev;
211 phydev = container_of(mdiodev, struct phy_device, mdio);
212 phy_device_free(phydev);
222 struct phy_device *phydev;
224 phydev = container_of(mdiodev, struct phy_device, mdio);
225 phy_device_remove(phydev);
233 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
235 struct device_driver *drv = phydev->mdio.dev.driver;
237 struct net_device *netdev = phydev->attached_dev;
269 return !phydev->suspended;
274 struct phy_device *phydev = to_phy_device(dev);
277 * control, possibly with the phydev->lock held. Upon resume, netdev
281 if (phydev->attached_dev && phydev->adjust_link)
282 phy_stop_machine(phydev);
284 if (!mdio_bus_phy_may_suspend(phydev))
287 phydev->suspended_by_mdio_bus = 1;
289 return phy_suspend(phydev);
294 struct phy_device *phydev = to_phy_device(dev);
297 if (!phydev->suspended_by_mdio_bus)
300 phydev->suspended_by_mdio_bus = 0;
302 ret = phy_init_hw(phydev);
306 ret = phy_resume(phydev);
310 if (phydev->attached_dev && phydev->adjust_link)
311 phy_start_machine(phydev);
321 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
322 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
324 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
412 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
415 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
417 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
422 (phydev->phy_id & fixup->phy_uid_mask))
429 /* Runs any matching fixups for this phydev */
430 static int phy_scan_fixups(struct phy_device *phydev)
436 if (phy_needs_fixup(phydev, fixup)) {
437 int err = fixup->run(phydev);
443 phydev->has_fixups = true;
453 struct phy_device *phydev = to_phy_device(dev);
455 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
462 return phydrv->match_phy_device(phydev);
464 if (phydev->is_c45) {
466 if (phydev->c45_ids.device_ids[i] == 0xffffffff)
470 (phydev->c45_ids.device_ids[i] &
477 (phydev->phy_id & phydrv->phy_id_mask);
484 struct phy_device *phydev = to_phy_device(dev);
486 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
493 struct phy_device *phydev = to_phy_device(dev);
496 if (phy_is_internal(phydev))
499 mode = phy_modes(phydev->interface);
509 struct phy_device *phydev = to_phy_device(dev);
511 return sprintf(buf, "%d\n", phydev->has_fixups);
862 * @phydev: phy_device structure to be added to the MDIO bus
864 int phy_device_register(struct phy_device *phydev)
868 err = mdiobus_register_device(&phydev->mdio);
873 phy_device_reset(phydev, 0);
876 err = phy_scan_fixups(phydev);
878 phydev_err(phydev, "failed to initialize\n");
882 err = device_add(&phydev->mdio.dev);
884 phydev_err(phydev, "failed to add\n");
892 phy_device_reset(phydev, 1);
894 mdiobus_unregister_device(&phydev->mdio);
901 * @phydev: phy_device structure to remove
907 void phy_device_remove(struct phy_device *phydev)
909 if (phydev->mii_ts)
910 unregister_mii_timestamper(phydev->mii_ts);
912 device_del(&phydev->mdio.dev);
915 phy_device_reset(phydev, 1);
917 mdiobus_unregister_device(&phydev->mdio);
927 struct phy_device *phydev;
931 phydev = mdiobus_get_phy(bus, addr);
932 if (phydev)
933 return phydev;
939 static void phy_link_change(struct phy_device *phydev, bool up)
941 struct net_device *netdev = phydev->attached_dev;
947 phydev->adjust_link(netdev);
948 if (phydev->mii_ts && phydev->mii_ts->link_state)
949 phydev->mii_ts->link_state(phydev->mii_ts, phydev);
954 * @phydev: target phy_device struct
964 static void phy_prepare_link(struct phy_device *phydev,
967 phydev->adjust_link = handler;
973 * @phydev: the pointer to the phy device
977 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
986 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
990 phy_prepare_link(phydev, handler);
991 if (phy_interrupt_is_valid(phydev))
992 phy_request_interrupt(phydev);
1017 struct phy_device *phydev;
1029 phydev = to_phy_device(d);
1031 rc = phy_connect_direct(dev, phydev, handler, interface);
1036 return phydev;
1043 * @phydev: target phy_device struct
1045 void phy_disconnect(struct phy_device *phydev)
1047 if (phy_is_started(phydev))
1048 phy_stop(phydev);
1050 if (phy_interrupt_is_valid(phydev))
1051 phy_free_interrupt(phydev);
1053 phydev->adjust_link = NULL;
1055 phy_detach(phydev);
1061 * @phydev: The PHY device to poll
1077 static int phy_poll_reset(struct phy_device *phydev)
1082 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
1093 int phy_init_hw(struct phy_device *phydev)
1098 phy_device_reset(phydev, 0);
1100 if (!phydev->drv)
1103 if (phydev->drv->soft_reset) {
1104 ret = phydev->drv->soft_reset(phydev);
1107 phydev->suspended = 0;
1113 ret = phy_scan_fixups(phydev);
1117 if (phydev->drv->config_init) {
1118 ret = phydev->drv->config_init(phydev);
1123 if (phydev->drv->config_intr) {
1124 ret = phydev->drv->config_intr(phydev);
1133 void phy_attached_info(struct phy_device *phydev)
1135 phy_attached_print(phydev, NULL);
1140 char *phy_attached_info_irq(struct phy_device *phydev)
1145 switch(phydev->irq) {
1153 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1162 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1164 const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
1165 char *irq_str = phy_attached_info_irq(phydev);
1168 phydev_info(phydev, ATTACHED_FMT "\n",
1169 drv_name, phydev_name(phydev),
1174 phydev_info(phydev, ATTACHED_FMT,
1175 drv_name, phydev_name(phydev),
1186 static void phy_sysfs_create_links(struct phy_device *phydev)
1188 struct net_device *dev = phydev->attached_dev;
1194 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1200 &phydev->mdio.dev.kobj,
1201 "phydev");
1204 kobject_name(&phydev->mdio.dev.kobj),
1211 phydev->sysfs_links = true;
1218 struct phy_device *phydev = to_phy_device(dev);
1220 return sprintf(buf, "%d\n", !phydev->attached_dev);
1233 struct phy_device *phydev = upstream;
1235 if (phydev->attached_dev)
1236 phydev->attached_dev->sfp_bus = bus;
1237 phydev->sfp_bus_attached = true;
1250 struct phy_device *phydev = upstream;
1252 if (phydev->attached_dev)
1253 phydev->attached_dev->sfp_bus = NULL;
1254 phydev->sfp_bus_attached = false;
1260 * @phydev: Pointer to phy_device
1263 int phy_sfp_probe(struct phy_device *phydev,
1269 if (phydev->mdio.dev.fwnode) {
1270 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1274 phydev->sfp_bus = bus;
1276 ret = sfp_bus_add_upstream(bus, phydev, ops);
1286 * @phydev: Pointer to phy_device to attach
1298 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1301 struct mii_bus *bus = phydev->mdio.bus;
1302 struct device *d = &phydev->mdio.dev;
1315 phydev_err(phydev, "failed to get the bus module\n");
1325 if (phydev->is_c45)
1334 phydev_err(phydev, "failed to get the device driver module\n");
1348 if (phydev->attached_dev) {
1354 phydev->phy_link_change = phy_link_change;
1356 phydev->attached_dev = dev;
1357 dev->phydev = phydev;
1359 if (phydev->sfp_bus_attached)
1360 dev->sfp_bus = phydev->sfp_bus;
1371 phydev->sysfs_links = false;
1373 phy_sysfs_create_links(phydev);
1375 if (!phydev->attached_dev) {
1376 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1379 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1382 phydev->dev_flags |= flags;
1384 phydev->interface = interface;
1386 phydev->state = PHY_READY;
1394 phydev->port = PORT_MII;
1400 netif_carrier_off(phydev->attached_dev);
1406 err = phy_init_hw(phydev);
1410 err = phy_disable_interrupts(phydev);
1414 phy_resume(phydev);
1415 phy_led_triggers_register(phydev);
1421 phy_detach(phydev);
1448 struct phy_device *phydev;
1463 phydev = to_phy_device(d);
1465 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1470 return phydev;
1474 static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1477 struct device *d = &phydev->mdio.dev;
1480 if (!phydev->drv)
1490 bool phy_driver_is_genphy(struct phy_device *phydev)
1492 return phy_driver_is_genphy_kind(phydev,
1497 bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1499 return phy_driver_is_genphy_kind(phydev,
1506 * @phydev: target phy_device struct
1522 * This will set the shared pointer of the phydev to the shared storage.
1530 int phy_package_join(struct phy_device *phydev, int addr, size_t priv_size)
1532 struct mii_bus *bus = phydev->mdio.bus;
1563 phydev->shared = shared;
1577 * @phydev: target phy_device struct
1579 * This leaves a PHY group created by phy_package_join(). If this phydev
1581 * freed. Resets the phydev->shared pointer to NULL.
1583 void phy_package_leave(struct phy_device *phydev)
1585 struct phy_package_shared *shared = phydev->shared;
1586 struct mii_bus *bus = phydev->mdio.bus;
1598 phydev->shared = NULL;
1610 * @phydev: target phy_device struct
1618 int devm_phy_package_join(struct device *dev, struct phy_device *phydev,
1629 ret = phy_package_join(phydev, addr, priv_size);
1632 *ptr = phydev;
1644 * @phydev: target phy_device struct
1649 void phy_detach(struct phy_device *phydev)
1651 struct net_device *dev = phydev->attached_dev;
1655 if (phydev->sysfs_links) {
1657 sysfs_remove_link(&dev->dev.kobj, "phydev");
1658 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1661 if (!phydev->attached_dev)
1662 sysfs_remove_file(&phydev->mdio.dev.kobj,
1665 phy_suspend(phydev);
1667 phydev->attached_dev->phydev = NULL;
1668 phydev->attached_dev = NULL;
1670 phydev->phylink = NULL;
1672 phy_led_triggers_unregister(phydev);
1674 if (phydev->mdio.dev.driver)
1675 module_put(phydev->mdio.dev.driver->owner);
1682 if (phy_driver_is_genphy(phydev) ||
1683 phy_driver_is_genphy_10g(phydev))
1684 device_release_driver(&phydev->mdio.dev);
1687 phy_device_reset(phydev, 1);
1690 * The phydev might go away on the put_device() below, so avoid
1693 bus = phydev->mdio.bus;
1695 put_device(&phydev->mdio.dev);
1703 int phy_suspend(struct phy_device *phydev)
1706 struct net_device *netdev = phydev->attached_dev;
1707 struct phy_driver *phydrv = phydev->drv;
1710 if (phydev->suspended)
1714 phy_ethtool_get_wol(phydev, &wol);
1721 ret = phydrv->suspend(phydev);
1723 phydev->suspended = true;
1729 int __phy_resume(struct phy_device *phydev)
1731 struct phy_driver *phydrv = phydev->drv;
1734 WARN_ON(!mutex_is_locked(&phydev->lock));
1739 ret = phydrv->resume(phydev);
1741 phydev->suspended = false;
1747 int phy_resume(struct phy_device *phydev)
1751 mutex_lock(&phydev->lock);
1752 ret = __phy_resume(phydev);
1753 mutex_unlock(&phydev->lock);
1759 int phy_loopback(struct phy_device *phydev, bool enable)
1761 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1764 mutex_lock(&phydev->lock);
1766 if (enable && phydev->loopback_enabled) {
1771 if (!enable && !phydev->loopback_enabled) {
1776 if (phydev->drv && phydrv->set_loopback)
1777 ret = phydrv->set_loopback(phydev, enable);
1784 phydev->loopback_enabled = enable;
1787 mutex_unlock(&phydev->lock);
1794 * @phydev: target phy_device struct
1801 int phy_reset_after_clk_enable(struct phy_device *phydev)
1803 if (!phydev || !phydev->drv)
1806 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1807 phy_device_reset(phydev, 1);
1808 phy_device_reset(phydev, 0);
1820 * @phydev: target phy_device struct
1827 static int genphy_config_advert(struct phy_device *phydev)
1833 linkmode_and(phydev->advertising, phydev->advertising,
1834 phydev->supported);
1836 adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1839 err = phy_modify_changed(phydev, MII_ADVERTISE,
1848 bmsr = phy_read(phydev, MII_BMSR);
1859 adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
1861 err = phy_modify_changed(phydev, MII_CTRL1000,
1874 * @phydev: target phy_device struct
1882 static int genphy_c37_config_advert(struct phy_device *phydev)
1887 linkmode_and(phydev->advertising, phydev->advertising,
1888 phydev->supported);
1891 phydev->advertising))
1894 phydev->advertising))
1897 phydev->advertising))
1900 return phy_modify_changed(phydev, MII_ADVERTISE,
1908 * @phydev: target phy_device struct
1914 int genphy_config_eee_advert(struct phy_device *phydev)
1919 if (!phydev->eee_broken_modes)
1922 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
1923 phydev->eee_broken_modes, 0);
1930 * genphy_setup_forced - configures/forces speed/duplex from @phydev
1931 * @phydev: target phy_device struct
1934 * to the values in phydev. Assumes that the values are valid.
1937 int genphy_setup_forced(struct phy_device *phydev)
1941 phydev->pause = 0;
1942 phydev->asym_pause = 0;
1944 if (SPEED_1000 == phydev->speed)
1946 else if (SPEED_100 == phydev->speed)
1949 if (DUPLEX_FULL == phydev->duplex)
1952 return phy_modify(phydev, MII_BMCR,
1957 static int genphy_setup_master_slave(struct phy_device *phydev)
1961 if (!phydev->is_gigabit_capable)
1964 switch (phydev->master_slave_set) {
1980 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
1984 return phy_modify_changed(phydev, MII_CTRL1000,
1989 static int genphy_read_master_slave(struct phy_device *phydev)
1994 if (!phydev->is_gigabit_capable) {
1995 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
1996 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2000 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2001 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2003 val = phy_read(phydev, MII_CTRL1000);
2019 val = phy_read(phydev, MII_STAT1000);
2025 } else if (phydev->link) {
2035 phydev->master_slave_get = cfg;
2036 phydev->master_slave_state = state;
2043 * @phydev: target phy_device struct
2045 int genphy_restart_aneg(struct phy_device *phydev)
2048 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2055 * @phydev: target phy_device struct
2060 int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2068 ret = phy_read(phydev, MII_BMCR);
2077 return genphy_restart_aneg(phydev);
2085 * @phydev: target phy_device struct
2092 int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2096 if (genphy_config_eee_advert(phydev))
2099 err = genphy_setup_master_slave(phydev);
2105 if (AUTONEG_ENABLE != phydev->autoneg)
2106 return genphy_setup_forced(phydev);
2108 err = genphy_config_advert(phydev);
2114 return genphy_check_and_restart_aneg(phydev, changed);
2120 * @phydev: target phy_device struct
2127 int genphy_c37_config_aneg(struct phy_device *phydev)
2131 if (phydev->autoneg != AUTONEG_ENABLE)
2132 return genphy_setup_forced(phydev);
2134 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2139 changed = genphy_c37_config_advert(phydev);
2147 int ctl = phy_read(phydev, MII_BMCR);
2160 return genphy_restart_aneg(phydev);
2168 * @phydev: target phy_device struct
2174 int genphy_aneg_done(struct phy_device *phydev)
2176 int retval = phy_read(phydev, MII_BMSR);
2183 * genphy_update_link - update link status in @phydev
2184 * @phydev: target phy_device struct
2186 * Description: Update the value in phydev->link to reflect the
2190 int genphy_update_link(struct phy_device *phydev)
2194 bmcr = phy_read(phydev, MII_BMCR);
2209 if (!phy_polling_mode(phydev) || !phydev->link) {
2210 status = phy_read(phydev, MII_BMSR);
2218 status = phy_read(phydev, MII_BMSR);
2222 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2223 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2228 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2229 phydev->link = 0;
2235 int genphy_read_lpa(struct phy_device *phydev)
2239 if (phydev->autoneg == AUTONEG_ENABLE) {
2240 if (!phydev->autoneg_complete) {
2241 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2243 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2247 if (phydev->is_gigabit_capable) {
2248 lpagb = phy_read(phydev, MII_STAT1000);
2253 int adv = phy_read(phydev, MII_CTRL1000);
2259 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2261 phydev_err(phydev, "Master/Slave resolution failed\n");
2265 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2269 lpa = phy_read(phydev, MII_LPA);
2273 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2275 linkmode_zero(phydev->lp_advertising);
2284 * @phydev: target phy_device struct
2289 int genphy_read_status_fixed(struct phy_device *phydev)
2291 int bmcr = phy_read(phydev, MII_BMCR);
2297 phydev->duplex = DUPLEX_FULL;
2299 phydev->duplex = DUPLEX_HALF;
2302 phydev->speed = SPEED_1000;
2304 phydev->speed = SPEED_100;
2306 phydev->speed = SPEED_10;
2314 * @phydev: target phy_device struct
2321 int genphy_read_status(struct phy_device *phydev)
2323 int err, old_link = phydev->link;
2326 err = genphy_update_link(phydev);
2331 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2334 phydev->speed = SPEED_UNKNOWN;
2335 phydev->duplex = DUPLEX_UNKNOWN;
2336 phydev->pause = 0;
2337 phydev->asym_pause = 0;
2339 err = genphy_read_master_slave(phydev);
2343 err = genphy_read_lpa(phydev);
2347 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2348 phy_resolve_aneg_linkmode(phydev);
2349 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2350 err = genphy_read_status_fixed(phydev);
2361 * @phydev: target phy_device struct
2367 int genphy_c37_read_status(struct phy_device *phydev)
2369 int lpa, err, old_link = phydev->link;
2372 err = genphy_update_link(phydev);
2377 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2380 phydev->duplex = DUPLEX_UNKNOWN;
2381 phydev->pause = 0;
2382 phydev->asym_pause = 0;
2384 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2385 lpa = phy_read(phydev, MII_LPA);
2390 phydev->lp_advertising, lpa & LPA_LPACK);
2392 phydev->lp_advertising, lpa & LPA_1000XFULL);
2394 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2396 phydev->lp_advertising,
2399 phy_resolve_aneg_linkmode(phydev);
2400 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2401 int bmcr = phy_read(phydev, MII_BMCR);
2407 phydev->duplex = DUPLEX_FULL;
2409 phydev->duplex = DUPLEX_HALF;
2418 * @phydev: target phy_device struct
2425 int genphy_soft_reset(struct phy_device *phydev)
2430 if (phydev->autoneg == AUTONEG_ENABLE)
2433 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2441 phydev->suspended = 0;
2443 ret = phy_poll_reset(phydev);
2448 if (phydev->autoneg == AUTONEG_DISABLE)
2449 ret = genphy_setup_forced(phydev);
2457 * @phydev: target phy_device struct
2460 * phydev->supported accordingly.
2464 int genphy_read_abilities(struct phy_device *phydev)
2470 phydev->supported);
2472 val = phy_read(phydev, MII_BMSR);
2476 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2479 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2481 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2483 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2485 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2489 val = phy_read(phydev, MII_ESTATUS);
2494 phydev->supported, val & ESTATUS_1000_TFULL);
2496 phydev->supported, val & ESTATUS_1000_THALF);
2498 phydev->supported, val & ESTATUS_1000_XFULL);
2522 int genphy_suspend(struct phy_device *phydev)
2524 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2528 int genphy_resume(struct phy_device *phydev)
2530 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2534 int genphy_loopback(struct phy_device *phydev, bool enable)
2536 return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
2543 * @phydev: phy_device structure to remove link mode from
2550 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2552 linkmode_clear_bit(link_mode, phydev->supported);
2553 phy_advertise_supported(phydev);
2567 * @phydev: target phy_device struct
2572 void phy_advertise_supported(struct phy_device *phydev)
2576 linkmode_copy(new, phydev->supported);
2577 phy_copy_pause_bits(new, phydev->advertising);
2578 linkmode_copy(phydev->advertising, new);
2584 * @phydev: target phy_device struct
2589 void phy_support_sym_pause(struct phy_device *phydev)
2591 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2592 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2598 * @phydev: target phy_device struct
2602 void phy_support_asym_pause(struct phy_device *phydev)
2604 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2610 * @phydev: target phy_device struct
2619 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2622 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2626 phydev->supported);
2628 linkmode_copy(phydev->advertising, phydev->supported);
2634 * @phydev: target phy_device struct
2643 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
2647 linkmode_copy(oldadv, phydev->advertising);
2648 linkmode_set_pause(phydev->advertising, tx, rx);
2650 if (!linkmode_equal(oldadv, phydev->advertising) &&
2651 phydev->autoneg)
2652 phy_start_aneg(phydev);
2658 * @phydev: phy_device struct
2665 bool phy_validate_pause(struct phy_device *phydev,
2669 phydev->supported) && pp->rx_pause)
2673 phydev->supported) &&
2683 * @phydev: phy_device struct
2693 void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
2695 if (phydev->duplex != DUPLEX_FULL) {
2701 return linkmode_resolve_pause(phydev->advertising,
2702 phydev->lp_advertising,
2728 * @phydev: phy_device struct
2742 s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev,
2751 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
2752 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
2761 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
2762 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
2776 phydev_err(phydev, "Delay %d is out of range\n", delay);
2798 phydev_err(phydev, "error finding internal delay index for %d\n",
2820 struct phy_device *phydev = to_phy_device(dev);
2821 struct device_driver *drv = phydev->mdio.dev.driver;
2825 phydev->drv = phydrv;
2830 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
2831 phydev->irq = PHY_POLL;
2834 phydev->is_internal = true;
2837 phy_device_reset(phydev, 0);
2839 if (phydev->drv->probe) {
2840 err = phydev->drv->probe(phydev);
2850 linkmode_copy(phydev->supported, phydrv->features);
2852 err = phydrv->get_features(phydev);
2853 } else if (phydev->is_c45) {
2854 err = genphy_c45_pma_read_abilities(phydev);
2856 err = genphy_read_abilities(phydev);
2863 phydev->supported))
2864 phydev->autoneg = 0;
2867 phydev->supported))
2868 phydev->is_gigabit_capable = 1;
2870 phydev->supported))
2871 phydev->is_gigabit_capable = 1;
2873 of_set_phy_supported(phydev);
2874 phy_advertise_supported(phydev);
2879 of_set_phy_eee_broken(phydev);
2892 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
2893 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
2895 phydev->supported);
2897 phydev->supported);
2901 phydev->state = PHY_READY;
2906 phy_device_reset(phydev, 1);
2913 struct phy_device *phydev = to_phy_device(dev);
2915 cancel_delayed_work_sync(&phydev->state_queue);
2917 phydev->state = PHY_DOWN;
2919 sfp_bus_del_upstream(phydev->sfp_bus);
2920 phydev->sfp_bus = NULL;
2922 if (phydev->drv && phydev->drv->remove)
2923 phydev->drv->remove(phydev);
2926 phy_device_reset(phydev, 1);
2928 phydev->drv = NULL;