Lines Matching defs:phydev
238 void phy_device_free(struct phy_device *phydev)
240 put_device(&phydev->mdio.dev);
246 struct phy_device *phydev;
248 phydev = container_of(mdiodev, struct phy_device, mdio);
249 phy_device_free(phydev);
260 struct phy_device *phydev;
262 phydev = container_of(mdiodev, struct phy_device, mdio);
263 phy_device_remove(phydev);
271 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
273 struct device_driver *drv = phydev->mdio.dev.driver;
275 struct net_device *netdev = phydev->attached_dev;
307 return !phydev->suspended;
312 struct phy_device *phydev = to_phy_device(dev);
314 if (phydev->mac_managed_pm)
321 if (phy_interrupt_is_valid(phydev)) {
322 phydev->irq_suspended = 1;
323 synchronize_irq(phydev->irq);
327 * control, possibly with the phydev->lock held. Upon resume, netdev
331 if (phydev->attached_dev && phydev->adjust_link)
332 phy_stop_machine(phydev);
334 if (!mdio_bus_phy_may_suspend(phydev))
337 phydev->suspended_by_mdio_bus = 1;
339 return phy_suspend(phydev);
344 struct phy_device *phydev = to_phy_device(dev);
347 if (phydev->mac_managed_pm)
350 if (!phydev->suspended_by_mdio_bus)
353 phydev->suspended_by_mdio_bus = 0;
360 WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY &&
361 phydev->state != PHY_UP);
363 ret = phy_init_hw(phydev);
367 ret = phy_resume(phydev);
371 if (phy_interrupt_is_valid(phydev)) {
372 phydev->irq_suspended = 0;
373 synchronize_irq(phydev->irq);
378 if (phydev->irq_rerun) {
379 phydev->irq_rerun = 0;
380 enable_irq(phydev->irq);
381 irq_wake_thread(phydev->irq, phydev);
385 if (phydev->attached_dev && phydev->adjust_link)
386 phy_start_machine(phydev);
396 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
397 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
399 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
486 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
489 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
491 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
495 if (!phy_id_compare(phydev->phy_id, fixup->phy_uid,
503 /* Runs any matching fixups for this phydev */
504 static int phy_scan_fixups(struct phy_device *phydev)
510 if (phy_needs_fixup(phydev, fixup)) {
511 int err = fixup->run(phydev);
517 phydev->has_fixups = true;
527 struct phy_device *phydev = to_phy_device(dev);
529 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
536 return phydrv->match_phy_device(phydev);
538 if (phydev->is_c45) {
540 if (phydev->c45_ids.device_ids[i] == 0xffffffff)
543 if (phy_id_compare(phydev->c45_ids.device_ids[i],
549 return phy_id_compare(phydev->phy_id, phydrv->phy_id,
557 struct phy_device *phydev = to_phy_device(dev);
559 return sysfs_emit(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
566 struct phy_device *phydev = to_phy_device(dev);
569 if (phy_is_internal(phydev))
572 mode = phy_modes(phydev->interface);
582 struct phy_device *phydev = to_phy_device(dev);
584 return sysfs_emit(buf, "%d\n", phydev->has_fixups);
592 struct phy_device *phydev = to_phy_device(dev);
594 return sysfs_emit(buf, "0x%08x\n", phydev->dev_flags);
981 * @phydev: phy_device structure to be added to the MDIO bus
983 int phy_device_register(struct phy_device *phydev)
987 err = mdiobus_register_device(&phydev->mdio);
992 phy_device_reset(phydev, 0);
995 err = phy_scan_fixups(phydev);
997 phydev_err(phydev, "failed to initialize\n");
1001 err = device_add(&phydev->mdio.dev);
1003 phydev_err(phydev, "failed to add\n");
1011 phy_device_reset(phydev, 1);
1013 mdiobus_unregister_device(&phydev->mdio);
1020 * @phydev: phy_device structure to remove
1026 void phy_device_remove(struct phy_device *phydev)
1028 unregister_mii_timestamper(phydev->mii_ts);
1029 pse_control_put(phydev->psec);
1031 device_del(&phydev->mdio.dev);
1034 phy_device_reset(phydev, 1);
1036 mdiobus_unregister_device(&phydev->mdio);
1042 * @phydev: phy_device structure to read 802.3-c45 IDs
1047 int phy_get_c45_ids(struct phy_device *phydev)
1049 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr,
1050 &phydev->c45_ids);
1060 struct phy_device *phydev;
1064 phydev = mdiobus_get_phy(bus, addr);
1065 if (phydev)
1066 return phydev;
1072 static void phy_link_change(struct phy_device *phydev, bool up)
1074 struct net_device *netdev = phydev->attached_dev;
1080 phydev->adjust_link(netdev);
1081 if (phydev->mii_ts && phydev->mii_ts->link_state)
1082 phydev->mii_ts->link_state(phydev->mii_ts, phydev);
1087 * @phydev: target phy_device struct
1097 static void phy_prepare_link(struct phy_device *phydev,
1100 phydev->adjust_link = handler;
1106 * @phydev: the pointer to the phy device
1110 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
1119 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1123 phy_prepare_link(phydev, handler);
1124 if (phy_interrupt_is_valid(phydev))
1125 phy_request_interrupt(phydev);
1150 struct phy_device *phydev;
1162 phydev = to_phy_device(d);
1164 rc = phy_connect_direct(dev, phydev, handler, interface);
1169 return phydev;
1176 * @phydev: target phy_device struct
1178 void phy_disconnect(struct phy_device *phydev)
1180 if (phy_is_started(phydev))
1181 phy_stop(phydev);
1183 if (phy_interrupt_is_valid(phydev))
1184 phy_free_interrupt(phydev);
1186 phydev->adjust_link = NULL;
1188 phy_detach(phydev);
1194 * @phydev: The PHY device to poll
1210 static int phy_poll_reset(struct phy_device *phydev)
1215 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
1226 int phy_init_hw(struct phy_device *phydev)
1231 phy_device_reset(phydev, 0);
1233 if (!phydev->drv)
1236 if (phydev->drv->soft_reset) {
1237 ret = phydev->drv->soft_reset(phydev);
1240 phydev->suspended = 0;
1246 ret = phy_scan_fixups(phydev);
1250 if (phydev->drv->config_init) {
1251 ret = phydev->drv->config_init(phydev);
1256 if (phydev->drv->config_intr) {
1257 ret = phydev->drv->config_intr(phydev);
1266 void phy_attached_info(struct phy_device *phydev)
1268 phy_attached_print(phydev, NULL);
1273 char *phy_attached_info_irq(struct phy_device *phydev)
1278 switch(phydev->irq) {
1286 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1295 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1297 const char *unbound = phydev->drv ? "" : "[unbound] ";
1298 char *irq_str = phy_attached_info_irq(phydev);
1301 phydev_info(phydev, ATTACHED_FMT "\n", unbound,
1302 phydev_name(phydev), irq_str);
1306 phydev_info(phydev, ATTACHED_FMT, unbound,
1307 phydev_name(phydev), irq_str);
1317 static void phy_sysfs_create_links(struct phy_device *phydev)
1319 struct net_device *dev = phydev->attached_dev;
1325 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1331 &phydev->mdio.dev.kobj,
1332 "phydev");
1335 kobject_name(&phydev->mdio.dev.kobj),
1342 phydev->sysfs_links = true;
1349 struct phy_device *phydev = to_phy_device(dev);
1351 return sysfs_emit(buf, "%d\n", !phydev->attached_dev);
1364 struct phy_device *phydev = upstream;
1366 if (phydev->attached_dev)
1367 phydev->attached_dev->sfp_bus = bus;
1368 phydev->sfp_bus_attached = true;
1381 struct phy_device *phydev = upstream;
1383 if (phydev->attached_dev)
1384 phydev->attached_dev->sfp_bus = NULL;
1385 phydev->sfp_bus_attached = false;
1391 * @phydev: Pointer to phy_device
1394 int phy_sfp_probe(struct phy_device *phydev,
1400 if (phydev->mdio.dev.fwnode) {
1401 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1405 phydev->sfp_bus = bus;
1407 ret = sfp_bus_add_upstream(bus, phydev, ops);
1417 * @phydev: Pointer to phy_device to attach
1429 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1432 struct mii_bus *bus = phydev->mdio.bus;
1433 struct device *d = &phydev->mdio.dev;
1446 phydev_err(phydev, "failed to get the bus module\n");
1456 if (phydev->is_c45)
1465 phydev_err(phydev, "failed to get the device driver module\n");
1479 if (phydev->attached_dev) {
1485 phydev->phy_link_change = phy_link_change;
1487 phydev->attached_dev = dev;
1488 dev->phydev = phydev;
1490 if (phydev->sfp_bus_attached)
1491 dev->sfp_bus = phydev->sfp_bus;
1502 phydev->sysfs_links = false;
1504 phy_sysfs_create_links(phydev);
1506 if (!phydev->attached_dev) {
1507 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1510 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1513 phydev->dev_flags |= flags;
1515 phydev->interface = interface;
1517 phydev->state = PHY_READY;
1519 phydev->interrupts = PHY_INTERRUPT_DISABLED;
1525 if (phydev->dev_flags & PHY_F_NO_IRQ)
1526 phydev->irq = PHY_POLL;
1534 phydev->port = PORT_MII;
1540 netif_carrier_off(phydev->attached_dev);
1546 err = phy_init_hw(phydev);
1550 phy_resume(phydev);
1551 if (!phydev->is_on_sfp_module)
1552 phy_led_triggers_register(phydev);
1559 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent)
1560 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev,
1567 phy_detach(phydev);
1594 struct phy_device *phydev;
1609 phydev = to_phy_device(d);
1611 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1616 return phydev;
1620 static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1623 struct device *d = &phydev->mdio.dev;
1626 if (!phydev->drv)
1636 bool phy_driver_is_genphy(struct phy_device *phydev)
1638 return phy_driver_is_genphy_kind(phydev,
1643 bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1645 return phy_driver_is_genphy_kind(phydev,
1652 * @phydev: target phy_device struct
1668 * This will set the shared pointer of the phydev to the shared storage.
1676 int phy_package_join(struct phy_device *phydev, int addr, size_t priv_size)
1678 struct mii_bus *bus = phydev->mdio.bus;
1709 phydev->shared = shared;
1723 * @phydev: target phy_device struct
1725 * This leaves a PHY group created by phy_package_join(). If this phydev
1727 * freed. Resets the phydev->shared pointer to NULL.
1729 void phy_package_leave(struct phy_device *phydev)
1731 struct phy_package_shared *shared = phydev->shared;
1732 struct mii_bus *bus = phydev->mdio.bus;
1744 phydev->shared = NULL;
1756 * @phydev: target phy_device struct
1764 int devm_phy_package_join(struct device *dev, struct phy_device *phydev,
1775 ret = phy_package_join(phydev, addr, priv_size);
1778 *ptr = phydev;
1790 * @phydev: target phy_device struct
1795 void phy_detach(struct phy_device *phydev)
1797 struct net_device *dev = phydev->attached_dev;
1801 if (phydev->devlink)
1802 device_link_del(phydev->devlink);
1804 if (phydev->sysfs_links) {
1806 sysfs_remove_link(&dev->dev.kobj, "phydev");
1807 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1810 if (!phydev->attached_dev)
1811 sysfs_remove_file(&phydev->mdio.dev.kobj,
1814 phy_suspend(phydev);
1816 phydev->attached_dev->phydev = NULL;
1817 phydev->attached_dev = NULL;
1819 phydev->phylink = NULL;
1821 if (!phydev->is_on_sfp_module)
1822 phy_led_triggers_unregister(phydev);
1824 if (phydev->mdio.dev.driver)
1825 module_put(phydev->mdio.dev.driver->owner);
1832 if (phy_driver_is_genphy(phydev) ||
1833 phy_driver_is_genphy_10g(phydev))
1834 device_release_driver(&phydev->mdio.dev);
1837 phy_device_reset(phydev, 1);
1840 * The phydev might go away on the put_device() below, so avoid
1843 bus = phydev->mdio.bus;
1845 put_device(&phydev->mdio.dev);
1853 int phy_suspend(struct phy_device *phydev)
1856 struct net_device *netdev = phydev->attached_dev;
1857 struct phy_driver *phydrv = phydev->drv;
1860 if (phydev->suspended)
1863 phy_ethtool_get_wol(phydev, &wol);
1864 phydev->wol_enabled = wol.wolopts || (netdev && netdev->wol_enabled);
1866 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND))
1872 ret = phydrv->suspend(phydev);
1874 phydev->suspended = true;
1880 int __phy_resume(struct phy_device *phydev)
1882 struct phy_driver *phydrv = phydev->drv;
1885 lockdep_assert_held(&phydev->lock);
1890 ret = phydrv->resume(phydev);
1892 phydev->suspended = false;
1898 int phy_resume(struct phy_device *phydev)
1902 mutex_lock(&phydev->lock);
1903 ret = __phy_resume(phydev);
1904 mutex_unlock(&phydev->lock);
1910 int phy_loopback(struct phy_device *phydev, bool enable)
1914 if (!phydev->drv)
1917 mutex_lock(&phydev->lock);
1919 if (enable && phydev->loopback_enabled) {
1924 if (!enable && !phydev->loopback_enabled) {
1929 if (phydev->drv->set_loopback)
1930 ret = phydev->drv->set_loopback(phydev, enable);
1932 ret = genphy_loopback(phydev, enable);
1937 phydev->loopback_enabled = enable;
1940 mutex_unlock(&phydev->lock);
1947 * @phydev: target phy_device struct
1954 int phy_reset_after_clk_enable(struct phy_device *phydev)
1956 if (!phydev || !phydev->drv)
1959 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1960 phy_device_reset(phydev, 1);
1961 phy_device_reset(phydev, 0);
1973 * @phydev: target phy_device struct
1980 static int genphy_config_advert(struct phy_device *phydev)
1986 linkmode_and(phydev->advertising, phydev->advertising,
1987 phydev->supported);
1989 adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1992 err = phy_modify_changed(phydev, MII_ADVERTISE,
2001 bmsr = phy_read(phydev, MII_BMSR);
2012 adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
2014 err = phy_modify_changed(phydev, MII_CTRL1000,
2027 * @phydev: target phy_device struct
2035 static int genphy_c37_config_advert(struct phy_device *phydev)
2040 linkmode_and(phydev->advertising, phydev->advertising,
2041 phydev->supported);
2044 phydev->advertising))
2047 phydev->advertising))
2050 phydev->advertising))
2053 return phy_modify_changed(phydev, MII_ADVERTISE,
2061 * @phydev: target phy_device struct
2067 int genphy_config_eee_advert(struct phy_device *phydev)
2072 if (!phydev->eee_broken_modes)
2075 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
2076 phydev->eee_broken_modes, 0);
2083 * genphy_setup_forced - configures/forces speed/duplex from @phydev
2084 * @phydev: target phy_device struct
2087 * to the values in phydev. Assumes that the values are valid.
2090 int genphy_setup_forced(struct phy_device *phydev)
2094 phydev->pause = 0;
2095 phydev->asym_pause = 0;
2097 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2099 return phy_modify(phydev, MII_BMCR,
2104 static int genphy_setup_master_slave(struct phy_device *phydev)
2108 if (!phydev->is_gigabit_capable)
2111 switch (phydev->master_slave_set) {
2127 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
2131 return phy_modify_changed(phydev, MII_CTRL1000,
2136 int genphy_read_master_slave(struct phy_device *phydev)
2141 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2142 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2144 val = phy_read(phydev, MII_CTRL1000);
2160 val = phy_read(phydev, MII_STAT1000);
2166 } else if (phydev->link) {
2176 phydev->master_slave_get = cfg;
2177 phydev->master_slave_state = state;
2185 * @phydev: target phy_device struct
2187 int genphy_restart_aneg(struct phy_device *phydev)
2190 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2197 * @phydev: target phy_device struct
2202 int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2210 ret = phy_read(phydev, MII_BMCR);
2219 return genphy_restart_aneg(phydev);
2227 * @phydev: target phy_device struct
2234 int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2238 err = genphy_c45_an_config_eee_aneg(phydev);
2244 err = genphy_setup_master_slave(phydev);
2250 if (AUTONEG_ENABLE != phydev->autoneg)
2251 return genphy_setup_forced(phydev);
2253 err = genphy_config_advert(phydev);
2259 return genphy_check_and_restart_aneg(phydev, changed);
2265 * @phydev: target phy_device struct
2272 int genphy_c37_config_aneg(struct phy_device *phydev)
2276 if (phydev->autoneg != AUTONEG_ENABLE)
2277 return genphy_setup_forced(phydev);
2279 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2284 changed = genphy_c37_config_advert(phydev);
2292 int ctl = phy_read(phydev, MII_BMCR);
2305 return genphy_restart_aneg(phydev);
2313 * @phydev: target phy_device struct
2319 int genphy_aneg_done(struct phy_device *phydev)
2321 int retval = phy_read(phydev, MII_BMSR);
2328 * genphy_update_link - update link status in @phydev
2329 * @phydev: target phy_device struct
2331 * Description: Update the value in phydev->link to reflect the
2335 int genphy_update_link(struct phy_device *phydev)
2339 bmcr = phy_read(phydev, MII_BMCR);
2354 if (!phy_polling_mode(phydev) || !phydev->link) {
2355 status = phy_read(phydev, MII_BMSR);
2363 status = phy_read(phydev, MII_BMSR);
2367 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2368 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2373 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2374 phydev->link = 0;
2380 int genphy_read_lpa(struct phy_device *phydev)
2384 if (phydev->autoneg == AUTONEG_ENABLE) {
2385 if (!phydev->autoneg_complete) {
2386 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2388 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2392 if (phydev->is_gigabit_capable) {
2393 lpagb = phy_read(phydev, MII_STAT1000);
2398 int adv = phy_read(phydev, MII_CTRL1000);
2404 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2406 phydev_err(phydev, "Master/Slave resolution failed\n");
2410 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2414 lpa = phy_read(phydev, MII_LPA);
2418 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2420 linkmode_zero(phydev->lp_advertising);
2429 * @phydev: target phy_device struct
2434 int genphy_read_status_fixed(struct phy_device *phydev)
2436 int bmcr = phy_read(phydev, MII_BMCR);
2442 phydev->duplex = DUPLEX_FULL;
2444 phydev->duplex = DUPLEX_HALF;
2447 phydev->speed = SPEED_1000;
2449 phydev->speed = SPEED_100;
2451 phydev->speed = SPEED_10;
2459 * @phydev: target phy_device struct
2466 int genphy_read_status(struct phy_device *phydev)
2468 int err, old_link = phydev->link;
2471 err = genphy_update_link(phydev);
2476 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2479 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
2480 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2481 phydev->speed = SPEED_UNKNOWN;
2482 phydev->duplex = DUPLEX_UNKNOWN;
2483 phydev->pause = 0;
2484 phydev->asym_pause = 0;
2486 if (phydev->is_gigabit_capable) {
2487 err = genphy_read_master_slave(phydev);
2492 err = genphy_read_lpa(phydev);
2496 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2497 phy_resolve_aneg_linkmode(phydev);
2498 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2499 err = genphy_read_status_fixed(phydev);
2510 * @phydev: target phy_device struct
2516 int genphy_c37_read_status(struct phy_device *phydev)
2518 int lpa, err, old_link = phydev->link;
2521 err = genphy_update_link(phydev);
2526 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2529 phydev->duplex = DUPLEX_UNKNOWN;
2530 phydev->pause = 0;
2531 phydev->asym_pause = 0;
2533 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2534 lpa = phy_read(phydev, MII_LPA);
2539 phydev->lp_advertising, lpa & LPA_LPACK);
2541 phydev->lp_advertising, lpa & LPA_1000XFULL);
2543 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2545 phydev->lp_advertising,
2548 phy_resolve_aneg_linkmode(phydev);
2549 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2550 int bmcr = phy_read(phydev, MII_BMCR);
2556 phydev->duplex = DUPLEX_FULL;
2558 phydev->duplex = DUPLEX_HALF;
2567 * @phydev: target phy_device struct
2574 int genphy_soft_reset(struct phy_device *phydev)
2579 if (phydev->autoneg == AUTONEG_ENABLE)
2582 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2590 phydev->suspended = 0;
2592 ret = phy_poll_reset(phydev);
2597 if (phydev->autoneg == AUTONEG_DISABLE)
2598 ret = genphy_setup_forced(phydev);
2604 irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
2611 phy_trigger_machine(phydev);
2619 * @phydev: target phy_device struct
2622 * phydev->supported accordingly.
2626 int genphy_read_abilities(struct phy_device *phydev)
2632 phydev->supported);
2634 val = phy_read(phydev, MII_BMSR);
2638 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2641 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2643 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2645 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2647 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2651 val = phy_read(phydev, MII_ESTATUS);
2656 phydev->supported, val & ESTATUS_1000_TFULL);
2658 phydev->supported, val & ESTATUS_1000_THALF);
2660 phydev->supported, val & ESTATUS_1000_XFULL);
2666 genphy_c45_read_eee_abilities(phydev);
2689 int genphy_suspend(struct phy_device *phydev)
2691 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2695 int genphy_resume(struct phy_device *phydev)
2697 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2701 int genphy_loopback(struct phy_device *phydev, bool enable)
2707 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2709 phy_modify(phydev, MII_BMCR, ~0, ctl);
2711 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,
2717 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
2719 phy_config_aneg(phydev);
2728 * @phydev: phy_device structure to remove link mode from
2735 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2737 linkmode_clear_bit(link_mode, phydev->supported);
2738 phy_advertise_supported(phydev);
2752 * @phydev: target phy_device struct
2757 void phy_advertise_supported(struct phy_device *phydev)
2761 linkmode_copy(new, phydev->supported);
2762 phy_copy_pause_bits(new, phydev->advertising);
2763 linkmode_copy(phydev->advertising, new);
2769 * @phydev: target phy_device struct
2774 void phy_support_sym_pause(struct phy_device *phydev)
2776 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2777 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2783 * @phydev: target phy_device struct
2787 void phy_support_asym_pause(struct phy_device *phydev)
2789 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2795 * @phydev: target phy_device struct
2804 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2807 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2811 phydev->supported);
2813 linkmode_copy(phydev->advertising, phydev->supported);
2819 * @phydev: target phy_device struct
2828 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
2832 linkmode_copy(oldadv, phydev->advertising);
2833 linkmode_set_pause(phydev->advertising, tx, rx);
2835 if (!linkmode_equal(oldadv, phydev->advertising) &&
2836 phydev->autoneg)
2837 phy_start_aneg(phydev);
2843 * @phydev: phy_device struct
2850 bool phy_validate_pause(struct phy_device *phydev,
2854 phydev->supported) && pp->rx_pause)
2858 phydev->supported) &&
2868 * @phydev: phy_device struct
2878 void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
2880 if (phydev->duplex != DUPLEX_FULL) {
2886 return linkmode_resolve_pause(phydev->advertising,
2887 phydev->lp_advertising,
2913 * @phydev: phy_device struct
2927 s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev,
2936 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
2937 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
2946 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
2947 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
2961 phydev_err(phydev, "Delay %d is out of range\n", delay);
2983 phydev_err(phydev, "error finding internal delay index for %d\n",
2999 struct phy_device *phydev = phyled->phydev;
3002 mutex_lock(&phydev->lock);
3003 err = phydev->drv->led_brightness_set(phydev, phyled->index, value);
3004 mutex_unlock(&phydev->lock);
3014 struct phy_device *phydev = phyled->phydev;
3017 mutex_lock(&phydev->lock);
3018 err = phydev->drv->led_blink_set(phydev, phyled->index,
3020 mutex_unlock(&phydev->lock);
3029 struct phy_device *phydev = phyled->phydev;
3031 if (phydev->attached_dev)
3032 return &phydev->attached_dev->dev;
3041 struct phy_device *phydev = phyled->phydev;
3044 mutex_lock(&phydev->lock);
3045 err = phydev->drv->led_hw_control_get(phydev, phyled->index, rules);
3046 mutex_unlock(&phydev->lock);
3056 struct phy_device *phydev = phyled->phydev;
3059 mutex_lock(&phydev->lock);
3060 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules);
3061 mutex_unlock(&phydev->lock);
3070 struct phy_device *phydev = phyled->phydev;
3073 mutex_lock(&phydev->lock);
3074 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules);
3075 mutex_unlock(&phydev->lock);
3080 static void phy_leds_unregister(struct phy_device *phydev)
3084 list_for_each_entry(phyled, &phydev->leds, list) {
3089 static int of_phy_led(struct phy_device *phydev,
3092 struct device *dev = &phydev->mdio.dev;
3104 phyled->phydev = phydev;
3113 if (phydev->drv->led_brightness_set)
3115 if (phydev->drv->led_blink_set)
3119 if (phydev->drv->led_hw_is_supported &&
3120 phydev->drv->led_hw_control_set &&
3121 phydev->drv->led_hw_control_get) {
3131 init_data.devicename = dev_name(&phydev->mdio.dev);
3139 list_add(&phyled->list, &phydev->leds);
3144 static int of_phy_leds(struct phy_device *phydev)
3146 struct device_node *node = phydev->mdio.dev.of_node;
3161 err = of_phy_led(phydev, led);
3164 phy_leds_unregister(phydev);
3264 struct phy_device *phydev = to_phy_device(dev);
3265 struct device_driver *drv = phydev->mdio.dev.driver;
3269 phydev->drv = phydrv;
3274 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
3275 phydev->irq = PHY_POLL;
3278 phydev->is_internal = true;
3281 phy_device_reset(phydev, 0);
3283 if (phydev->drv->probe) {
3284 err = phydev->drv->probe(phydev);
3289 phy_disable_interrupts(phydev);
3296 linkmode_copy(phydev->supported, phydrv->features);
3297 genphy_c45_read_eee_abilities(phydev);
3300 err = phydrv->get_features(phydev);
3301 else if (phydev->is_c45)
3302 err = genphy_c45_pma_read_abilities(phydev);
3304 err = genphy_read_abilities(phydev);
3310 phydev->supported))
3311 phydev->autoneg = 0;
3314 phydev->supported))
3315 phydev->is_gigabit_capable = 1;
3317 phydev->supported))
3318 phydev->is_gigabit_capable = 1;
3320 of_set_phy_supported(phydev);
3321 phy_advertise_supported(phydev);
3326 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee);
3333 phydev->eee_enabled = !linkmode_empty(phydev->advertising_eee);
3338 if (phydev->eee_enabled)
3339 linkmode_and(phydev->advertising_eee, phydev->supported_eee,
3340 phydev->advertising_eee);
3345 of_set_phy_eee_broken(phydev);
3358 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
3359 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
3361 phydev->supported);
3363 phydev->supported);
3367 phydev->state = PHY_READY;
3373 err = of_phy_leds(phydev);
3378 phy_device_reset(phydev, 1);
3385 struct phy_device *phydev = to_phy_device(dev);
3387 cancel_delayed_work_sync(&phydev->state_queue);
3390 phy_leds_unregister(phydev);
3392 phydev->state = PHY_DOWN;
3394 sfp_bus_del_upstream(phydev->sfp_bus);
3395 phydev->sfp_bus = NULL;
3397 if (phydev->drv && phydev->drv->remove)
3398 phydev->drv->remove(phydev);
3401 phy_device_reset(phydev, 1);
3403 phydev->drv = NULL;
3429 * make out-of-bounds accesses and lockup in phydev->lock.