Lines Matching defs:phydev
59 static void phy_process_state_change(struct phy_device *phydev,
62 if (old_state != phydev->state) {
63 phydev_dbg(phydev, "PHY state change %s -> %s\n",
65 phy_state_to_str(phydev->state));
66 if (phydev->drv && phydev->drv->link_change_notify)
67 phydev->drv->link_change_notify(phydev);
71 static void phy_link_up(struct phy_device *phydev)
73 phydev->phy_link_change(phydev, true);
74 phy_led_trigger_change_speed(phydev);
77 static void phy_link_down(struct phy_device *phydev)
79 phydev->phy_link_change(phydev, false);
80 phy_led_trigger_change_speed(phydev);
83 static const char *phy_pause_str(struct phy_device *phydev)
87 if (phydev->autoneg == AUTONEG_DISABLE)
91 phydev->advertising);
93 phydev->advertising);
95 if (local_pause && phydev->pause)
98 if (local_asym_pause && phydev->asym_pause) {
101 if (phydev->pause)
111 * @phydev: the phy_device struct
113 void phy_print_status(struct phy_device *phydev)
115 if (phydev->link) {
116 netdev_info(phydev->attached_dev,
118 phy_speed_to_str(phydev->speed),
119 phy_duplex_to_str(phydev->duplex),
120 phydev->downshifted_rate ? "(downshifted) " : "",
121 phy_pause_str(phydev));
123 netdev_info(phydev->attached_dev, "Link is Down\n");
130 * @phydev: the phy_device struct
132 * If the @phydev driver has an ack_interrupt function, call it to
137 static int phy_clear_interrupt(struct phy_device *phydev)
141 if (phydev->drv->ack_interrupt) {
142 mutex_lock(&phydev->lock);
143 ret = phydev->drv->ack_interrupt(phydev);
144 mutex_unlock(&phydev->lock);
152 * @phydev: the phy_device struct
153 * @interrupts: interrupt flags to configure for this @phydev
157 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
159 phydev->interrupts = interrupts ? 1 : 0;
160 if (phydev->drv->config_intr)
161 return phydev->drv->config_intr(phydev);
168 * @phydev: target phy_device struct
170 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
173 int phy_restart_aneg(struct phy_device *phydev)
177 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
178 ret = genphy_c45_restart_aneg(phydev);
180 ret = genphy_restart_aneg(phydev);
188 * @phydev: target phy_device struct
190 * Description: Return the auto-negotiation status from this @phydev
194 int phy_aneg_done(struct phy_device *phydev)
196 if (phydev->drv && phydev->drv->aneg_done)
197 return phydev->drv->aneg_done(phydev);
198 else if (phydev->is_c45)
199 return genphy_c45_aneg_done(phydev);
201 return genphy_aneg_done(phydev);
258 * @phydev: the target phy_device struct
264 static void phy_sanitize_settings(struct phy_device *phydev)
268 setting = phy_find_valid(phydev->speed, phydev->duplex,
269 phydev->supported);
271 phydev->speed = setting->speed;
272 phydev->duplex = setting->duplex;
275 phydev->speed = SPEED_UNKNOWN;
276 phydev->duplex = DUPLEX_UNKNOWN;
280 void phy_ethtool_ksettings_get(struct phy_device *phydev,
283 mutex_lock(&phydev->lock);
284 linkmode_copy(cmd->link_modes.supported, phydev->supported);
285 linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
286 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
288 cmd->base.speed = phydev->speed;
289 cmd->base.duplex = phydev->duplex;
290 cmd->base.master_slave_cfg = phydev->master_slave_get;
291 cmd->base.master_slave_state = phydev->master_slave_state;
292 if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
295 cmd->base.port = phydev->port;
296 cmd->base.transceiver = phy_is_internal(phydev) ?
298 cmd->base.phy_address = phydev->mdio.addr;
299 cmd->base.autoneg = phydev->autoneg;
300 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
301 cmd->base.eth_tp_mdix = phydev->mdix;
302 mutex_unlock(&phydev->lock);
308 * @phydev: the phy_device struct
316 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
325 mii_data->phy_id = phydev->mdio.addr;
337 mii_data->val_out = mdiobus_read(phydev->mdio.bus, prtad,
350 if (prtad == phydev->mdio.addr) {
354 if (phydev->autoneg == AUTONEG_ENABLE)
356 phydev->autoneg = AUTONEG_DISABLE;
358 phydev->duplex = DUPLEX_FULL;
360 phydev->duplex = DUPLEX_HALF;
362 phydev->speed = SPEED_1000;
364 phydev->speed = SPEED_100;
365 else phydev->speed = SPEED_10;
368 if (phydev->autoneg == AUTONEG_DISABLE)
370 phydev->autoneg = AUTONEG_ENABLE;
374 mii_adv_mod_linkmode_adv_t(phydev->advertising,
379 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
389 mdiobus_write(phydev->mdio.bus, prtad, devad, val);
391 if (prtad == phydev->mdio.addr &&
394 return phy_init_hw(phydev);
397 return phy_start_aneg(phydev);
402 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
403 return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
420 if (!dev->phydev)
423 return phy_mii_ioctl(dev->phydev, ifr, cmd);
449 * @phydev: the phy_device struct
452 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
454 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
462 * @phydev: the phy_device struct
464 static void phy_trigger_machine(struct phy_device *phydev)
466 phy_queue_state_machine(phydev, 0);
469 static void phy_abort_cable_test(struct phy_device *phydev)
473 ethnl_cable_test_finished(phydev);
475 err = phy_init_hw(phydev);
477 phydev_err(phydev, "Error while aborting cable test");
483 * @phydev: the phy_device struct
486 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
488 if (!phydev->drv)
491 mutex_lock(&phydev->lock);
492 phydev->drv->get_strings(phydev, data);
493 mutex_unlock(&phydev->lock);
502 * @phydev: the phy_device struct
504 int phy_ethtool_get_sset_count(struct phy_device *phydev)
508 if (!phydev->drv)
511 if (phydev->drv->get_sset_count &&
512 phydev->drv->get_strings &&
513 phydev->drv->get_stats) {
514 mutex_lock(&phydev->lock);
515 ret = phydev->drv->get_sset_count(phydev);
516 mutex_unlock(&phydev->lock);
528 * @phydev: the phy_device struct
532 int phy_ethtool_get_stats(struct phy_device *phydev,
535 if (!phydev->drv)
538 mutex_lock(&phydev->lock);
539 phydev->drv->get_stats(phydev, stats, data);
540 mutex_unlock(&phydev->lock);
549 * @phydev: the phy_device struct
552 int phy_start_cable_test(struct phy_device *phydev,
555 struct net_device *dev = phydev->attached_dev;
558 if (!(phydev->drv &&
559 phydev->drv->cable_test_start &&
560 phydev->drv->cable_test_get_status)) {
566 mutex_lock(&phydev->lock);
567 if (phydev->state == PHY_CABLETEST) {
574 if (phydev->state < PHY_UP ||
575 phydev->state > PHY_CABLETEST) {
582 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
587 phy_link_down(phydev);
590 err = phydev->drv->cable_test_start(phydev);
593 phy_link_up(phydev);
597 phydev->state = PHY_CABLETEST;
599 if (phy_polling_mode(phydev))
600 phy_trigger_machine(phydev);
602 mutex_unlock(&phydev->lock);
607 ethnl_cable_test_free(phydev);
609 mutex_unlock(&phydev->lock);
618 * @phydev: the phy_device struct
622 int phy_start_cable_test_tdr(struct phy_device *phydev,
626 struct net_device *dev = phydev->attached_dev;
629 if (!(phydev->drv &&
630 phydev->drv->cable_test_tdr_start &&
631 phydev->drv->cable_test_get_status)) {
637 mutex_lock(&phydev->lock);
638 if (phydev->state == PHY_CABLETEST) {
645 if (phydev->state < PHY_UP ||
646 phydev->state > PHY_CABLETEST) {
653 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
658 phy_link_down(phydev);
661 err = phydev->drv->cable_test_tdr_start(phydev, config);
664 phy_link_up(phydev);
668 phydev->state = PHY_CABLETEST;
670 if (phy_polling_mode(phydev))
671 phy_trigger_machine(phydev);
673 mutex_unlock(&phydev->lock);
678 ethnl_cable_test_free(phydev);
680 mutex_unlock(&phydev->lock);
686 static int phy_config_aneg(struct phy_device *phydev)
688 if (phydev->drv->config_aneg)
689 return phydev->drv->config_aneg(phydev);
694 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
695 return genphy_c45_config_aneg(phydev);
697 return genphy_config_aneg(phydev);
702 * @phydev: the phy_device struct
707 static int phy_check_link_status(struct phy_device *phydev)
711 WARN_ON(!mutex_is_locked(&phydev->lock));
716 if (phydev->loopback_enabled)
719 err = phy_read_status(phydev);
723 if (phydev->link && phydev->state != PHY_RUNNING) {
724 phy_check_downshift(phydev);
725 phydev->state = PHY_RUNNING;
726 phy_link_up(phydev);
727 } else if (!phydev->link && phydev->state != PHY_NOLINK) {
728 phydev->state = PHY_NOLINK;
729 phy_link_down(phydev);
737 * @phydev: the phy_device struct
744 static int _phy_start_aneg(struct phy_device *phydev)
748 lockdep_assert_held(&phydev->lock);
750 if (!phydev->drv)
753 if (AUTONEG_DISABLE == phydev->autoneg)
754 phy_sanitize_settings(phydev);
756 err = phy_config_aneg(phydev);
760 if (phy_is_started(phydev))
761 err = phy_check_link_status(phydev);
768 * @phydev: the phy_device struct
775 int phy_start_aneg(struct phy_device *phydev)
779 mutex_lock(&phydev->lock);
780 err = _phy_start_aneg(phydev);
781 mutex_unlock(&phydev->lock);
787 static int phy_poll_aneg_done(struct phy_device *phydev)
794 ret = phy_aneg_done(phydev);
803 int phy_ethtool_ksettings_set(struct phy_device *phydev,
811 if (cmd->base.phy_address != phydev->mdio.addr)
817 linkmode_and(advertising, advertising, phydev->supported);
834 mutex_lock(&phydev->lock);
835 phydev->autoneg = autoneg;
838 phydev->speed = speed;
839 phydev->duplex = duplex;
842 linkmode_copy(phydev->advertising, advertising);
845 phydev->advertising, autoneg == AUTONEG_ENABLE);
847 phydev->master_slave_set = cmd->base.master_slave_cfg;
848 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
851 if (phy_is_started(phydev)) {
852 phydev->state = PHY_UP;
853 phy_trigger_machine(phydev);
855 _phy_start_aneg(phydev);
858 mutex_unlock(&phydev->lock);
865 * @phydev: the phy_device struct
876 int phy_speed_down(struct phy_device *phydev, bool sync)
881 if (phydev->autoneg != AUTONEG_ENABLE)
884 linkmode_copy(adv_tmp, phydev->advertising);
886 ret = phy_speed_down_core(phydev);
890 linkmode_copy(phydev->adv_old, adv_tmp);
892 if (linkmode_equal(phydev->advertising, adv_tmp))
895 ret = phy_config_aneg(phydev);
899 return sync ? phy_poll_aneg_done(phydev) : 0;
905 * @phydev: the phy_device struct
909 int phy_speed_up(struct phy_device *phydev)
913 if (phydev->autoneg != AUTONEG_ENABLE)
916 if (linkmode_empty(phydev->adv_old))
919 linkmode_copy(adv_tmp, phydev->advertising);
920 linkmode_copy(phydev->advertising, phydev->adv_old);
921 linkmode_zero(phydev->adv_old);
923 if (linkmode_equal(phydev->advertising, adv_tmp))
926 return phy_config_aneg(phydev);
932 * @phydev: the phy_device struct
940 void phy_start_machine(struct phy_device *phydev)
942 phy_trigger_machine(phydev);
948 * @phydev: target phy_device struct
954 void phy_stop_machine(struct phy_device *phydev)
956 cancel_delayed_work_sync(&phydev->state_queue);
958 mutex_lock(&phydev->lock);
959 if (phy_is_started(phydev))
960 phydev->state = PHY_UP;
961 mutex_unlock(&phydev->lock);
966 * @phydev: target phy_device struct
971 * phydev->lock is held.
973 static void phy_error(struct phy_device *phydev)
977 mutex_lock(&phydev->lock);
978 phydev->state = PHY_HALTED;
979 mutex_unlock(&phydev->lock);
981 phy_trigger_machine(phydev);
986 * @phydev: target phy_device struct
988 int phy_disable_interrupts(struct phy_device *phydev)
993 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
998 return phy_clear_interrupt(phydev);
1003 * @phydev: target phy_device struct
1005 static int phy_did_interrupt(struct phy_device *phydev)
1009 mutex_lock(&phydev->lock);
1010 ret = phydev->drv->did_interrupt(phydev);
1011 mutex_unlock(&phydev->lock);
1018 * @phydev: target phy_device struct
1020 static irqreturn_t phy_handle_interrupt(struct phy_device *phydev)
1024 mutex_lock(&phydev->lock);
1025 ret = phydev->drv->handle_interrupt(phydev);
1026 mutex_unlock(&phydev->lock);
1040 struct phy_device *phydev = phy_dat;
1041 struct phy_driver *drv = phydev->drv;
1044 return phy_handle_interrupt(phydev);
1046 if (drv->did_interrupt && !phy_did_interrupt(phydev))
1050 phy_trigger_machine(phydev);
1053 if (!drv->did_interrupt && phy_clear_interrupt(phydev)) {
1054 phy_error(phydev);
1063 * @phydev: target phy_device struct
1065 static int phy_enable_interrupts(struct phy_device *phydev)
1067 int err = phy_clear_interrupt(phydev);
1072 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
1077 * @phydev: target phy_device struct
1083 void phy_request_interrupt(struct phy_device *phydev)
1087 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
1089 phydev_name(phydev), phydev);
1091 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
1092 err, phydev->irq);
1093 phydev->irq = PHY_POLL;
1095 if (phy_enable_interrupts(phydev)) {
1096 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1097 phy_free_interrupt(phydev);
1098 phydev->irq = PHY_POLL;
1106 * @phydev: target phy_device struct
1111 void phy_free_interrupt(struct phy_device *phydev)
1113 phy_disable_interrupts(phydev);
1114 free_irq(phydev->irq, phydev);
1120 * @phydev: target phy_device struct
1122 void phy_stop(struct phy_device *phydev)
1124 struct net_device *dev = phydev->attached_dev;
1127 if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1129 phy_state_to_str(phydev->state));
1133 mutex_lock(&phydev->lock);
1134 old_state = phydev->state;
1136 if (phydev->state == PHY_CABLETEST) {
1137 phy_abort_cable_test(phydev);
1141 if (phydev->sfp_bus)
1142 sfp_upstream_stop(phydev->sfp_bus);
1144 phydev->state = PHY_HALTED;
1145 phy_process_state_change(phydev, old_state);
1147 mutex_unlock(&phydev->lock);
1149 phy_state_machine(&phydev->state_queue.work);
1150 phy_stop_machine(phydev);
1161 * @phydev: target phy_device struct
1169 void phy_start(struct phy_device *phydev)
1171 mutex_lock(&phydev->lock);
1173 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1175 phy_state_to_str(phydev->state));
1179 if (phydev->sfp_bus)
1180 sfp_upstream_start(phydev->sfp_bus);
1183 __phy_resume(phydev);
1185 phydev->state = PHY_UP;
1187 phy_start_machine(phydev);
1189 mutex_unlock(&phydev->lock);
1200 struct phy_device *phydev =
1202 struct net_device *dev = phydev->attached_dev;
1208 mutex_lock(&phydev->lock);
1210 old_state = phydev->state;
1212 switch (phydev->state) {
1222 err = phy_check_link_status(phydev);
1225 err = phydev->drv->cable_test_get_status(phydev, &finished);
1227 phy_abort_cable_test(phydev);
1230 phydev->state = PHY_UP;
1235 ethnl_cable_test_finished(phydev);
1238 phydev->state = PHY_UP;
1242 if (phydev->link) {
1243 phydev->link = 0;
1244 phy_link_down(phydev);
1250 mutex_unlock(&phydev->lock);
1253 err = phy_start_aneg(phydev);
1255 phy_suspend(phydev);
1258 phy_error(phydev);
1260 phy_process_state_change(phydev, old_state);
1270 mutex_lock(&phydev->lock);
1271 if (phy_polling_mode(phydev) && phy_is_started(phydev))
1272 phy_queue_state_machine(phydev, PHY_STATE_TIME);
1273 mutex_unlock(&phydev->lock);
1278 * @phydev: phy_device struct with changed link
1283 void phy_mac_interrupt(struct phy_device *phydev)
1286 phy_trigger_machine(phydev);
1316 * @phydev: target phy_device struct
1324 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1326 if (!phydev->drv)
1331 if (phydev->duplex == DUPLEX_FULL) {
1340 status = phy_read_status(phydev);
1345 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1356 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1360 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1368 if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1375 phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1387 * @phydev: target phy_device struct
1392 int phy_get_eee_err(struct phy_device *phydev)
1394 if (!phydev->drv)
1397 return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1403 * @phydev: target phy_device struct
1409 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1413 if (!phydev->drv)
1417 val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1423 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1430 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1443 * @phydev: target phy_device struct
1448 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1452 if (!phydev->drv)
1456 cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1460 old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1468 adv &= ~phydev->eee_broken_modes;
1472 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1479 if (phydev->autoneg == AUTONEG_ENABLE) {
1480 ret = phy_restart_aneg(phydev);
1493 * @phydev: target phy_device struct
1496 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1498 if (phydev->drv && phydev->drv->set_wol)
1499 return phydev->drv->set_wol(phydev, wol);
1508 * @phydev: target phy_device struct
1511 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1513 if (phydev->drv && phydev->drv->get_wol)
1514 phydev->drv->get_wol(phydev, wol);
1521 struct phy_device *phydev = ndev->phydev;
1523 if (!phydev)
1526 phy_ethtool_ksettings_get(phydev, cmd);
1535 struct phy_device *phydev = ndev->phydev;
1537 if (!phydev)
1540 return phy_ethtool_ksettings_set(phydev, cmd);
1550 struct phy_device *phydev = ndev->phydev;
1552 if (!phydev)
1555 if (!phydev->drv)
1558 return phy_restart_aneg(phydev);