Lines Matching defs:phydev
61 static void phy_process_state_change(struct phy_device *phydev,
64 if (old_state != phydev->state) {
65 phydev_dbg(phydev, "PHY state change %s -> %s\n",
67 phy_state_to_str(phydev->state));
68 if (phydev->drv && phydev->drv->link_change_notify)
69 phydev->drv->link_change_notify(phydev);
73 static void phy_link_up(struct phy_device *phydev)
75 phydev->phy_link_change(phydev, true);
76 phy_led_trigger_change_speed(phydev);
79 static void phy_link_down(struct phy_device *phydev)
81 phydev->phy_link_change(phydev, false);
82 phy_led_trigger_change_speed(phydev);
83 WRITE_ONCE(phydev->link_down_events, phydev->link_down_events + 1);
86 static const char *phy_pause_str(struct phy_device *phydev)
90 if (phydev->autoneg == AUTONEG_DISABLE)
94 phydev->advertising);
96 phydev->advertising);
98 if (local_pause && phydev->pause)
101 if (local_asym_pause && phydev->asym_pause) {
104 if (phydev->pause)
114 * @phydev: the phy_device struct
116 void phy_print_status(struct phy_device *phydev)
118 if (phydev->link) {
119 netdev_info(phydev->attached_dev,
121 phy_speed_to_str(phydev->speed),
122 phy_duplex_to_str(phydev->duplex),
123 phydev->downshifted_rate ? "(downshifted) " : "",
124 phy_pause_str(phydev));
126 netdev_info(phydev->attached_dev, "Link is Down\n");
133 * @phydev: The phy device to return rate matching for
143 int phy_get_rate_matching(struct phy_device *phydev,
148 if (phydev->drv->get_rate_matching) {
149 mutex_lock(&phydev->lock);
150 ret = phydev->drv->get_rate_matching(phydev, iface);
151 mutex_unlock(&phydev->lock);
160 * @phydev: the phy_device struct
161 * @interrupts: interrupt flags to configure for this @phydev
165 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
167 phydev->interrupts = interrupts ? 1 : 0;
168 if (phydev->drv->config_intr)
169 return phydev->drv->config_intr(phydev);
176 * @phydev: target phy_device struct
178 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
181 int phy_restart_aneg(struct phy_device *phydev)
185 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
186 ret = genphy_c45_restart_aneg(phydev);
188 ret = genphy_restart_aneg(phydev);
196 * @phydev: target phy_device struct
198 * Description: Return the auto-negotiation status from this @phydev
202 int phy_aneg_done(struct phy_device *phydev)
204 if (phydev->drv && phydev->drv->aneg_done)
205 return phydev->drv->aneg_done(phydev);
206 else if (phydev->is_c45)
207 return genphy_c45_aneg_done(phydev);
209 return genphy_aneg_done(phydev);
266 * @phydev: the target phy_device struct
272 static void phy_sanitize_settings(struct phy_device *phydev)
276 setting = phy_find_valid(phydev->speed, phydev->duplex,
277 phydev->supported);
279 phydev->speed = setting->speed;
280 phydev->duplex = setting->duplex;
283 phydev->speed = SPEED_UNKNOWN;
284 phydev->duplex = DUPLEX_UNKNOWN;
288 void phy_ethtool_ksettings_get(struct phy_device *phydev,
291 mutex_lock(&phydev->lock);
292 linkmode_copy(cmd->link_modes.supported, phydev->supported);
293 linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
294 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
296 cmd->base.speed = phydev->speed;
297 cmd->base.duplex = phydev->duplex;
298 cmd->base.master_slave_cfg = phydev->master_slave_get;
299 cmd->base.master_slave_state = phydev->master_slave_state;
300 cmd->base.rate_matching = phydev->rate_matching;
301 if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
304 cmd->base.port = phydev->port;
305 cmd->base.transceiver = phy_is_internal(phydev) ?
307 cmd->base.phy_address = phydev->mdio.addr;
308 cmd->base.autoneg = phydev->autoneg;
309 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
310 cmd->base.eth_tp_mdix = phydev->mdix;
311 mutex_unlock(&phydev->lock);
317 * @phydev: the phy_device struct
325 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
334 mii_data->phy_id = phydev->mdio.addr;
342 phydev->mdio.bus, prtad, devad,
346 phydev->mdio.bus, mii_data->phy_id,
359 if (prtad == phydev->mdio.addr) {
363 if (phydev->autoneg == AUTONEG_ENABLE)
365 phydev->autoneg = AUTONEG_DISABLE;
367 phydev->duplex = DUPLEX_FULL;
369 phydev->duplex = DUPLEX_HALF;
371 phydev->speed = SPEED_1000;
373 phydev->speed = SPEED_100;
374 else phydev->speed = SPEED_10;
376 if (phydev->autoneg == AUTONEG_DISABLE)
378 phydev->autoneg = AUTONEG_ENABLE;
382 mii_adv_mod_linkmode_adv_t(phydev->advertising,
387 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
398 mdiobus_c45_write(phydev->mdio.bus, prtad, devad,
401 mdiobus_write(phydev->mdio.bus, prtad, devad, val);
403 if (prtad == phydev->mdio.addr &&
406 return phy_init_hw(phydev);
409 return phy_start_aneg(phydev);
414 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
415 return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
432 if (!dev->phydev)
435 return phy_mii_ioctl(dev->phydev, ifr, cmd);
461 * @phydev: the PHY device structure
466 int __phy_hwtstamp_get(struct phy_device *phydev,
469 if (!phydev)
472 return phy_mii_ioctl(phydev, config->ifr, SIOCGHWTSTAMP);
478 * @phydev: the PHY device structure
482 int __phy_hwtstamp_set(struct phy_device *phydev,
486 if (!phydev)
489 return phy_mii_ioctl(phydev, config->ifr, SIOCSHWTSTAMP);
495 * @phydev: the phy_device struct
498 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
500 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
508 * @phydev: the phy_device struct
510 void phy_trigger_machine(struct phy_device *phydev)
512 phy_queue_state_machine(phydev, 0);
516 static void phy_abort_cable_test(struct phy_device *phydev)
520 ethnl_cable_test_finished(phydev);
522 err = phy_init_hw(phydev);
524 phydev_err(phydev, "Error while aborting cable test");
530 * @phydev: the phy_device struct
533 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
535 if (!phydev->drv)
538 mutex_lock(&phydev->lock);
539 phydev->drv->get_strings(phydev, data);
540 mutex_unlock(&phydev->lock);
549 * @phydev: the phy_device struct
551 int phy_ethtool_get_sset_count(struct phy_device *phydev)
555 if (!phydev->drv)
558 if (phydev->drv->get_sset_count &&
559 phydev->drv->get_strings &&
560 phydev->drv->get_stats) {
561 mutex_lock(&phydev->lock);
562 ret = phydev->drv->get_sset_count(phydev);
563 mutex_unlock(&phydev->lock);
575 * @phydev: the phy_device struct
579 int phy_ethtool_get_stats(struct phy_device *phydev,
582 if (!phydev->drv)
585 mutex_lock(&phydev->lock);
586 phydev->drv->get_stats(phydev, stats, data);
587 mutex_unlock(&phydev->lock);
595 * @phydev: the phy_device struct
601 int phy_ethtool_get_plca_cfg(struct phy_device *phydev,
606 if (!phydev->drv) {
611 if (!phydev->drv->get_plca_cfg) {
616 mutex_lock(&phydev->lock);
617 ret = phydev->drv->get_plca_cfg(phydev, plca_cfg);
619 mutex_unlock(&phydev->lock);
626 * @phydev: the phy_device struct
634 static int plca_check_valid(struct phy_device *phydev,
641 phydev->advertising)) {
655 * @phydev: the phy_device struct
662 int phy_ethtool_set_plca_cfg(struct phy_device *phydev,
669 if (!phydev->drv) {
674 if (!phydev->drv->set_plca_cfg ||
675 !phydev->drv->get_plca_cfg) {
686 mutex_lock(&phydev->lock);
688 ret = phydev->drv->get_plca_cfg(phydev, curr_plca_cfg);
740 ret = plca_check_valid(phydev, curr_plca_cfg, extack);
745 ret = phydev->drv->set_plca_cfg(phydev, plca_cfg);
749 mutex_unlock(&phydev->lock);
756 * @phydev: the phy_device struct
762 int phy_ethtool_get_plca_status(struct phy_device *phydev,
767 if (!phydev->drv) {
772 if (!phydev->drv->get_plca_status) {
777 mutex_lock(&phydev->lock);
778 ret = phydev->drv->get_plca_status(phydev, plca_st);
780 mutex_unlock(&phydev->lock);
788 * @phydev: the phy_device struct
791 int phy_start_cable_test(struct phy_device *phydev,
794 struct net_device *dev = phydev->attached_dev;
797 if (!(phydev->drv &&
798 phydev->drv->cable_test_start &&
799 phydev->drv->cable_test_get_status)) {
805 mutex_lock(&phydev->lock);
806 if (phydev->state == PHY_CABLETEST) {
813 if (phydev->state < PHY_UP ||
814 phydev->state > PHY_CABLETEST) {
821 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
826 phy_link_down(phydev);
829 err = phydev->drv->cable_test_start(phydev);
832 phy_link_up(phydev);
836 phydev->state = PHY_CABLETEST;
838 if (phy_polling_mode(phydev))
839 phy_trigger_machine(phydev);
841 mutex_unlock(&phydev->lock);
846 ethnl_cable_test_free(phydev);
848 mutex_unlock(&phydev->lock);
857 * @phydev: the phy_device struct
861 int phy_start_cable_test_tdr(struct phy_device *phydev,
865 struct net_device *dev = phydev->attached_dev;
868 if (!(phydev->drv &&
869 phydev->drv->cable_test_tdr_start &&
870 phydev->drv->cable_test_get_status)) {
876 mutex_lock(&phydev->lock);
877 if (phydev->state == PHY_CABLETEST) {
884 if (phydev->state < PHY_UP ||
885 phydev->state > PHY_CABLETEST) {
892 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
897 phy_link_down(phydev);
900 err = phydev->drv->cable_test_tdr_start(phydev, config);
903 phy_link_up(phydev);
907 phydev->state = PHY_CABLETEST;
909 if (phy_polling_mode(phydev))
910 phy_trigger_machine(phydev);
912 mutex_unlock(&phydev->lock);
917 ethnl_cable_test_free(phydev);
919 mutex_unlock(&phydev->lock);
925 int phy_config_aneg(struct phy_device *phydev)
927 if (phydev->drv->config_aneg)
928 return phydev->drv->config_aneg(phydev);
933 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
934 return genphy_c45_config_aneg(phydev);
936 return genphy_config_aneg(phydev);
942 * @phydev: the phy_device struct
947 static int phy_check_link_status(struct phy_device *phydev)
951 lockdep_assert_held(&phydev->lock);
956 if (phydev->loopback_enabled)
959 err = phy_read_status(phydev);
963 if (phydev->link && phydev->state != PHY_RUNNING) {
964 phy_check_downshift(phydev);
965 phydev->state = PHY_RUNNING;
966 phy_link_up(phydev);
967 } else if (!phydev->link && phydev->state != PHY_NOLINK) {
968 phydev->state = PHY_NOLINK;
969 phy_link_down(phydev);
977 * @phydev: the phy_device struct
984 static int _phy_start_aneg(struct phy_device *phydev)
988 lockdep_assert_held(&phydev->lock);
990 if (!phydev->drv)
993 if (AUTONEG_DISABLE == phydev->autoneg)
994 phy_sanitize_settings(phydev);
996 err = phy_config_aneg(phydev);
1000 if (phy_is_started(phydev))
1001 err = phy_check_link_status(phydev);
1008 * @phydev: the phy_device struct
1015 int phy_start_aneg(struct phy_device *phydev)
1019 mutex_lock(&phydev->lock);
1020 err = _phy_start_aneg(phydev);
1021 mutex_unlock(&phydev->lock);
1027 static int phy_poll_aneg_done(struct phy_device *phydev)
1034 ret = phy_aneg_done(phydev);
1043 int phy_ethtool_ksettings_set(struct phy_device *phydev,
1051 if (cmd->base.phy_address != phydev->mdio.addr)
1057 linkmode_and(advertising, advertising, phydev->supported);
1074 mutex_lock(&phydev->lock);
1075 phydev->autoneg = autoneg;
1078 phydev->speed = speed;
1079 phydev->duplex = duplex;
1082 linkmode_copy(phydev->advertising, advertising);
1085 phydev->advertising, autoneg == AUTONEG_ENABLE);
1087 phydev->master_slave_set = cmd->base.master_slave_cfg;
1088 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
1091 if (phy_is_started(phydev)) {
1092 phydev->state = PHY_UP;
1093 phy_trigger_machine(phydev);
1095 _phy_start_aneg(phydev);
1098 mutex_unlock(&phydev->lock);
1105 * @phydev: the phy_device struct
1116 int phy_speed_down(struct phy_device *phydev, bool sync)
1121 mutex_lock(&phydev->lock);
1123 if (phydev->autoneg != AUTONEG_ENABLE)
1126 linkmode_copy(adv_tmp, phydev->advertising);
1128 ret = phy_speed_down_core(phydev);
1132 linkmode_copy(phydev->adv_old, adv_tmp);
1134 if (linkmode_equal(phydev->advertising, adv_tmp)) {
1139 ret = phy_config_aneg(phydev);
1143 ret = sync ? phy_poll_aneg_done(phydev) : 0;
1145 mutex_unlock(&phydev->lock);
1153 * @phydev: the phy_device struct
1157 int phy_speed_up(struct phy_device *phydev)
1162 mutex_lock(&phydev->lock);
1164 if (phydev->autoneg != AUTONEG_ENABLE)
1167 if (linkmode_empty(phydev->adv_old))
1170 linkmode_copy(adv_tmp, phydev->advertising);
1171 linkmode_copy(phydev->advertising, phydev->adv_old);
1172 linkmode_zero(phydev->adv_old);
1174 if (linkmode_equal(phydev->advertising, adv_tmp))
1177 ret = phy_config_aneg(phydev);
1179 mutex_unlock(&phydev->lock);
1187 * @phydev: the phy_device struct
1195 void phy_start_machine(struct phy_device *phydev)
1197 phy_trigger_machine(phydev);
1203 * @phydev: target phy_device struct
1209 void phy_stop_machine(struct phy_device *phydev)
1211 cancel_delayed_work_sync(&phydev->state_queue);
1213 mutex_lock(&phydev->lock);
1214 if (phy_is_started(phydev))
1215 phydev->state = PHY_UP;
1216 mutex_unlock(&phydev->lock);
1219 static void phy_process_error(struct phy_device *phydev)
1221 /* phydev->lock must be held for the state change to be safe */
1222 if (!mutex_is_locked(&phydev->lock))
1223 phydev_err(phydev, "PHY-device data unsafe context\n");
1225 phydev->state = PHY_ERROR;
1227 phy_trigger_machine(phydev);
1230 static void phy_error_precise(struct phy_device *phydev,
1234 mutex_lock(&phydev->lock);
1235 phy_process_error(phydev);
1236 mutex_unlock(&phydev->lock);
1241 * @phydev: target phy_device struct
1245 * Must be called with phydev->lock held.
1247 void phy_error(struct phy_device *phydev)
1250 phy_process_error(phydev);
1256 * @phydev: target phy_device struct
1258 int phy_disable_interrupts(struct phy_device *phydev)
1261 return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
1273 struct phy_device *phydev = phy_dat;
1274 struct phy_driver *drv = phydev->drv;
1280 if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {
1281 struct net_device *netdev = phydev->attached_dev;
1294 phydev->irq_rerun = 1;
1299 mutex_lock(&phydev->lock);
1300 ret = drv->handle_interrupt(phydev);
1301 mutex_unlock(&phydev->lock);
1308 * @phydev: target phy_device struct
1310 static int phy_enable_interrupts(struct phy_device *phydev)
1312 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
1317 * @phydev: target phy_device struct
1323 void phy_request_interrupt(struct phy_device *phydev)
1327 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
1329 phydev_name(phydev), phydev);
1331 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
1332 err, phydev->irq);
1333 phydev->irq = PHY_POLL;
1335 if (phy_enable_interrupts(phydev)) {
1336 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1337 phy_free_interrupt(phydev);
1338 phydev->irq = PHY_POLL;
1346 * @phydev: target phy_device struct
1351 void phy_free_interrupt(struct phy_device *phydev)
1353 phy_disable_interrupts(phydev);
1354 free_irq(phydev->irq, phydev);
1360 * @phydev: target phy_device struct
1362 void phy_stop(struct phy_device *phydev)
1364 struct net_device *dev = phydev->attached_dev;
1367 if (!phy_is_started(phydev) && phydev->state != PHY_DOWN &&
1368 phydev->state != PHY_ERROR) {
1370 phy_state_to_str(phydev->state));
1374 mutex_lock(&phydev->lock);
1375 old_state = phydev->state;
1377 if (phydev->state == PHY_CABLETEST) {
1378 phy_abort_cable_test(phydev);
1382 if (phydev->sfp_bus)
1383 sfp_upstream_stop(phydev->sfp_bus);
1385 phydev->state = PHY_HALTED;
1386 phy_process_state_change(phydev, old_state);
1388 mutex_unlock(&phydev->lock);
1390 phy_state_machine(&phydev->state_queue.work);
1391 phy_stop_machine(phydev);
1402 * @phydev: target phy_device struct
1410 void phy_start(struct phy_device *phydev)
1412 mutex_lock(&phydev->lock);
1414 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1416 phy_state_to_str(phydev->state));
1420 if (phydev->sfp_bus)
1421 sfp_upstream_start(phydev->sfp_bus);
1424 __phy_resume(phydev);
1426 phydev->state = PHY_UP;
1428 phy_start_machine(phydev);
1430 mutex_unlock(&phydev->lock);
1441 struct phy_device *phydev =
1443 struct net_device *dev = phydev->attached_dev;
1450 mutex_lock(&phydev->lock);
1452 old_state = phydev->state;
1454 switch (phydev->state) {
1464 err = phy_check_link_status(phydev);
1468 err = phydev->drv->cable_test_get_status(phydev, &finished);
1470 phy_abort_cable_test(phydev);
1473 phydev->state = PHY_UP;
1478 ethnl_cable_test_finished(phydev);
1481 phydev->state = PHY_UP;
1486 if (phydev->link) {
1487 phydev->link = 0;
1488 phy_link_down(phydev);
1494 mutex_unlock(&phydev->lock);
1497 err = phy_start_aneg(phydev);
1500 phy_suspend(phydev);
1507 phy_error_precise(phydev, func, err);
1509 phy_process_state_change(phydev, old_state);
1519 mutex_lock(&phydev->lock);
1520 if (phy_polling_mode(phydev) && phy_is_started(phydev))
1521 phy_queue_state_machine(phydev, PHY_STATE_TIME);
1522 mutex_unlock(&phydev->lock);
1527 * @phydev: phy_device struct with changed link
1532 void phy_mac_interrupt(struct phy_device *phydev)
1535 phy_trigger_machine(phydev);
1541 * @phydev: target phy_device struct
1549 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1553 if (!phydev->drv)
1556 ret = genphy_c45_eee_is_active(phydev, NULL, NULL, NULL);
1566 ret = phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1575 * @phydev: target phy_device struct
1580 int phy_get_eee_err(struct phy_device *phydev)
1584 if (!phydev->drv)
1587 mutex_lock(&phydev->lock);
1588 ret = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1589 mutex_unlock(&phydev->lock);
1597 * @phydev: target phy_device struct
1603 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1607 if (!phydev->drv)
1610 mutex_lock(&phydev->lock);
1611 ret = genphy_c45_ethtool_get_eee(phydev, data);
1612 mutex_unlock(&phydev->lock);
1620 * @phydev: target phy_device struct
1625 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1629 if (!phydev->drv)
1632 mutex_lock(&phydev->lock);
1633 ret = genphy_c45_ethtool_set_eee(phydev, data);
1634 mutex_unlock(&phydev->lock);
1643 * @phydev: target phy_device struct
1646 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1650 if (phydev->drv && phydev->drv->set_wol) {
1651 mutex_lock(&phydev->lock);
1652 ret = phydev->drv->set_wol(phydev, wol);
1653 mutex_unlock(&phydev->lock);
1665 * @phydev: target phy_device struct
1668 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1670 if (phydev->drv && phydev->drv->get_wol) {
1671 mutex_lock(&phydev->lock);
1672 phydev->drv->get_wol(phydev, wol);
1673 mutex_unlock(&phydev->lock);
1681 struct phy_device *phydev = ndev->phydev;
1683 if (!phydev)
1686 phy_ethtool_ksettings_get(phydev, cmd);
1695 struct phy_device *phydev = ndev->phydev;
1697 if (!phydev)
1700 return phy_ethtool_ksettings_set(phydev, cmd);
1710 struct phy_device *phydev = ndev->phydev;
1713 if (!phydev)
1716 if (!phydev->drv)
1719 mutex_lock(&phydev->lock);
1720 ret = phy_restart_aneg(phydev);
1721 mutex_unlock(&phydev->lock);