Lines Matching defs:phydev
249 void phy_device_free(struct phy_device *phydev)
251 put_device(&phydev->mdio.dev);
257 struct phy_device *phydev;
259 phydev = container_of(mdiodev, struct phy_device, mdio);
260 phy_device_free(phydev);
271 struct phy_device *phydev;
273 phydev = container_of(mdiodev, struct phy_device, mdio);
274 phy_device_remove(phydev);
282 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
284 struct device_driver *drv = phydev->mdio.dev.driver;
286 struct net_device *netdev = phydev->attached_dev;
318 return !phydev->suspended;
323 struct phy_device *phydev = to_phy_device(dev);
325 if (phydev->mac_managed_pm)
332 if (phy_interrupt_is_valid(phydev)) {
333 phydev->irq_suspended = 1;
334 synchronize_irq(phydev->irq);
338 * control, possibly with the phydev->lock held. Upon resume, netdev
342 if (phydev->attached_dev && phydev->adjust_link)
343 phy_stop_machine(phydev);
345 if (!mdio_bus_phy_may_suspend(phydev))
348 phydev->suspended_by_mdio_bus = 1;
350 return phy_suspend(phydev);
355 struct phy_device *phydev = to_phy_device(dev);
358 if (phydev->mac_managed_pm)
361 if (!phydev->suspended_by_mdio_bus)
364 phydev->suspended_by_mdio_bus = 0;
371 WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY &&
372 phydev->state != PHY_UP);
374 ret = phy_init_hw(phydev);
378 ret = phy_resume(phydev);
382 if (phy_interrupt_is_valid(phydev)) {
383 phydev->irq_suspended = 0;
384 synchronize_irq(phydev->irq);
389 if (phydev->irq_rerun) {
390 phydev->irq_rerun = 0;
391 enable_irq(phydev->irq);
392 irq_wake_thread(phydev->irq, phydev);
396 if (phydev->attached_dev && phydev->adjust_link)
397 phy_start_machine(phydev);
407 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
408 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
410 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
497 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
500 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
502 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
506 if (!phy_id_compare(phydev->phy_id, fixup->phy_uid,
514 /* Runs any matching fixups for this phydev */
515 static int phy_scan_fixups(struct phy_device *phydev)
521 if (phy_needs_fixup(phydev, fixup)) {
522 int err = fixup->run(phydev);
528 phydev->has_fixups = true;
538 struct phy_device *phydev = to_phy_device(dev);
540 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
547 return phydrv->match_phy_device(phydev);
549 if (phydev->is_c45) {
551 if (phydev->c45_ids.device_ids[i] == 0xffffffff)
554 if (phy_id_compare(phydev->c45_ids.device_ids[i],
560 return phy_id_compare(phydev->phy_id, phydrv->phy_id,
568 struct phy_device *phydev = to_phy_device(dev);
570 return sysfs_emit(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
577 struct phy_device *phydev = to_phy_device(dev);
580 if (phy_is_internal(phydev))
583 mode = phy_modes(phydev->interface);
593 struct phy_device *phydev = to_phy_device(dev);
595 return sysfs_emit(buf, "%d\n", phydev->has_fixups);
603 struct phy_device *phydev = to_phy_device(dev);
605 return sysfs_emit(buf, "0x%08x\n", phydev->dev_flags);
997 * @phydev: phy_device structure to be added to the MDIO bus
999 int phy_device_register(struct phy_device *phydev)
1003 err = mdiobus_register_device(&phydev->mdio);
1008 phy_device_reset(phydev, 0);
1011 err = phy_scan_fixups(phydev);
1013 phydev_err(phydev, "failed to initialize\n");
1017 err = device_add(&phydev->mdio.dev);
1019 phydev_err(phydev, "failed to add\n");
1027 phy_device_reset(phydev, 1);
1029 mdiobus_unregister_device(&phydev->mdio);
1036 * @phydev: phy_device structure to remove
1042 void phy_device_remove(struct phy_device *phydev)
1044 unregister_mii_timestamper(phydev->mii_ts);
1045 pse_control_put(phydev->psec);
1047 device_del(&phydev->mdio.dev);
1050 phy_device_reset(phydev, 1);
1052 mdiobus_unregister_device(&phydev->mdio);
1058 * @phydev: phy_device structure to read 802.3-c45 IDs
1063 int phy_get_c45_ids(struct phy_device *phydev)
1065 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr,
1066 &phydev->c45_ids);
1076 struct phy_device *phydev;
1080 phydev = mdiobus_get_phy(bus, addr);
1081 if (phydev)
1082 return phydev;
1088 static void phy_link_change(struct phy_device *phydev, bool up)
1090 struct net_device *netdev = phydev->attached_dev;
1096 phydev->adjust_link(netdev);
1097 if (phydev->mii_ts && phydev->mii_ts->link_state)
1098 phydev->mii_ts->link_state(phydev->mii_ts, phydev);
1103 * @phydev: target phy_device struct
1113 static void phy_prepare_link(struct phy_device *phydev,
1116 phydev->adjust_link = handler;
1122 * @phydev: the pointer to the phy device
1126 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
1135 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1139 phy_prepare_link(phydev, handler);
1140 if (phy_interrupt_is_valid(phydev))
1141 phy_request_interrupt(phydev);
1166 struct phy_device *phydev;
1178 phydev = to_phy_device(d);
1180 rc = phy_connect_direct(dev, phydev, handler, interface);
1185 return phydev;
1192 * @phydev: target phy_device struct
1194 void phy_disconnect(struct phy_device *phydev)
1196 if (phy_is_started(phydev))
1197 phy_stop(phydev);
1199 if (phy_interrupt_is_valid(phydev))
1200 phy_free_interrupt(phydev);
1202 phydev->adjust_link = NULL;
1204 phy_detach(phydev);
1210 * @phydev: The PHY device to poll
1226 static int phy_poll_reset(struct phy_device *phydev)
1231 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
1242 int phy_init_hw(struct phy_device *phydev)
1247 phy_device_reset(phydev, 0);
1249 if (!phydev->drv)
1252 if (phydev->drv->soft_reset) {
1253 ret = phydev->drv->soft_reset(phydev);
1258 phydev->suspended = 0;
1261 ret = phy_scan_fixups(phydev);
1265 phy_interface_zero(phydev->possible_interfaces);
1267 if (phydev->drv->config_init) {
1268 ret = phydev->drv->config_init(phydev);
1273 if (phydev->drv->config_intr) {
1274 ret = phydev->drv->config_intr(phydev);
1283 void phy_attached_info(struct phy_device *phydev)
1285 phy_attached_print(phydev, NULL);
1290 char *phy_attached_info_irq(struct phy_device *phydev)
1295 switch(phydev->irq) {
1303 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1312 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1314 const char *unbound = phydev->drv ? "" : "[unbound] ";
1315 char *irq_str = phy_attached_info_irq(phydev);
1318 phydev_info(phydev, ATTACHED_FMT "\n", unbound,
1319 phydev_name(phydev), irq_str);
1323 phydev_info(phydev, ATTACHED_FMT, unbound,
1324 phydev_name(phydev), irq_str);
1334 static void phy_sysfs_create_links(struct phy_device *phydev)
1336 struct net_device *dev = phydev->attached_dev;
1342 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1348 &phydev->mdio.dev.kobj,
1349 "phydev");
1352 kobject_name(&phydev->mdio.dev.kobj),
1359 phydev->sysfs_links = true;
1366 struct phy_device *phydev = to_phy_device(dev);
1368 return sysfs_emit(buf, "%d\n", !phydev->attached_dev);
1381 struct phy_device *phydev = upstream;
1383 if (phydev->attached_dev)
1384 phydev->attached_dev->sfp_bus = bus;
1385 phydev->sfp_bus_attached = true;
1398 struct phy_device *phydev = upstream;
1400 if (phydev->attached_dev)
1401 phydev->attached_dev->sfp_bus = NULL;
1402 phydev->sfp_bus_attached = false;
1408 * @phydev: Pointer to phy_device
1411 int phy_sfp_probe(struct phy_device *phydev,
1417 if (phydev->mdio.dev.fwnode) {
1418 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1422 phydev->sfp_bus = bus;
1424 ret = sfp_bus_add_upstream(bus, phydev, ops);
1439 * @phydev: Pointer to phy_device to attach
1451 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1454 struct mii_bus *bus = phydev->mdio.bus;
1455 struct device *d = &phydev->mdio.dev;
1468 phydev_err(phydev, "failed to get the bus module\n");
1478 if (phydev->is_c45)
1487 phydev_err(phydev, "failed to get the device driver module\n");
1501 if (phydev->attached_dev) {
1507 phydev->phy_link_change = phy_link_change;
1509 phydev->attached_dev = dev;
1510 dev->phydev = phydev;
1512 if (phydev->sfp_bus_attached)
1513 dev->sfp_bus = phydev->sfp_bus;
1524 phydev->sysfs_links = false;
1526 phy_sysfs_create_links(phydev);
1528 if (!phydev->attached_dev) {
1529 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1532 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1535 phydev->dev_flags |= flags;
1537 phydev->interface = interface;
1539 phydev->state = PHY_READY;
1541 phydev->interrupts = PHY_INTERRUPT_DISABLED;
1547 if (phydev->dev_flags & PHY_F_NO_IRQ)
1548 phydev->irq = PHY_POLL;
1550 if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev))
1551 phydev->irq = PHY_POLL;
1559 phydev->port = PORT_MII;
1565 netif_carrier_off(phydev->attached_dev);
1571 err = phy_init_hw(phydev);
1575 phy_resume(phydev);
1576 if (!phydev->is_on_sfp_module)
1577 phy_led_triggers_register(phydev);
1584 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent)
1585 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev,
1592 phy_detach(phydev);
1618 struct phy_device *phydev;
1633 phydev = to_phy_device(d);
1635 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1640 return phydev;
1644 static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1647 struct device *d = &phydev->mdio.dev;
1650 if (!phydev->drv)
1660 bool phy_driver_is_genphy(struct phy_device *phydev)
1662 return phy_driver_is_genphy_kind(phydev,
1667 bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1669 return phy_driver_is_genphy_kind(phydev,
1676 * @phydev: target phy_device struct
1694 * This will set the shared pointer of the phydev to the shared storage.
1702 int phy_package_join(struct phy_device *phydev, int base_addr, size_t priv_size)
1704 struct mii_bus *bus = phydev->mdio.bus;
1736 phydev->shared = shared;
1750 * @phydev: target phy_device struct
1755 * The parent node of the @phydev is checked as a valid PHY package node
1768 int of_phy_package_join(struct phy_device *phydev, size_t priv_size)
1770 struct device_node *node = phydev->mdio.dev.of_node;
1792 ret = phy_package_join(phydev, base_addr, priv_size);
1796 phydev->shared->np = package_node;
1807 * @phydev: target phy_device struct
1809 * This leaves a PHY group created by phy_package_join(). If this phydev
1811 * freed. Resets the phydev->shared pointer to NULL.
1813 void phy_package_leave(struct phy_device *phydev)
1815 struct phy_package_shared *shared = phydev->shared;
1816 struct mii_bus *bus = phydev->mdio.bus;
1832 phydev->shared = NULL;
1844 * @phydev: target phy_device struct
1853 int devm_phy_package_join(struct device *dev, struct phy_device *phydev,
1864 ret = phy_package_join(phydev, base_addr, priv_size);
1867 *ptr = phydev;
1880 * @phydev: target phy_device struct
1887 int devm_of_phy_package_join(struct device *dev, struct phy_device *phydev,
1898 ret = of_phy_package_join(phydev, priv_size);
1901 *ptr = phydev;
1913 * @phydev: target phy_device struct
1918 void phy_detach(struct phy_device *phydev)
1920 struct net_device *dev = phydev->attached_dev;
1924 if (phydev->devlink)
1925 device_link_del(phydev->devlink);
1927 if (phydev->sysfs_links) {
1929 sysfs_remove_link(&dev->dev.kobj, "phydev");
1930 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1933 if (!phydev->attached_dev)
1934 sysfs_remove_file(&phydev->mdio.dev.kobj,
1937 phy_suspend(phydev);
1939 phydev->attached_dev->phydev = NULL;
1940 phydev->attached_dev = NULL;
1942 phydev->phylink = NULL;
1944 if (!phydev->is_on_sfp_module)
1945 phy_led_triggers_unregister(phydev);
1947 if (phydev->mdio.dev.driver)
1948 module_put(phydev->mdio.dev.driver->owner);
1955 if (phy_driver_is_genphy(phydev) ||
1956 phy_driver_is_genphy_10g(phydev))
1957 device_release_driver(&phydev->mdio.dev);
1960 phy_device_reset(phydev, 1);
1963 * The phydev might go away on the put_device() below, so avoid
1966 bus = phydev->mdio.bus;
1968 put_device(&phydev->mdio.dev);
1976 int phy_suspend(struct phy_device *phydev)
1979 struct net_device *netdev = phydev->attached_dev;
1980 const struct phy_driver *phydrv = phydev->drv;
1983 if (phydev->suspended)
1986 phy_ethtool_get_wol(phydev, &wol);
1987 phydev->wol_enabled = wol.wolopts || (netdev && netdev->wol_enabled);
1989 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND))
1995 ret = phydrv->suspend(phydev);
1997 phydev->suspended = true;
2003 int __phy_resume(struct phy_device *phydev)
2005 const struct phy_driver *phydrv = phydev->drv;
2008 lockdep_assert_held(&phydev->lock);
2013 ret = phydrv->resume(phydev);
2015 phydev->suspended = false;
2021 int phy_resume(struct phy_device *phydev)
2025 mutex_lock(&phydev->lock);
2026 ret = __phy_resume(phydev);
2027 mutex_unlock(&phydev->lock);
2033 int phy_loopback(struct phy_device *phydev, bool enable)
2037 if (!phydev->drv)
2040 mutex_lock(&phydev->lock);
2042 if (enable && phydev->loopback_enabled) {
2047 if (!enable && !phydev->loopback_enabled) {
2052 if (phydev->drv->set_loopback)
2053 ret = phydev->drv->set_loopback(phydev, enable);
2055 ret = genphy_loopback(phydev, enable);
2060 phydev->loopback_enabled = enable;
2063 mutex_unlock(&phydev->lock);
2070 * @phydev: target phy_device struct
2077 int phy_reset_after_clk_enable(struct phy_device *phydev)
2079 if (!phydev || !phydev->drv)
2082 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
2083 phy_device_reset(phydev, 1);
2084 phy_device_reset(phydev, 0);
2096 * @phydev: target phy_device struct
2103 static int genphy_config_advert(struct phy_device *phydev)
2109 linkmode_and(phydev->advertising, phydev->advertising,
2110 phydev->supported);
2112 adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
2115 err = phy_modify_changed(phydev, MII_ADVERTISE,
2124 bmsr = phy_read(phydev, MII_BMSR);
2135 adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
2137 err = phy_modify_changed(phydev, MII_CTRL1000,
2150 * @phydev: target phy_device struct
2158 static int genphy_c37_config_advert(struct phy_device *phydev)
2163 linkmode_and(phydev->advertising, phydev->advertising,
2164 phydev->supported);
2167 phydev->advertising))
2170 phydev->advertising))
2173 phydev->advertising))
2176 return phy_modify_changed(phydev, MII_ADVERTISE,
2184 * @phydev: target phy_device struct
2190 int genphy_config_eee_advert(struct phy_device *phydev)
2195 if (!phydev->eee_broken_modes)
2198 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
2199 phydev->eee_broken_modes, 0);
2206 * genphy_setup_forced - configures/forces speed/duplex from @phydev
2207 * @phydev: target phy_device struct
2210 * to the values in phydev. Assumes that the values are valid.
2213 int genphy_setup_forced(struct phy_device *phydev)
2217 phydev->pause = 0;
2218 phydev->asym_pause = 0;
2220 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2222 return phy_modify(phydev, MII_BMCR,
2227 static int genphy_setup_master_slave(struct phy_device *phydev)
2231 if (!phydev->is_gigabit_capable)
2234 switch (phydev->master_slave_set) {
2250 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
2254 return phy_modify_changed(phydev, MII_CTRL1000,
2259 int genphy_read_master_slave(struct phy_device *phydev)
2264 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2265 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2267 val = phy_read(phydev, MII_CTRL1000);
2283 val = phy_read(phydev, MII_STAT1000);
2289 } else if (phydev->link) {
2299 phydev->master_slave_get = cfg;
2300 phydev->master_slave_state = state;
2308 * @phydev: target phy_device struct
2310 int genphy_restart_aneg(struct phy_device *phydev)
2313 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2320 * @phydev: target phy_device struct
2325 int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2333 ret = phy_read(phydev, MII_BMCR);
2342 return genphy_restart_aneg(phydev);
2350 * @phydev: target phy_device struct
2357 int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2361 err = genphy_c45_an_config_eee_aneg(phydev);
2367 err = genphy_setup_master_slave(phydev);
2373 if (AUTONEG_ENABLE != phydev->autoneg)
2374 return genphy_setup_forced(phydev);
2376 err = genphy_config_advert(phydev);
2382 return genphy_check_and_restart_aneg(phydev, changed);
2388 * @phydev: target phy_device struct
2395 int genphy_c37_config_aneg(struct phy_device *phydev)
2399 if (phydev->autoneg != AUTONEG_ENABLE)
2400 return genphy_setup_forced(phydev);
2402 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2407 changed = genphy_c37_config_advert(phydev);
2415 int ctl = phy_read(phydev, MII_BMCR);
2428 return genphy_restart_aneg(phydev);
2436 * @phydev: target phy_device struct
2442 int genphy_aneg_done(struct phy_device *phydev)
2444 int retval = phy_read(phydev, MII_BMSR);
2451 * genphy_update_link - update link status in @phydev
2452 * @phydev: target phy_device struct
2454 * Description: Update the value in phydev->link to reflect the
2458 int genphy_update_link(struct phy_device *phydev)
2462 bmcr = phy_read(phydev, MII_BMCR);
2477 if (!phy_polling_mode(phydev) || !phydev->link) {
2478 status = phy_read(phydev, MII_BMSR);
2486 status = phy_read(phydev, MII_BMSR);
2490 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2491 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2496 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2497 phydev->link = 0;
2503 int genphy_read_lpa(struct phy_device *phydev)
2507 if (phydev->autoneg == AUTONEG_ENABLE) {
2508 if (!phydev->autoneg_complete) {
2509 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2511 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2515 if (phydev->is_gigabit_capable) {
2516 lpagb = phy_read(phydev, MII_STAT1000);
2521 int adv = phy_read(phydev, MII_CTRL1000);
2527 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2529 phydev_err(phydev, "Master/Slave resolution failed\n");
2533 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2537 lpa = phy_read(phydev, MII_LPA);
2541 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2543 linkmode_zero(phydev->lp_advertising);
2552 * @phydev: target phy_device struct
2557 int genphy_read_status_fixed(struct phy_device *phydev)
2559 int bmcr = phy_read(phydev, MII_BMCR);
2565 phydev->duplex = DUPLEX_FULL;
2567 phydev->duplex = DUPLEX_HALF;
2570 phydev->speed = SPEED_1000;
2572 phydev->speed = SPEED_100;
2574 phydev->speed = SPEED_10;
2582 * @phydev: target phy_device struct
2589 int genphy_read_status(struct phy_device *phydev)
2591 int err, old_link = phydev->link;
2594 err = genphy_update_link(phydev);
2599 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2602 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
2603 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2604 phydev->speed = SPEED_UNKNOWN;
2605 phydev->duplex = DUPLEX_UNKNOWN;
2606 phydev->pause = 0;
2607 phydev->asym_pause = 0;
2609 if (phydev->is_gigabit_capable) {
2610 err = genphy_read_master_slave(phydev);
2615 err = genphy_read_lpa(phydev);
2619 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2620 phy_resolve_aneg_linkmode(phydev);
2621 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2622 err = genphy_read_status_fixed(phydev);
2633 * @phydev: target phy_device struct
2642 int genphy_c37_read_status(struct phy_device *phydev, bool *changed)
2644 int lpa, err, old_link = phydev->link;
2647 err = genphy_update_link(phydev);
2652 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) {
2659 phydev->duplex = DUPLEX_UNKNOWN;
2660 phydev->pause = 0;
2661 phydev->asym_pause = 0;
2663 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2664 lpa = phy_read(phydev, MII_LPA);
2669 phydev->lp_advertising, lpa & LPA_LPACK);
2671 phydev->lp_advertising, lpa & LPA_1000XFULL);
2673 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2675 phydev->lp_advertising,
2678 phy_resolve_aneg_linkmode(phydev);
2679 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2680 int bmcr = phy_read(phydev, MII_BMCR);
2686 phydev->duplex = DUPLEX_FULL;
2688 phydev->duplex = DUPLEX_HALF;
2697 * @phydev: target phy_device struct
2704 int genphy_soft_reset(struct phy_device *phydev)
2709 if (phydev->autoneg == AUTONEG_ENABLE)
2712 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2720 phydev->suspended = 0;
2722 ret = phy_poll_reset(phydev);
2727 if (phydev->autoneg == AUTONEG_DISABLE)
2728 ret = genphy_setup_forced(phydev);
2734 irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
2741 phy_trigger_machine(phydev);
2749 * @phydev: target phy_device struct
2752 * phydev->supported accordingly.
2756 int genphy_read_abilities(struct phy_device *phydev)
2762 phydev->supported);
2764 val = phy_read(phydev, MII_BMSR);
2768 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2771 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2773 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2775 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2777 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2781 val = phy_read(phydev, MII_ESTATUS);
2786 phydev->supported, val & ESTATUS_1000_TFULL);
2788 phydev->supported, val & ESTATUS_1000_THALF);
2790 phydev->supported, val & ESTATUS_1000_XFULL);
2796 genphy_c45_read_eee_abilities(phydev);
2819 int genphy_suspend(struct phy_device *phydev)
2821 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2825 int genphy_resume(struct phy_device *phydev)
2827 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2831 int genphy_loopback(struct phy_device *phydev, bool enable)
2837 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2839 phy_modify(phydev, MII_BMCR, ~0, ctl);
2841 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,
2847 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
2849 phy_config_aneg(phydev);
2858 * @phydev: phy_device structure to remove link mode from
2865 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2867 linkmode_clear_bit(link_mode, phydev->supported);
2868 phy_advertise_supported(phydev);
2882 * @phydev: target phy_device struct
2887 void phy_advertise_supported(struct phy_device *phydev)
2891 linkmode_copy(new, phydev->supported);
2892 phy_copy_pause_bits(new, phydev->advertising);
2893 linkmode_copy(phydev->advertising, new);
2899 * @phydev: target phy_device struct
2907 void phy_advertise_eee_all(struct phy_device *phydev)
2909 linkmode_copy(phydev->advertising_eee, phydev->supported_eee);
2915 * @phydev: Target phy_device struct
2933 void phy_support_eee(struct phy_device *phydev)
2935 linkmode_copy(phydev->advertising_eee, phydev->supported_eee);
2936 phydev->eee_cfg.tx_lpi_enabled = true;
2937 phydev->eee_cfg.eee_enabled = true;
2943 * @phydev: target phy_device struct
2948 void phy_support_sym_pause(struct phy_device *phydev)
2950 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2951 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2957 * @phydev: target phy_device struct
2961 void phy_support_asym_pause(struct phy_device *phydev)
2963 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2969 * @phydev: target phy_device struct
2978 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2981 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2985 phydev->supported);
2987 linkmode_copy(phydev->advertising, phydev->supported);
2993 * @phydev: target phy_device struct
3002 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
3006 linkmode_copy(oldadv, phydev->advertising);
3007 linkmode_set_pause(phydev->advertising, tx, rx);
3009 if (!linkmode_equal(oldadv, phydev->advertising) &&
3010 phydev->autoneg)
3011 phy_start_aneg(phydev);
3017 * @phydev: phy_device struct
3024 bool phy_validate_pause(struct phy_device *phydev,
3028 phydev->supported) && pp->rx_pause)
3032 phydev->supported) &&
3042 * @phydev: phy_device struct
3052 void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
3054 if (phydev->duplex != DUPLEX_FULL) {
3060 return linkmode_resolve_pause(phydev->advertising,
3061 phydev->lp_advertising,
3087 * @phydev: phy_device struct
3101 s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev,
3110 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3111 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
3120 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3121 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
3135 phydev_err(phydev, "Delay %d is out of range\n", delay);
3157 phydev_err(phydev, "error finding internal delay index for %d\n",
3168 struct phy_device *phydev = phyled->phydev;
3171 mutex_lock(&phydev->lock);
3172 err = phydev->drv->led_brightness_set(phydev, phyled->index, value);
3173 mutex_unlock(&phydev->lock);
3183 struct phy_device *phydev = phyled->phydev;
3186 mutex_lock(&phydev->lock);
3187 err = phydev->drv->led_blink_set(phydev, phyled->index,
3189 mutex_unlock(&phydev->lock);
3198 struct phy_device *phydev = phyled->phydev;
3200 if (phydev->attached_dev)
3201 return &phydev->attached_dev->dev;
3210 struct phy_device *phydev = phyled->phydev;
3213 mutex_lock(&phydev->lock);
3214 err = phydev->drv->led_hw_control_get(phydev, phyled->index, rules);
3215 mutex_unlock(&phydev->lock);
3225 struct phy_device *phydev = phyled->phydev;
3228 mutex_lock(&phydev->lock);
3229 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules);
3230 mutex_unlock(&phydev->lock);
3239 struct phy_device *phydev = phyled->phydev;
3242 mutex_lock(&phydev->lock);
3243 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules);
3244 mutex_unlock(&phydev->lock);
3249 static void phy_leds_unregister(struct phy_device *phydev)
3253 list_for_each_entry(phyled, &phydev->leds, list) {
3258 static int of_phy_led(struct phy_device *phydev,
3261 struct device *dev = &phydev->mdio.dev;
3274 phyled->phydev = phydev;
3289 if (!phydev->drv->led_polarity_set)
3292 err = phydev->drv->led_polarity_set(phydev, index, modes);
3298 if (phydev->drv->led_brightness_set)
3300 if (phydev->drv->led_blink_set)
3304 if (phydev->drv->led_hw_is_supported &&
3305 phydev->drv->led_hw_control_set &&
3306 phydev->drv->led_hw_control_get) {
3316 init_data.devicename = dev_name(&phydev->mdio.dev);
3324 list_add(&phyled->list, &phydev->leds);
3329 static int of_phy_leds(struct phy_device *phydev)
3331 struct device_node *node = phydev->mdio.dev.of_node;
3346 err = of_phy_led(phydev, led);
3349 phy_leds_unregister(phydev);
3449 struct phy_device *phydev = to_phy_device(dev);
3450 struct device_driver *drv = phydev->mdio.dev.driver;
3454 phydev->drv = phydrv;
3459 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
3460 phydev->irq = PHY_POLL;
3463 phydev->is_internal = true;
3466 phy_device_reset(phydev, 0);
3468 if (phydev->drv->probe) {
3469 err = phydev->drv->probe(phydev);
3474 phy_disable_interrupts(phydev);
3481 linkmode_copy(phydev->supported, phydrv->features);
3482 genphy_c45_read_eee_abilities(phydev);
3485 err = phydrv->get_features(phydev);
3486 else if (phydev->is_c45)
3487 err = genphy_c45_pma_read_abilities(phydev);
3489 err = genphy_read_abilities(phydev);
3495 phydev->supported))
3496 phydev->autoneg = 0;
3499 phydev->supported))
3500 phydev->is_gigabit_capable = 1;
3502 phydev->supported))
3503 phydev->is_gigabit_capable = 1;
3505 of_set_phy_supported(phydev);
3506 phy_advertise_supported(phydev);
3511 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee);
3518 phydev->eee_enabled = !linkmode_empty(phydev->advertising_eee);
3523 if (phydev->eee_enabled)
3524 linkmode_and(phydev->advertising_eee, phydev->supported_eee,
3525 phydev->advertising_eee);
3530 of_set_phy_eee_broken(phydev);
3543 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
3544 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
3546 phydev->supported);
3548 phydev->supported);
3552 phydev->state = PHY_READY;
3558 err = of_phy_leds(phydev);
3563 phy_device_reset(phydev, 1);
3570 struct phy_device *phydev = to_phy_device(dev);
3572 cancel_delayed_work_sync(&phydev->state_queue);
3575 phy_leds_unregister(phydev);
3577 phydev->state = PHY_DOWN;
3579 sfp_bus_del_upstream(phydev->sfp_bus);
3580 phydev->sfp_bus = NULL;
3582 if (phydev->drv && phydev->drv->remove)
3583 phydev->drv->remove(phydev);
3586 phy_device_reset(phydev, 1);
3588 phydev->drv = NULL;
3614 * make out-of-bounds accesses and lockup in phydev->lock.