2019-01-22 02:05:50 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2014-01-05 08:17:06 +08:00
|
|
|
/* Framework for finding and configuring PHYs.
|
2005-07-31 07:31:23 +08:00
|
|
|
* Also contains generic PHY driver
|
|
|
|
*
|
|
|
|
* Author: Andy Fleming
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004 Freescale Semiconductor, Inc.
|
|
|
|
*/
|
2012-06-09 15:49:07 +08:00
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-07-31 07:31:23 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mii.h>
|
|
|
|
#include <linux/ethtool.h>
|
2018-09-30 05:04:16 +08:00
|
|
|
#include <linux/bitmap.h>
|
2005-07-31 07:31:23 +08:00
|
|
|
#include <linux/phy.h>
|
2016-10-17 23:49:55 +08:00
|
|
|
#include <linux/phy_led_triggers.h>
|
2019-11-16 03:56:51 +08:00
|
|
|
#include <linux/sfp.h>
|
2014-01-10 14:27:37 +08:00
|
|
|
#include <linux/mdio.h>
|
2014-01-05 08:17:06 +08:00
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/uaccess.h>
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2005-12-14 07:33:49 +08:00
|
|
|
MODULE_DESCRIPTION("PHY library");
|
|
|
|
MODULE_AUTHOR("Andy Fleming");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2018-09-30 05:04:16 +08:00
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_basic_features);
|
|
|
|
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_basic_t1_features);
|
|
|
|
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_gbit_features);
|
|
|
|
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
|
|
|
|
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
|
|
|
|
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_10gbit_features);
|
|
|
|
|
2019-01-15 23:55:30 +08:00
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
|
|
|
|
|
2019-07-11 02:03:24 +08:00
|
|
|
const int phy_basic_ports_array[3] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_Autoneg_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_TP_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_MII_BIT,
|
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_basic_ports_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2019-07-11 02:03:24 +08:00
|
|
|
const int phy_fibre_port_array[1] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_FIBRE_BIT,
|
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_fibre_port_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2019-07-11 02:03:24 +08:00
|
|
|
const int phy_all_ports_features_array[7] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_Autoneg_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_TP_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_MII_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_FIBRE_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_AUI_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_BNC_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_Backplane_BIT,
|
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2018-11-11 06:43:33 +08:00
|
|
|
const int phy_10_100_features_array[4] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_10baseT_Half_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_10baseT_Full_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_100baseT_Half_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_100baseT_Full_BIT,
|
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_10_100_features_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2018-11-11 06:43:33 +08:00
|
|
|
const int phy_basic_t1_features_array[2] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_TP_BIT,
|
2019-05-23 02:47:04 +08:00
|
|
|
ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
|
2018-09-30 05:04:16 +08:00
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2018-11-11 06:43:33 +08:00
|
|
|
const int phy_gbit_features_array[2] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
|
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_gbit_features_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2018-11-11 06:43:33 +08:00
|
|
|
const int phy_10gbit_features_array[1] = {
|
2018-09-30 05:04:16 +08:00
|
|
|
ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
|
|
|
|
};
|
2018-11-11 06:43:33 +08:00
|
|
|
EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
|
2018-09-30 05:04:16 +08:00
|
|
|
|
2019-01-15 23:55:30 +08:00
|
|
|
const int phy_10gbit_fec_features_array[1] = {
|
|
|
|
ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array);
|
|
|
|
|
2018-09-30 05:04:16 +08:00
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
|
|
|
|
EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
|
|
|
|
|
|
|
|
static const int phy_10gbit_full_features_array[] = {
|
|
|
|
ETHTOOL_LINK_MODE_10baseT_Full_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_100baseT_Full_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
|
|
|
|
ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void features_init(void)
|
|
|
|
{
|
|
|
|
/* 10/100 half/full*/
|
|
|
|
linkmode_set_bit_array(phy_basic_ports_array,
|
|
|
|
ARRAY_SIZE(phy_basic_ports_array),
|
|
|
|
phy_basic_features);
|
|
|
|
linkmode_set_bit_array(phy_10_100_features_array,
|
|
|
|
ARRAY_SIZE(phy_10_100_features_array),
|
|
|
|
phy_basic_features);
|
|
|
|
|
|
|
|
/* 100 full, TP */
|
|
|
|
linkmode_set_bit_array(phy_basic_t1_features_array,
|
|
|
|
ARRAY_SIZE(phy_basic_t1_features_array),
|
|
|
|
phy_basic_t1_features);
|
|
|
|
|
|
|
|
/* 10/100 half/full + 1000 half/full */
|
|
|
|
linkmode_set_bit_array(phy_basic_ports_array,
|
|
|
|
ARRAY_SIZE(phy_basic_ports_array),
|
|
|
|
phy_gbit_features);
|
|
|
|
linkmode_set_bit_array(phy_10_100_features_array,
|
|
|
|
ARRAY_SIZE(phy_10_100_features_array),
|
|
|
|
phy_gbit_features);
|
|
|
|
linkmode_set_bit_array(phy_gbit_features_array,
|
|
|
|
ARRAY_SIZE(phy_gbit_features_array),
|
|
|
|
phy_gbit_features);
|
|
|
|
|
|
|
|
/* 10/100 half/full + 1000 half/full + fibre*/
|
|
|
|
linkmode_set_bit_array(phy_basic_ports_array,
|
|
|
|
ARRAY_SIZE(phy_basic_ports_array),
|
|
|
|
phy_gbit_fibre_features);
|
|
|
|
linkmode_set_bit_array(phy_10_100_features_array,
|
|
|
|
ARRAY_SIZE(phy_10_100_features_array),
|
|
|
|
phy_gbit_fibre_features);
|
|
|
|
linkmode_set_bit_array(phy_gbit_features_array,
|
|
|
|
ARRAY_SIZE(phy_gbit_features_array),
|
|
|
|
phy_gbit_fibre_features);
|
|
|
|
linkmode_set_bit_array(phy_fibre_port_array,
|
|
|
|
ARRAY_SIZE(phy_fibre_port_array),
|
|
|
|
phy_gbit_fibre_features);
|
|
|
|
|
|
|
|
/* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
|
|
|
|
linkmode_set_bit_array(phy_all_ports_features_array,
|
|
|
|
ARRAY_SIZE(phy_all_ports_features_array),
|
|
|
|
phy_gbit_all_ports_features);
|
|
|
|
linkmode_set_bit_array(phy_10_100_features_array,
|
|
|
|
ARRAY_SIZE(phy_10_100_features_array),
|
|
|
|
phy_gbit_all_ports_features);
|
|
|
|
linkmode_set_bit_array(phy_gbit_features_array,
|
|
|
|
ARRAY_SIZE(phy_gbit_features_array),
|
|
|
|
phy_gbit_all_ports_features);
|
|
|
|
|
|
|
|
/* 10/100 half/full + 1000 half/full + 10G full*/
|
|
|
|
linkmode_set_bit_array(phy_all_ports_features_array,
|
|
|
|
ARRAY_SIZE(phy_all_ports_features_array),
|
|
|
|
phy_10gbit_features);
|
|
|
|
linkmode_set_bit_array(phy_10_100_features_array,
|
|
|
|
ARRAY_SIZE(phy_10_100_features_array),
|
|
|
|
phy_10gbit_features);
|
|
|
|
linkmode_set_bit_array(phy_gbit_features_array,
|
|
|
|
ARRAY_SIZE(phy_gbit_features_array),
|
|
|
|
phy_10gbit_features);
|
|
|
|
linkmode_set_bit_array(phy_10gbit_features_array,
|
|
|
|
ARRAY_SIZE(phy_10gbit_features_array),
|
|
|
|
phy_10gbit_features);
|
|
|
|
|
|
|
|
/* 10/100/1000/10G full */
|
|
|
|
linkmode_set_bit_array(phy_all_ports_features_array,
|
|
|
|
ARRAY_SIZE(phy_all_ports_features_array),
|
|
|
|
phy_10gbit_full_features);
|
|
|
|
linkmode_set_bit_array(phy_10gbit_full_features_array,
|
|
|
|
ARRAY_SIZE(phy_10gbit_full_features_array),
|
|
|
|
phy_10gbit_full_features);
|
2019-01-15 23:55:30 +08:00
|
|
|
/* 10G FEC only */
|
|
|
|
linkmode_set_bit_array(phy_10gbit_fec_features_array,
|
|
|
|
ARRAY_SIZE(phy_10gbit_fec_features_array),
|
|
|
|
phy_10gbit_fec_features);
|
2018-09-30 05:04:16 +08:00
|
|
|
}
|
|
|
|
|
2007-12-04 21:17:33 +08:00
|
|
|
void phy_device_free(struct phy_device *phydev)
|
|
|
|
{
|
2016-01-07 03:11:16 +08:00
|
|
|
put_device(&phydev->mdio.dev);
|
2007-12-04 21:17:33 +08:00
|
|
|
}
|
2009-04-25 20:52:46 +08:00
|
|
|
EXPORT_SYMBOL(phy_device_free);
|
2007-12-04 21:17:33 +08:00
|
|
|
|
2016-01-07 03:11:27 +08:00
|
|
|
static void phy_mdio_device_free(struct mdio_device *mdiodev)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
|
|
|
phydev = container_of(mdiodev, struct phy_device, mdio);
|
|
|
|
phy_device_free(phydev);
|
|
|
|
}
|
|
|
|
|
2007-12-04 21:17:33 +08:00
|
|
|
static void phy_device_release(struct device *dev)
|
|
|
|
{
|
2013-02-28 09:01:52 +08:00
|
|
|
kfree(to_phy_device(dev));
|
2007-12-04 21:17:33 +08:00
|
|
|
}
|
|
|
|
|
2016-01-07 03:11:27 +08:00
|
|
|
static void phy_mdio_device_remove(struct mdio_device *mdiodev)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
|
|
|
phydev = container_of(mdiodev, struct phy_device, mdio);
|
|
|
|
phy_device_remove(phydev);
|
|
|
|
}
|
|
|
|
|
2017-06-05 19:23:05 +08:00
|
|
|
static struct phy_driver genphy_driver;
|
2019-04-07 19:55:01 +08:00
|
|
|
extern struct phy_driver genphy_c45_driver;
|
2009-04-25 20:52:46 +08:00
|
|
|
|
2008-04-19 06:29:54 +08:00
|
|
|
static LIST_HEAD(phy_fixup_list);
|
|
|
|
static DEFINE_MUTEX(phy_fixup_lock);
|
|
|
|
|
2016-01-07 03:11:21 +08:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct device_driver *drv = phydev->mdio.dev.driver;
|
|
|
|
struct phy_driver *phydrv = to_phy_driver(drv);
|
|
|
|
struct net_device *netdev = phydev->attached_dev;
|
|
|
|
|
|
|
|
if (!drv || !phydrv->suspend)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* PHY not attached? May suspend if the PHY has not already been
|
|
|
|
* suspended as part of a prior call to phy_disconnect() ->
|
|
|
|
* phy_detach() -> phy_suspend() because the parent netdev might be the
|
|
|
|
* MDIO bus driver and clock gated at this point.
|
|
|
|
*/
|
|
|
|
if (!netdev)
|
2020-02-21 07:34:53 +08:00
|
|
|
goto out;
|
2016-01-07 03:11:21 +08:00
|
|
|
|
2018-09-25 04:01:32 +08:00
|
|
|
if (netdev->wol_enabled)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* As long as not all affected network drivers support the
|
|
|
|
* wol_enabled flag, let's check for hints that WoL is enabled.
|
|
|
|
* Don't suspend PHY if the attached netdev parent may wake up.
|
2016-01-07 03:11:21 +08:00
|
|
|
* The parent may point to a PCI device, as in tg3 driver.
|
|
|
|
*/
|
|
|
|
if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Also don't suspend PHY if the netdev itself may wakeup. This
|
|
|
|
* is the case for devices w/o underlaying pwr. mgmt. aware bus,
|
|
|
|
* e.g. SoC devices.
|
|
|
|
*/
|
|
|
|
if (device_may_wakeup(&netdev->dev))
|
|
|
|
return false;
|
|
|
|
|
2020-02-21 07:34:53 +08:00
|
|
|
out:
|
|
|
|
return !phydev->suspended;
|
2016-01-07 03:11:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mdio_bus_phy_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
|
|
|
|
/* We must stop the state machine manually, otherwise it stops out of
|
|
|
|
* control, possibly with the phydev->lock held. Upon resume, netdev
|
|
|
|
* may call phy routines that try to grab the same lock, and that may
|
|
|
|
* lead to a deadlock.
|
|
|
|
*/
|
|
|
|
if (phydev->attached_dev && phydev->adjust_link)
|
|
|
|
phy_stop_machine(phydev);
|
|
|
|
|
|
|
|
if (!mdio_bus_phy_may_suspend(phydev))
|
|
|
|
return 0;
|
|
|
|
|
2020-03-13 05:25:20 +08:00
|
|
|
phydev->suspended_by_mdio_bus = 1;
|
|
|
|
|
2016-01-07 03:11:21 +08:00
|
|
|
return phy_suspend(phydev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mdio_bus_phy_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
int ret;
|
|
|
|
|
2020-03-13 05:25:20 +08:00
|
|
|
if (!phydev->suspended_by_mdio_bus)
|
2016-01-07 03:11:21 +08:00
|
|
|
goto no_resume;
|
|
|
|
|
2020-03-13 05:25:20 +08:00
|
|
|
phydev->suspended_by_mdio_bus = 0;
|
|
|
|
|
2016-01-07 03:11:21 +08:00
|
|
|
ret = phy_resume(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
no_resume:
|
|
|
|
if (phydev->attached_dev && phydev->adjust_link)
|
|
|
|
phy_start_machine(phydev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mdio_bus_phy_restore(struct device *dev)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
struct net_device *netdev = phydev->attached_dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!netdev)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = phy_init_hw(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2018-12-18 15:57:04 +08:00
|
|
|
if (phydev->attached_dev && phydev->adjust_link)
|
|
|
|
phy_start_machine(phydev);
|
2016-01-07 03:11:21 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
|
|
|
|
.suspend = mdio_bus_phy_suspend,
|
|
|
|
.resume = mdio_bus_phy_resume,
|
|
|
|
.freeze = mdio_bus_phy_suspend,
|
|
|
|
.thaw = mdio_bus_phy_resume,
|
|
|
|
.restore = mdio_bus_phy_restore,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define MDIO_BUS_PHY_PM_OPS NULL
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
2014-01-05 08:17:06 +08:00
|
|
|
/**
|
|
|
|
* phy_register_fixup - creates a new phy_fixup and adds it to the list
|
2016-01-07 03:11:16 +08:00
|
|
|
* @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
|
2008-04-19 06:29:54 +08:00
|
|
|
* @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
|
2014-01-05 08:17:06 +08:00
|
|
|
* It can also be PHY_ANY_UID
|
2008-04-19 06:29:54 +08:00
|
|
|
* @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
|
2014-01-05 08:17:06 +08:00
|
|
|
* comparison
|
2008-04-19 06:29:54 +08:00
|
|
|
* @run: The actual code to be run when a matching PHY is found
|
|
|
|
*/
|
|
|
|
int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
|
2014-01-05 08:17:06 +08:00
|
|
|
int (*run)(struct phy_device *))
|
2008-04-19 06:29:54 +08:00
|
|
|
{
|
2014-01-05 08:23:19 +08:00
|
|
|
struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
|
2008-04-19 06:29:54 +08:00
|
|
|
|
|
|
|
if (!fixup)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-11-11 05:55:14 +08:00
|
|
|
strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
|
2008-04-19 06:29:54 +08:00
|
|
|
fixup->phy_uid = phy_uid;
|
|
|
|
fixup->phy_uid_mask = phy_uid_mask;
|
|
|
|
fixup->run = run;
|
|
|
|
|
|
|
|
mutex_lock(&phy_fixup_lock);
|
|
|
|
list_add_tail(&fixup->list, &phy_fixup_list);
|
|
|
|
mutex_unlock(&phy_fixup_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_register_fixup);
|
|
|
|
|
|
|
|
/* Registers a fixup to be run on any PHY with the UID in phy_uid */
|
|
|
|
int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
|
2014-01-05 08:17:06 +08:00
|
|
|
int (*run)(struct phy_device *))
|
2008-04-19 06:29:54 +08:00
|
|
|
{
|
|
|
|
return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_register_fixup_for_uid);
|
|
|
|
|
|
|
|
/* Registers a fixup to be run on the PHY with id string bus_id */
|
|
|
|
int phy_register_fixup_for_id(const char *bus_id,
|
2014-01-05 08:17:06 +08:00
|
|
|
int (*run)(struct phy_device *))
|
2008-04-19 06:29:54 +08:00
|
|
|
{
|
|
|
|
return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_register_fixup_for_id);
|
|
|
|
|
2016-12-08 04:26:07 +08:00
|
|
|
/**
|
|
|
|
* phy_unregister_fixup - remove a phy_fixup from the list
|
|
|
|
* @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
|
|
|
|
* @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
|
|
|
|
* @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
|
|
|
|
*/
|
|
|
|
int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
|
|
|
|
{
|
|
|
|
struct list_head *pos, *n;
|
|
|
|
struct phy_fixup *fixup;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = -ENODEV;
|
|
|
|
|
|
|
|
mutex_lock(&phy_fixup_lock);
|
|
|
|
list_for_each_safe(pos, n, &phy_fixup_list) {
|
|
|
|
fixup = list_entry(pos, struct phy_fixup, list);
|
|
|
|
|
|
|
|
if ((!strcmp(fixup->bus_id, bus_id)) &&
|
|
|
|
((fixup->phy_uid & phy_uid_mask) ==
|
|
|
|
(phy_uid & phy_uid_mask))) {
|
|
|
|
list_del(&fixup->list);
|
|
|
|
kfree(fixup);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&phy_fixup_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_unregister_fixup);
|
|
|
|
|
|
|
|
/* Unregisters a fixup of any PHY with the UID in phy_uid */
|
|
|
|
int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
|
|
|
|
{
|
|
|
|
return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
|
|
|
|
|
|
|
|
/* Unregisters a fixup of the PHY with id string bus_id */
|
|
|
|
int phy_unregister_fixup_for_id(const char *bus_id)
|
|
|
|
{
|
|
|
|
return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_unregister_fixup_for_id);
|
|
|
|
|
2014-01-05 08:17:06 +08:00
|
|
|
/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
|
2008-04-19 06:29:54 +08:00
|
|
|
* Fixups can be set to match any in one or more fields.
|
|
|
|
*/
|
|
|
|
static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
|
|
|
|
{
|
2016-01-07 03:11:10 +08:00
|
|
|
if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
|
2008-04-19 06:29:54 +08:00
|
|
|
if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((fixup->phy_uid & fixup->phy_uid_mask) !=
|
2014-01-05 08:17:06 +08:00
|
|
|
(phydev->phy_id & fixup->phy_uid_mask))
|
2008-04-19 06:29:54 +08:00
|
|
|
if (fixup->phy_uid != PHY_ANY_UID)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Runs any matching fixups for this phydev */
|
2014-01-05 08:28:27 +08:00
|
|
|
static int phy_scan_fixups(struct phy_device *phydev)
|
2008-04-19 06:29:54 +08:00
|
|
|
{
|
|
|
|
struct phy_fixup *fixup;
|
|
|
|
|
|
|
|
mutex_lock(&phy_fixup_lock);
|
|
|
|
list_for_each_entry(fixup, &phy_fixup_list, list) {
|
|
|
|
if (phy_needs_fixup(phydev, fixup)) {
|
2014-01-05 08:23:19 +08:00
|
|
|
int err = fixup->run(phydev);
|
2008-04-19 06:29:54 +08:00
|
|
|
|
2009-07-13 19:23:39 +08:00
|
|
|
if (err < 0) {
|
|
|
|
mutex_unlock(&phy_fixup_lock);
|
2008-04-19 06:29:54 +08:00
|
|
|
return err;
|
2009-07-13 19:23:39 +08:00
|
|
|
}
|
2014-02-12 09:27:41 +08:00
|
|
|
phydev->has_fixups = true;
|
2008-04-19 06:29:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&phy_fixup_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-07 03:11:23 +08:00
|
|
|
static int phy_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
struct phy_driver *phydrv = to_phy_driver(drv);
|
|
|
|
const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
|
|
|
|
int i;
|
|
|
|
|
2016-01-07 03:11:26 +08:00
|
|
|
if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
|
|
|
|
return 0;
|
|
|
|
|
2016-01-07 03:11:23 +08:00
|
|
|
if (phydrv->match_phy_device)
|
|
|
|
return phydrv->match_phy_device(phydev);
|
|
|
|
|
|
|
|
if (phydev->is_c45) {
|
|
|
|
for (i = 1; i < num_ids; i++) {
|
net: phy: avoid matching all-ones clause 45 PHY IDs
We currently match clause 45 PHYs using any ID read from a MMD marked
as present in the "Devices in package" registers 5 and 6. However,
this is incorrect. 45.2 says:
"The definition of the term package is vendor specific and could be
a chip, module, or other similar entity."
so a package could be more or less than the whole PHY - a PHY could be
made up of several modules instantiated onto a single chip such as the
Marvell 88x3310, or some of the MMDs could be disabled according to
chip configuration, such as the Broadcom 84881.
In the case of Broadcom 84881, the "Devices in package" registers
contain 0xc000009b, meaning that there is a PHYXS present in the
package, but all registers in MMD 4 return 0xffff. This leads to our
matching code incorrectly binding this PHY to one of our generic PHY
drivers.
This patch changes the way we determine whether to attempt to match a
MMD identifier, or use it to request a module - if the identifier is
all-ones, then we skip over it. When reading the identifiers, we
initialise phydev->c45_ids.device_ids to all-ones, only reading the
device ID if the "Devices in package" registers indicates we should.
This avoids the generic drivers incorrectly matching on a PHY ID of
0xffffffff.
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-16 04:08:37 +08:00
|
|
|
if (phydev->c45_ids.device_ids[i] == 0xffffffff)
|
2016-01-07 03:11:23 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((phydrv->phy_id & phydrv->phy_id_mask) ==
|
|
|
|
(phydev->c45_ids.device_ids[i] &
|
|
|
|
phydrv->phy_id_mask))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return (phydrv->phy_id & phydrv->phy_id_mask) ==
|
|
|
|
(phydev->phy_id & phydrv->phy_id_mask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-03 04:36:06 +08:00
|
|
|
static ssize_t
|
|
|
|
phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(phy_id);
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
const char *mode = NULL;
|
|
|
|
|
|
|
|
if (phy_is_internal(phydev))
|
|
|
|
mode = "internal";
|
|
|
|
else
|
|
|
|
mode = phy_modes(phydev->interface);
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", mode);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(phy_interface);
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", phydev->has_fixups);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(phy_has_fixups);
|
|
|
|
|
|
|
|
static struct attribute *phy_dev_attrs[] = {
|
|
|
|
&dev_attr_phy_id.attr,
|
|
|
|
&dev_attr_phy_interface.attr,
|
|
|
|
&dev_attr_phy_has_fixups.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
ATTRIBUTE_GROUPS(phy_dev);
|
|
|
|
|
|
|
|
static const struct device_type mdio_bus_phy_type = {
|
|
|
|
.name = "PHY",
|
|
|
|
.groups = phy_dev_groups,
|
|
|
|
.release = phy_device_release,
|
|
|
|
.pm = MDIO_BUS_PHY_PM_OPS,
|
|
|
|
};
|
|
|
|
|
2019-12-20 07:24:52 +08:00
|
|
|
static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
|
2019-01-16 15:07:38 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
|
|
|
|
MDIO_ID_ARGS(phy_id));
|
2019-01-19 17:30:21 +08:00
|
|
|
/* We only check for failures in executing the usermode binary,
|
|
|
|
* not whether a PHY driver module exists for the PHY ID.
|
|
|
|
* Accept -ENOENT because this may occur in case no initramfs exists,
|
|
|
|
* then modprobe isn't available.
|
2019-01-16 15:07:38 +08:00
|
|
|
*/
|
2019-01-19 17:30:21 +08:00
|
|
|
if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
|
2019-12-20 07:24:52 +08:00
|
|
|
phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",
|
|
|
|
ret, (unsigned long)phy_id);
|
2019-01-16 15:07:38 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-12-20 07:24:52 +08:00
|
|
|
struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
|
2014-01-05 08:17:06 +08:00
|
|
|
bool is_c45,
|
|
|
|
struct phy_c45_device_ids *c45_ids)
|
2006-08-15 14:00:29 +08:00
|
|
|
{
|
|
|
|
struct phy_device *dev;
|
2016-01-07 03:11:16 +08:00
|
|
|
struct mdio_device *mdiodev;
|
2019-01-16 15:07:38 +08:00
|
|
|
int ret = 0;
|
2010-04-02 09:05:27 +08:00
|
|
|
|
2014-01-05 08:17:06 +08:00
|
|
|
/* We allocate the device, and initialize the default values */
|
2006-12-13 16:34:52 +08:00
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
2015-08-29 02:35:14 +08:00
|
|
|
if (!dev)
|
2015-08-29 02:34:34 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2006-08-15 14:00:29 +08:00
|
|
|
|
2016-01-07 03:11:16 +08:00
|
|
|
mdiodev = &dev->mdio;
|
|
|
|
mdiodev->dev.parent = &bus->dev;
|
|
|
|
mdiodev->dev.bus = &mdio_bus_type;
|
2018-06-03 04:36:06 +08:00
|
|
|
mdiodev->dev.type = &mdio_bus_phy_type;
|
2016-01-07 03:11:16 +08:00
|
|
|
mdiodev->bus = bus;
|
2016-01-07 03:11:23 +08:00
|
|
|
mdiodev->bus_match = phy_bus_match;
|
2016-01-07 03:11:16 +08:00
|
|
|
mdiodev->addr = addr;
|
2016-01-07 03:11:18 +08:00
|
|
|
mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
|
2016-01-07 03:11:27 +08:00
|
|
|
mdiodev->device_free = phy_mdio_device_free;
|
|
|
|
mdiodev->device_remove = phy_mdio_device_remove;
|
2007-12-04 21:17:33 +08:00
|
|
|
|
2019-11-22 23:23:23 +08:00
|
|
|
dev->speed = SPEED_UNKNOWN;
|
|
|
|
dev->duplex = DUPLEX_UNKNOWN;
|
2014-01-05 08:17:06 +08:00
|
|
|
dev->pause = 0;
|
|
|
|
dev->asym_pause = 0;
|
2018-03-11 22:00:37 +08:00
|
|
|
dev->link = 0;
|
2006-12-02 02:01:06 +08:00
|
|
|
dev->interface = PHY_INTERFACE_MODE_GMII;
|
2006-08-15 14:00:29 +08:00
|
|
|
|
|
|
|
dev->autoneg = AUTONEG_ENABLE;
|
|
|
|
|
2012-06-27 15:33:35 +08:00
|
|
|
dev->is_c45 = is_c45;
|
2006-08-15 14:00:29 +08:00
|
|
|
dev->phy_id = phy_id;
|
2012-06-27 15:33:35 +08:00
|
|
|
if (c45_ids)
|
|
|
|
dev->c45_ids = *c45_ids;
|
2016-01-12 17:36:21 +08:00
|
|
|
dev->irq = bus->irq[addr];
|
2016-01-07 03:11:16 +08:00
|
|
|
dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
|
2006-08-15 14:00:29 +08:00
|
|
|
|
|
|
|
dev->state = PHY_DOWN;
|
|
|
|
|
2008-01-30 00:05:09 +08:00
|
|
|
mutex_init(&dev->lock);
|
2010-01-18 13:37:16 +08:00
|
|
|
INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
|
2006-08-15 14:00:29 +08:00
|
|
|
|
2010-04-02 09:05:27 +08:00
|
|
|
/* Request the appropriate module unconditionally; don't
|
2014-01-05 08:17:06 +08:00
|
|
|
* bother trying to do so only if it isn't already loaded,
|
|
|
|
* because that gets complicated. A hotplug event would have
|
|
|
|
* done an unconditional modprobe anyway.
|
|
|
|
* We don't do normal hotplug because it won't work for MDIO
|
|
|
|
* -- because it relies on the device staying around for long
|
|
|
|
* enough for the driver to get loaded. With MDIO, the NIC
|
|
|
|
* driver will get bored and give up as soon as it finds that
|
|
|
|
* there's no driver _already_ loaded.
|
|
|
|
*/
|
2018-12-02 23:33:14 +08:00
|
|
|
if (is_c45 && c45_ids) {
|
|
|
|
const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < num_ids; i++) {
|
net: phy: avoid matching all-ones clause 45 PHY IDs
We currently match clause 45 PHYs using any ID read from a MMD marked
as present in the "Devices in package" registers 5 and 6. However,
this is incorrect. 45.2 says:
"The definition of the term package is vendor specific and could be
a chip, module, or other similar entity."
so a package could be more or less than the whole PHY - a PHY could be
made up of several modules instantiated onto a single chip such as the
Marvell 88x3310, or some of the MMDs could be disabled according to
chip configuration, such as the Broadcom 84881.
In the case of Broadcom 84881, the "Devices in package" registers
contain 0xc000009b, meaning that there is a PHYXS present in the
package, but all registers in MMD 4 return 0xffff. This leads to our
matching code incorrectly binding this PHY to one of our generic PHY
drivers.
This patch changes the way we determine whether to attempt to match a
MMD identifier, or use it to request a module - if the identifier is
all-ones, then we skip over it. When reading the identifiers, we
initialise phydev->c45_ids.device_ids to all-ones, only reading the
device ID if the "Devices in package" registers indicates we should.
This avoids the generic drivers incorrectly matching on a PHY ID of
0xffffffff.
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-16 04:08:37 +08:00
|
|
|
if (c45_ids->device_ids[i] == 0xffffffff)
|
2018-12-02 23:33:14 +08:00
|
|
|
continue;
|
|
|
|
|
2019-01-16 15:07:38 +08:00
|
|
|
ret = phy_request_driver_module(dev,
|
|
|
|
c45_ids->device_ids[i]);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2018-12-02 23:33:14 +08:00
|
|
|
}
|
|
|
|
} else {
|
2019-01-16 15:07:38 +08:00
|
|
|
ret = phy_request_driver_module(dev, phy_id);
|
2018-12-02 23:33:14 +08:00
|
|
|
}
|
2010-04-02 09:05:27 +08:00
|
|
|
|
2019-01-16 15:07:38 +08:00
|
|
|
if (!ret) {
|
|
|
|
device_initialize(&mdiodev->dev);
|
|
|
|
} else {
|
|
|
|
kfree(dev);
|
|
|
|
dev = ERR_PTR(ret);
|
|
|
|
}
|
2013-02-28 09:01:52 +08:00
|
|
|
|
2006-08-15 14:00:29 +08:00
|
|
|
return dev;
|
|
|
|
}
|
2012-06-27 15:33:35 +08:00
|
|
|
EXPORT_SYMBOL(phy_device_create);
|
|
|
|
|
2015-11-03 12:27:33 +08:00
|
|
|
/* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
|
|
|
|
* @bus: the target MII bus
|
|
|
|
* @addr: PHY address on the MII bus
|
|
|
|
* @dev_addr: MMD address in the PHY.
|
|
|
|
* @devices_in_package: where to store the devices in package information.
|
|
|
|
*
|
|
|
|
* Description: reads devices in package registers of a MMD at @dev_addr
|
|
|
|
* from PHY at @addr on @bus.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, -EIO on failure.
|
|
|
|
*/
|
|
|
|
static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
|
|
|
|
u32 *devices_in_package)
|
|
|
|
{
|
2020-05-26 23:29:36 +08:00
|
|
|
int phy_reg;
|
2015-11-03 12:27:33 +08:00
|
|
|
|
2020-05-26 23:29:36 +08:00
|
|
|
phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS2);
|
2015-11-03 12:27:33 +08:00
|
|
|
if (phy_reg < 0)
|
|
|
|
return -EIO;
|
2019-02-09 16:46:53 +08:00
|
|
|
*devices_in_package = phy_reg << 16;
|
2015-11-03 12:27:33 +08:00
|
|
|
|
2020-05-26 23:29:36 +08:00
|
|
|
phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS1);
|
2015-11-03 12:27:33 +08:00
|
|
|
if (phy_reg < 0)
|
|
|
|
return -EIO;
|
2019-02-09 16:46:53 +08:00
|
|
|
*devices_in_package |= phy_reg;
|
2015-11-03 12:27:33 +08:00
|
|
|
|
2019-02-09 02:25:22 +08:00
|
|
|
/* Bit 0 doesn't represent a device, it indicates c22 regs presence */
|
|
|
|
*devices_in_package &= ~BIT(0);
|
|
|
|
|
2015-11-03 12:27:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-27 15:33:35 +08:00
|
|
|
/**
|
|
|
|
* get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
|
|
|
|
* @bus: the target MII bus
|
|
|
|
* @addr: PHY address on the MII bus
|
|
|
|
* @phy_id: where to store the ID retrieved.
|
|
|
|
* @c45_ids: where to store the c45 ID information.
|
|
|
|
*
|
|
|
|
* If the PHY devices-in-package appears to be valid, it and the
|
|
|
|
* corresponding identifiers are stored in @c45_ids, zero is stored
|
|
|
|
* in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
|
|
|
|
* zero on success.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
|
2020-05-26 23:29:36 +08:00
|
|
|
struct phy_c45_device_ids *c45_ids)
|
|
|
|
{
|
2012-06-27 15:33:35 +08:00
|
|
|
const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
|
2015-11-03 12:27:33 +08:00
|
|
|
u32 *devs = &c45_ids->devices_in_package;
|
2020-05-26 23:29:36 +08:00
|
|
|
int i, phy_reg;
|
2012-06-27 15:33:35 +08:00
|
|
|
|
2015-11-03 12:27:33 +08:00
|
|
|
/* Find first non-zero Devices In package. Device zero is reserved
|
|
|
|
* for 802.3 c45 complied PHYs, so don't probe it at first.
|
2012-06-27 15:33:35 +08:00
|
|
|
*/
|
2015-11-03 12:27:33 +08:00
|
|
|
for (i = 1; i < num_ids && *devs == 0; i++) {
|
|
|
|
phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
|
2012-06-27 15:33:35 +08:00
|
|
|
if (phy_reg < 0)
|
|
|
|
return -EIO;
|
|
|
|
|
2015-11-03 12:27:33 +08:00
|
|
|
if ((*devs & 0x1fffffff) == 0x1fffffff) {
|
|
|
|
/* If mostly Fs, there is no device there,
|
|
|
|
* then let's continue to probe more, as some
|
|
|
|
* 10G PHYs have zero Devices In package,
|
|
|
|
* e.g. Cortina CS4315/CS4340 PHY.
|
|
|
|
*/
|
|
|
|
phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
|
|
|
|
if (phy_reg < 0)
|
|
|
|
return -EIO;
|
|
|
|
/* no device there, let's get out of here */
|
|
|
|
if ((*devs & 0x1fffffff) == 0x1fffffff) {
|
2015-06-26 17:58:52 +08:00
|
|
|
*phy_id = 0xffffffff;
|
|
|
|
return 0;
|
2015-11-03 12:27:33 +08:00
|
|
|
} else {
|
|
|
|
break;
|
2015-06-26 17:58:52 +08:00
|
|
|
}
|
2012-06-27 15:33:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now probe Device Identifiers for each device present. */
|
|
|
|
for (i = 1; i < num_ids; i++) {
|
|
|
|
if (!(c45_ids->devices_in_package & (1 << i)))
|
|
|
|
continue;
|
|
|
|
|
2020-05-26 23:29:36 +08:00
|
|
|
phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID1);
|
2012-06-27 15:33:35 +08:00
|
|
|
if (phy_reg < 0)
|
|
|
|
return -EIO;
|
2019-02-09 16:46:53 +08:00
|
|
|
c45_ids->device_ids[i] = phy_reg << 16;
|
2012-06-27 15:33:35 +08:00
|
|
|
|
2020-05-26 23:29:36 +08:00
|
|
|
phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID2);
|
2012-06-27 15:33:35 +08:00
|
|
|
if (phy_reg < 0)
|
|
|
|
return -EIO;
|
2019-02-09 16:46:53 +08:00
|
|
|
c45_ids->device_ids[i] |= phy_reg;
|
2012-06-27 15:33:35 +08:00
|
|
|
}
|
|
|
|
*phy_id = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-08-15 14:00:29 +08:00
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
2008-04-16 00:49:21 +08:00
|
|
|
* get_phy_id - reads the specified addr for its ID.
|
2007-03-06 18:41:48 +08:00
|
|
|
* @bus: the target MII bus
|
|
|
|
* @addr: PHY address on the MII bus
|
2008-04-16 00:49:21 +08:00
|
|
|
* @phy_id: where to store the ID retrieved.
|
2012-06-27 15:33:35 +08:00
|
|
|
* @is_c45: If true the PHY uses the 802.3 clause 45 protocol
|
|
|
|
* @c45_ids: where to store the c45 ID information.
|
|
|
|
*
|
|
|
|
* Description: In the case of a 802.3-c22 PHY, reads the ID registers
|
|
|
|
* of the PHY at @addr on the @bus, stores it in @phy_id and returns
|
|
|
|
* zero on success.
|
|
|
|
*
|
|
|
|
* In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
|
|
|
|
* its return value is in turn returned.
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
|
|
|
*/
|
2012-06-27 15:33:35 +08:00
|
|
|
static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
|
|
|
|
bool is_c45, struct phy_c45_device_ids *c45_ids)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
|
|
|
int phy_reg;
|
|
|
|
|
2012-06-27 15:33:35 +08:00
|
|
|
if (is_c45)
|
|
|
|
return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
|
|
|
|
|
2014-01-05 08:17:06 +08:00
|
|
|
/* Grab the bits from PHYIR1, and put them in the upper half */
|
2011-09-30 19:51:22 +08:00
|
|
|
phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
|
2018-04-25 00:09:04 +08:00
|
|
|
if (phy_reg < 0) {
|
2019-01-17 02:52:51 +08:00
|
|
|
/* returning -ENODEV doesn't stop bus scanning */
|
|
|
|
return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
|
2018-04-25 00:09:04 +08:00
|
|
|
}
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-02-09 16:46:53 +08:00
|
|
|
*phy_id = phy_reg << 16;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
/* Grab the bits from PHYIR2, and put them in the lower half */
|
2011-09-30 19:51:22 +08:00
|
|
|
phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
|
2020-06-20 02:47:47 +08:00
|
|
|
if (phy_reg < 0) {
|
|
|
|
/* returning -ENODEV doesn't stop bus scanning */
|
|
|
|
return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
|
|
|
|
}
|
2008-04-16 00:49:21 +08:00
|
|
|
|
2019-02-09 16:46:53 +08:00
|
|
|
*phy_id |= phy_reg;
|
2008-04-16 00:49:21 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-05 08:17:06 +08:00
|
|
|
* get_phy_device - reads the specified PHY device and returns its @phy_device
|
|
|
|
* struct
|
2008-04-16 00:49:21 +08:00
|
|
|
* @bus: the target MII bus
|
|
|
|
* @addr: PHY address on the MII bus
|
2012-06-27 15:33:35 +08:00
|
|
|
* @is_c45: If true the PHY uses the 802.3 clause 45 protocol
|
2008-04-16 00:49:21 +08:00
|
|
|
*
|
|
|
|
* Description: Reads the ID registers of the PHY at @addr on the
|
|
|
|
* @bus, then allocates and returns the phy_device to represent it.
|
|
|
|
*/
|
2012-06-27 15:33:35 +08:00
|
|
|
struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
|
2008-04-16 00:49:21 +08:00
|
|
|
{
|
net: phy: avoid matching all-ones clause 45 PHY IDs
We currently match clause 45 PHYs using any ID read from a MMD marked
as present in the "Devices in package" registers 5 and 6. However,
this is incorrect. 45.2 says:
"The definition of the term package is vendor specific and could be
a chip, module, or other similar entity."
so a package could be more or less than the whole PHY - a PHY could be
made up of several modules instantiated onto a single chip such as the
Marvell 88x3310, or some of the MMDs could be disabled according to
chip configuration, such as the Broadcom 84881.
In the case of Broadcom 84881, the "Devices in package" registers
contain 0xc000009b, meaning that there is a PHYXS present in the
package, but all registers in MMD 4 return 0xffff. This leads to our
matching code incorrectly binding this PHY to one of our generic PHY
drivers.
This patch changes the way we determine whether to attempt to match a
MMD identifier, or use it to request a module - if the identifier is
all-ones, then we skip over it. When reading the identifiers, we
initialise phydev->c45_ids.device_ids to all-ones, only reading the
device ID if the "Devices in package" registers indicates we should.
This avoids the generic drivers incorrectly matching on a PHY ID of
0xffffffff.
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-16 04:08:37 +08:00
|
|
|
struct phy_c45_device_ids c45_ids;
|
2012-06-28 12:28:14 +08:00
|
|
|
u32 phy_id = 0;
|
2008-04-16 00:49:21 +08:00
|
|
|
int r;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
net: phy: avoid matching all-ones clause 45 PHY IDs
We currently match clause 45 PHYs using any ID read from a MMD marked
as present in the "Devices in package" registers 5 and 6. However,
this is incorrect. 45.2 says:
"The definition of the term package is vendor specific and could be
a chip, module, or other similar entity."
so a package could be more or less than the whole PHY - a PHY could be
made up of several modules instantiated onto a single chip such as the
Marvell 88x3310, or some of the MMDs could be disabled according to
chip configuration, such as the Broadcom 84881.
In the case of Broadcom 84881, the "Devices in package" registers
contain 0xc000009b, meaning that there is a PHYXS present in the
package, but all registers in MMD 4 return 0xffff. This leads to our
matching code incorrectly binding this PHY to one of our generic PHY
drivers.
This patch changes the way we determine whether to attempt to match a
MMD identifier, or use it to request a module - if the identifier is
all-ones, then we skip over it. When reading the identifiers, we
initialise phydev->c45_ids.device_ids to all-ones, only reading the
device ID if the "Devices in package" registers indicates we should.
This avoids the generic drivers incorrectly matching on a PHY ID of
0xffffffff.
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-16 04:08:37 +08:00
|
|
|
c45_ids.devices_in_package = 0;
|
|
|
|
memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));
|
|
|
|
|
2012-06-27 15:33:35 +08:00
|
|
|
r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
|
2008-04-16 00:49:21 +08:00
|
|
|
if (r)
|
|
|
|
return ERR_PTR(r);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2008-11-21 12:43:18 +08:00
|
|
|
/* If the phy_id is mostly Fs, there is no device there */
|
|
|
|
if ((phy_id & 0x1fffffff) == 0x1fffffff)
|
2016-04-25 01:25:23 +08:00
|
|
|
return ERR_PTR(-ENODEV);
|
2008-11-21 12:43:18 +08:00
|
|
|
|
2014-01-05 08:21:52 +08:00
|
|
|
return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
2009-04-25 20:52:46 +08:00
|
|
|
EXPORT_SYMBOL(get_phy_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* phy_device_register - Register the phy device on the MDIO bus
|
2009-06-17 00:56:33 +08:00
|
|
|
* @phydev: phy_device structure to be added to the MDIO bus
|
2009-04-25 20:52:46 +08:00
|
|
|
*/
|
|
|
|
int phy_device_register(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2016-01-07 03:11:18 +08:00
|
|
|
err = mdiobus_register_device(&phydev->mdio);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2009-04-25 20:52:46 +08:00
|
|
|
|
2017-12-04 20:35:05 +08:00
|
|
|
/* Deassert the reset signal */
|
|
|
|
phy_device_reset(phydev, 0);
|
|
|
|
|
2009-04-25 20:52:46 +08:00
|
|
|
/* Run all of the fixups for this PHY */
|
2014-07-29 07:28:07 +08:00
|
|
|
err = phy_scan_fixups(phydev);
|
2013-12-07 05:01:34 +08:00
|
|
|
if (err) {
|
2019-01-16 04:50:25 +08:00
|
|
|
phydev_err(phydev, "failed to initialize\n");
|
2013-12-07 05:01:34 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2009-04-25 20:52:46 +08:00
|
|
|
|
2016-01-07 03:11:16 +08:00
|
|
|
err = device_add(&phydev->mdio.dev);
|
2009-04-25 20:52:46 +08:00
|
|
|
if (err) {
|
2019-01-16 04:50:25 +08:00
|
|
|
phydev_err(phydev, "failed to add\n");
|
2009-04-25 20:52:46 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
2017-12-04 20:35:05 +08:00
|
|
|
/* Assert the reset signal */
|
|
|
|
phy_device_reset(phydev, 1);
|
|
|
|
|
2016-01-07 03:11:18 +08:00
|
|
|
mdiobus_unregister_device(&phydev->mdio);
|
2009-04-25 20:52:46 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_device_register);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2015-09-25 03:36:28 +08:00
|
|
|
/**
|
|
|
|
* phy_device_remove - Remove a previously registered phy device from the MDIO bus
|
|
|
|
* @phydev: phy_device structure to remove
|
|
|
|
*
|
|
|
|
* This doesn't free the phy_device itself, it merely reverses the effects
|
|
|
|
* of phy_device_register(). Use phy_device_free() to free the device
|
|
|
|
* after calling this function.
|
|
|
|
*/
|
|
|
|
void phy_device_remove(struct phy_device *phydev)
|
|
|
|
{
|
2019-12-26 10:16:18 +08:00
|
|
|
if (phydev->mii_ts)
|
|
|
|
unregister_mii_timestamper(phydev->mii_ts);
|
|
|
|
|
2016-01-07 03:11:16 +08:00
|
|
|
device_del(&phydev->mdio.dev);
|
2017-12-04 20:35:05 +08:00
|
|
|
|
|
|
|
/* Assert the reset signal */
|
|
|
|
phy_device_reset(phydev, 1);
|
|
|
|
|
2016-01-07 03:11:18 +08:00
|
|
|
mdiobus_unregister_device(&phydev->mdio);
|
2015-09-25 03:36:28 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_device_remove);
|
|
|
|
|
2010-02-05 02:23:02 +08:00
|
|
|
/**
|
|
|
|
* phy_find_first - finds the first PHY device on the bus
|
|
|
|
* @bus: the target MII bus
|
|
|
|
*/
|
|
|
|
struct phy_device *phy_find_first(struct mii_bus *bus)
|
|
|
|
{
|
2016-01-07 03:11:18 +08:00
|
|
|
struct phy_device *phydev;
|
2010-02-05 02:23:02 +08:00
|
|
|
int addr;
|
|
|
|
|
|
|
|
for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
|
2016-01-07 03:11:18 +08:00
|
|
|
phydev = mdiobus_get_phy(bus, addr);
|
|
|
|
if (phydev)
|
|
|
|
return phydev;
|
2010-02-05 02:23:02 +08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_find_first);
|
|
|
|
|
2020-05-19 06:23:59 +08:00
|
|
|
static void phy_link_change(struct phy_device *phydev, bool up)
|
2017-07-25 22:02:58 +08:00
|
|
|
{
|
|
|
|
struct net_device *netdev = phydev->attached_dev;
|
|
|
|
|
2020-05-19 06:23:59 +08:00
|
|
|
if (up)
|
|
|
|
netif_carrier_on(netdev);
|
|
|
|
else
|
|
|
|
netif_carrier_off(netdev);
|
2017-07-25 22:02:58 +08:00
|
|
|
phydev->adjust_link(netdev);
|
2019-12-26 10:16:15 +08:00
|
|
|
if (phydev->mii_ts && phydev->mii_ts->link_state)
|
|
|
|
phydev->mii_ts->link_state(phydev->mii_ts, phydev);
|
2017-07-25 22:02:58 +08:00
|
|
|
}
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* phy_prepare_link - prepares the PHY layer to monitor link status
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
* @handler: callback function for link status change notifications
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Tells the PHY infrastructure to handle the
|
2005-07-31 07:31:23 +08:00
|
|
|
* gory details on monitoring link status (whether through
|
|
|
|
* polling or an interrupt), and to call back to the
|
|
|
|
* connected device driver when the link status changes.
|
|
|
|
* If you want to monitor your own link state, don't call
|
2007-03-06 18:41:48 +08:00
|
|
|
* this function.
|
|
|
|
*/
|
2010-10-21 16:37:41 +08:00
|
|
|
static void phy_prepare_link(struct phy_device *phydev,
|
2014-01-05 08:17:06 +08:00
|
|
|
void (*handler)(struct net_device *))
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
|
|
|
phydev->adjust_link = handler;
|
|
|
|
}
|
|
|
|
|
2009-04-25 20:52:51 +08:00
|
|
|
/**
|
|
|
|
* phy_connect_direct - connect an ethernet device to a specific phy_device
|
|
|
|
* @dev: the network device to connect
|
|
|
|
* @phydev: the pointer to the phy device
|
|
|
|
* @handler: callback function for state change notifications
|
|
|
|
* @interface: PHY device's interface
|
|
|
|
*/
|
|
|
|
int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
|
2013-01-14 08:52:52 +08:00
|
|
|
void (*handler)(struct net_device *),
|
2009-04-25 20:52:51 +08:00
|
|
|
phy_interface_t interface)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2019-05-29 01:38:09 +08:00
|
|
|
if (!dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-01-14 08:52:52 +08:00
|
|
|
rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
|
2009-04-25 20:52:51 +08:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
phy_prepare_link(phydev, handler);
|
2019-01-23 14:31:58 +08:00
|
|
|
if (phy_interrupt_is_valid(phydev))
|
|
|
|
phy_request_interrupt(phydev);
|
2009-04-25 20:52:51 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_connect_direct);
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* phy_connect - connect an ethernet device to a PHY device
|
|
|
|
* @dev: the network device to connect
|
2008-04-29 01:58:22 +08:00
|
|
|
* @bus_id: the id string of the PHY device to connect
|
2007-03-06 18:41:48 +08:00
|
|
|
* @handler: callback function for state change notifications
|
|
|
|
* @interface: PHY device's interface
|
2005-08-25 07:46:21 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Convenience function for connecting ethernet
|
2005-08-25 07:46:21 +08:00
|
|
|
* devices to PHY devices. The default behavior is for
|
|
|
|
* the PHY infrastructure to handle everything, and only notify
|
|
|
|
* the connected driver when the link status changes. If you
|
|
|
|
* don't want, or can't use the provided functionality, you may
|
|
|
|
* choose to call only the subset of functions which provide
|
|
|
|
* the desired functionality.
|
|
|
|
*/
|
2013-12-18 13:38:12 +08:00
|
|
|
struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
|
2014-01-05 08:17:06 +08:00
|
|
|
void (*handler)(struct net_device *),
|
|
|
|
phy_interface_t interface)
|
2005-08-25 07:46:21 +08:00
|
|
|
{
|
|
|
|
struct phy_device *phydev;
|
2009-04-25 20:52:51 +08:00
|
|
|
struct device *d;
|
|
|
|
int rc;
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2009-04-25 20:52:51 +08:00
|
|
|
/* Search the list of PHY devices on the mdio bus for the
|
2014-01-05 08:17:06 +08:00
|
|
|
* PHY with the requested name
|
|
|
|
*/
|
2009-04-25 20:52:51 +08:00
|
|
|
d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
|
|
|
|
if (!d) {
|
|
|
|
pr_err("PHY %s not found\n", bus_id);
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
phydev = to_phy_device(d);
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2013-01-14 08:52:52 +08:00
|
|
|
rc = phy_connect_direct(dev, phydev, handler, interface);
|
2016-11-04 01:40:19 +08:00
|
|
|
put_device(d);
|
2009-04-25 20:52:51 +08:00
|
|
|
if (rc)
|
|
|
|
return ERR_PTR(rc);
|
2005-08-25 07:46:21 +08:00
|
|
|
|
|
|
|
return phydev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_connect);
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
2014-01-05 08:17:06 +08:00
|
|
|
* phy_disconnect - disable interrupts, stop state machine, and detach a PHY
|
|
|
|
* device
|
2007-03-06 18:41:48 +08:00
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*/
|
2005-08-25 07:46:21 +08:00
|
|
|
void phy_disconnect(struct phy_device *phydev)
|
|
|
|
{
|
2019-01-18 03:07:54 +08:00
|
|
|
if (phy_is_started(phydev))
|
|
|
|
phy_stop(phydev);
|
|
|
|
|
2019-01-18 03:09:21 +08:00
|
|
|
if (phy_interrupt_is_valid(phydev))
|
2019-05-30 21:09:15 +08:00
|
|
|
phy_free_interrupt(phydev);
|
2005-08-25 07:46:21 +08:00
|
|
|
|
|
|
|
phydev->adjust_link = NULL;
|
|
|
|
|
|
|
|
phy_detach(phydev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_disconnect);
|
|
|
|
|
2013-12-07 05:01:34 +08:00
|
|
|
/**
|
|
|
|
* phy_poll_reset - Safely wait until a PHY reset has properly completed
|
|
|
|
* @phydev: The PHY device to poll
|
|
|
|
*
|
|
|
|
* Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
|
|
|
|
* published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
|
|
|
|
* register must be polled until the BMCR_RESET bit clears.
|
|
|
|
*
|
|
|
|
* Furthermore, any attempts to write to PHY registers may have no effect
|
|
|
|
* or even generate MDIO bus errors until this is complete.
|
|
|
|
*
|
|
|
|
* Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
|
|
|
|
* standard and do not fully reset after the BMCR_RESET bit is set, and may
|
|
|
|
* even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
|
|
|
|
* effort to support such broken PHYs, this function is separate from the
|
|
|
|
* standard phy_init_hw() which will zero all the other bits in the BMCR
|
|
|
|
* and reapply all driver-specific and board-specific fixups.
|
|
|
|
*/
|
|
|
|
static int phy_poll_reset(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
|
2020-03-23 23:05:58 +08:00
|
|
|
int ret, val;
|
2013-12-07 05:01:34 +08:00
|
|
|
|
2020-03-23 23:05:58 +08:00
|
|
|
ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
|
|
|
|
50000, 600000, true);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-01-05 08:17:06 +08:00
|
|
|
/* Some chips (smsc911x) may still need up to another 1ms after the
|
2013-12-07 05:01:34 +08:00
|
|
|
* BMCR_RESET bit is cleared before they are usable.
|
|
|
|
*/
|
|
|
|
msleep(1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-30 16:23:30 +08:00
|
|
|
int phy_init_hw(struct phy_device *phydev)
|
|
|
|
{
|
2014-02-18 05:34:03 +08:00
|
|
|
int ret = 0;
|
2009-12-30 16:23:30 +08:00
|
|
|
|
2017-12-04 20:35:05 +08:00
|
|
|
/* Deassert the reset signal */
|
|
|
|
phy_device_reset(phydev, 0);
|
|
|
|
|
2019-01-19 17:43:07 +08:00
|
|
|
if (!phydev->drv)
|
2009-12-30 16:23:30 +08:00
|
|
|
return 0;
|
|
|
|
|
2020-04-24 03:38:42 +08:00
|
|
|
if (phydev->drv->soft_reset) {
|
2014-02-18 05:34:03 +08:00
|
|
|
ret = phydev->drv->soft_reset(phydev);
|
2020-04-24 03:38:42 +08:00
|
|
|
/* see comment in genphy_soft_reset for an explanation */
|
|
|
|
if (!ret)
|
|
|
|
phydev->suspended = 0;
|
|
|
|
}
|
2014-02-18 05:34:03 +08:00
|
|
|
|
2013-12-07 05:01:34 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-12-30 16:23:30 +08:00
|
|
|
ret = phy_scan_fixups(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2020-06-24 15:59:23 +08:00
|
|
|
ret = phy_disable_interrupts(phydev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2019-01-19 17:43:07 +08:00
|
|
|
if (phydev->drv->config_init)
|
|
|
|
ret = phydev->drv->config_init(phydev);
|
|
|
|
|
|
|
|
return ret;
|
2009-12-30 16:23:30 +08:00
|
|
|
}
|
2013-12-07 05:01:34 +08:00
|
|
|
EXPORT_SYMBOL(phy_init_hw);
|
2009-12-30 16:23:30 +08:00
|
|
|
|
2016-01-07 03:11:13 +08:00
|
|
|
void phy_attached_info(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
phy_attached_print(phydev, NULL);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_attached_info);
|
|
|
|
|
2017-09-04 16:41:36 +08:00
|
|
|
#define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
|
2020-01-13 01:35:38 +08:00
|
|
|
char *phy_attached_info_irq(struct phy_device *phydev)
|
2016-01-07 03:11:13 +08:00
|
|
|
{
|
2017-09-04 16:41:36 +08:00
|
|
|
char *irq_str;
|
2017-09-21 19:27:02 +08:00
|
|
|
char irq_num[8];
|
2017-09-04 16:41:36 +08:00
|
|
|
|
|
|
|
switch(phydev->irq) {
|
|
|
|
case PHY_POLL:
|
|
|
|
irq_str = "POLL";
|
|
|
|
break;
|
|
|
|
case PHY_IGNORE_INTERRUPT:
|
|
|
|
irq_str = "IGNORE";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
|
|
|
|
irq_str = irq_num;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-01-13 01:35:38 +08:00
|
|
|
return kasprintf(GFP_KERNEL, "%s", irq_str);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_attached_info_irq);
|
|
|
|
|
|
|
|
void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
|
|
|
|
char *irq_str = phy_attached_info_irq(phydev);
|
2017-08-23 05:26:47 +08:00
|
|
|
|
2016-01-07 03:11:13 +08:00
|
|
|
if (!fmt) {
|
2018-09-30 05:04:11 +08:00
|
|
|
phydev_info(phydev, ATTACHED_FMT "\n",
|
2017-08-23 05:26:47 +08:00
|
|
|
drv_name, phydev_name(phydev),
|
2017-09-04 16:41:36 +08:00
|
|
|
irq_str);
|
2016-01-07 03:11:13 +08:00
|
|
|
} else {
|
|
|
|
va_list ap;
|
|
|
|
|
2018-09-30 05:04:11 +08:00
|
|
|
phydev_info(phydev, ATTACHED_FMT,
|
2017-08-23 05:26:47 +08:00
|
|
|
drv_name, phydev_name(phydev),
|
2017-09-04 16:41:36 +08:00
|
|
|
irq_str);
|
2016-01-07 03:11:13 +08:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintk(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
2020-01-13 01:35:38 +08:00
|
|
|
kfree(irq_str);
|
2016-01-07 03:11:13 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_attached_print);
|
|
|
|
|
2019-05-29 01:38:07 +08:00
|
|
|
static void phy_sysfs_create_links(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = phydev->attached_dev;
|
|
|
|
int err;
|
|
|
|
|
2019-05-29 01:38:08 +08:00
|
|
|
if (!dev)
|
|
|
|
return;
|
|
|
|
|
2019-05-29 01:38:07 +08:00
|
|
|
err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
|
|
|
|
"attached_dev");
|
|
|
|
if (err)
|
|
|
|
return;
|
|
|
|
|
|
|
|
err = sysfs_create_link_nowarn(&dev->dev.kobj,
|
|
|
|
&phydev->mdio.dev.kobj,
|
|
|
|
"phydev");
|
|
|
|
if (err) {
|
|
|
|
dev_err(&dev->dev, "could not add device link to %s err %d\n",
|
|
|
|
kobject_name(&phydev->mdio.dev.kobj),
|
|
|
|
err);
|
|
|
|
/* non-fatal - some net drivers can use one netdevice
|
|
|
|
* with more then one phy
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
phydev->sysfs_links = true;
|
|
|
|
}
|
|
|
|
|
2019-05-29 01:38:10 +08:00
|
|
|
static ssize_t
|
|
|
|
phy_standalone_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", !phydev->attached_dev);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(phy_standalone);
|
|
|
|
|
2019-11-16 03:56:51 +08:00
|
|
|
/**
|
|
|
|
* phy_sfp_attach - attach the SFP bus to the PHY upstream network device
|
|
|
|
* @upstream: pointer to the phy device
|
|
|
|
* @bus: sfp bus representing cage being attached
|
|
|
|
*
|
|
|
|
* This is used to fill in the sfp_upstream_ops .attach member.
|
|
|
|
*/
|
|
|
|
void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = upstream;
|
|
|
|
|
|
|
|
if (phydev->attached_dev)
|
|
|
|
phydev->attached_dev->sfp_bus = bus;
|
|
|
|
phydev->sfp_bus_attached = true;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_sfp_attach);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* phy_sfp_detach - detach the SFP bus from the PHY upstream network device
|
|
|
|
* @upstream: pointer to the phy device
|
|
|
|
* @bus: sfp bus representing cage being attached
|
|
|
|
*
|
|
|
|
* This is used to fill in the sfp_upstream_ops .detach member.
|
|
|
|
*/
|
|
|
|
void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = upstream;
|
|
|
|
|
|
|
|
if (phydev->attached_dev)
|
|
|
|
phydev->attached_dev->sfp_bus = NULL;
|
|
|
|
phydev->sfp_bus_attached = false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_sfp_detach);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* phy_sfp_probe - probe for a SFP cage attached to this PHY device
|
|
|
|
* @phydev: Pointer to phy_device
|
|
|
|
* @ops: SFP's upstream operations
|
|
|
|
*/
|
|
|
|
int phy_sfp_probe(struct phy_device *phydev,
|
|
|
|
const struct sfp_upstream_ops *ops)
|
|
|
|
{
|
|
|
|
struct sfp_bus *bus;
|
2020-05-17 19:53:40 +08:00
|
|
|
int ret = 0;
|
2019-11-16 03:56:51 +08:00
|
|
|
|
|
|
|
if (phydev->mdio.dev.fwnode) {
|
|
|
|
bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
|
|
|
|
if (IS_ERR(bus))
|
|
|
|
return PTR_ERR(bus);
|
|
|
|
|
|
|
|
phydev->sfp_bus = bus;
|
|
|
|
|
|
|
|
ret = sfp_bus_add_upstream(bus, phydev, ops);
|
|
|
|
sfp_bus_put(bus);
|
|
|
|
}
|
2020-05-17 19:53:40 +08:00
|
|
|
return ret;
|
2019-11-16 03:56:51 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_sfp_probe);
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
2009-04-25 20:52:51 +08:00
|
|
|
* phy_attach_direct - attach a network device to a given PHY device pointer
|
2007-03-06 18:41:48 +08:00
|
|
|
* @dev: network device to attach
|
2009-04-25 20:52:51 +08:00
|
|
|
* @phydev: Pointer to phy_device to attach
|
2007-03-06 18:41:48 +08:00
|
|
|
* @flags: PHY device's dev_flags
|
|
|
|
* @interface: PHY device's interface
|
2005-08-25 07:46:21 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Called by drivers to attach to a particular PHY
|
2005-08-25 07:46:21 +08:00
|
|
|
* device. The phy_device is found, and properly hooked up
|
2014-01-10 14:27:54 +08:00
|
|
|
* to the phy_driver. If no driver is attached, then a
|
|
|
|
* generic driver is used. The phy_device is given a ptr to
|
2005-08-25 07:46:21 +08:00
|
|
|
* the attaching device, and given a callback for link status
|
2007-03-06 18:41:48 +08:00
|
|
|
* change. The phy_device is returned to the attaching driver.
|
2015-09-25 03:36:08 +08:00
|
|
|
* This function takes a reference on the phy device.
|
2005-08-25 07:46:21 +08:00
|
|
|
*/
|
2014-01-10 14:27:54 +08:00
|
|
|
int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
|
|
|
|
u32 flags, phy_interface_t interface)
|
2005-08-25 07:46:21 +08:00
|
|
|
{
|
2016-01-07 03:11:16 +08:00
|
|
|
struct mii_bus *bus = phydev->mdio.bus;
|
|
|
|
struct device *d = &phydev->mdio.dev;
|
2019-05-29 01:38:08 +08:00
|
|
|
struct module *ndev_owner = NULL;
|
2017-02-09 11:05:26 +08:00
|
|
|
bool using_genphy = false;
|
2011-03-28 22:54:08 +08:00
|
|
|
int err;
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2016-12-07 12:54:43 +08:00
|
|
|
/* For Ethernet device drivers that register their own MDIO bus, we
|
|
|
|
* will have bus->owner match ndev_mod, so we do not want to increment
|
|
|
|
* our own module->refcnt here, otherwise we would not be able to
|
|
|
|
* unload later on.
|
|
|
|
*/
|
2019-05-29 01:38:08 +08:00
|
|
|
if (dev)
|
|
|
|
ndev_owner = dev->dev.parent->driver->owner;
|
2016-12-07 12:54:43 +08:00
|
|
|
if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
|
2019-05-29 01:38:08 +08:00
|
|
|
phydev_err(phydev, "failed to get the bus module\n");
|
2015-09-25 03:36:02 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2015-09-25 03:36:08 +08:00
|
|
|
get_device(d);
|
|
|
|
|
2005-08-25 07:46:21 +08:00
|
|
|
/* Assume that if there is no driver, that it doesn't
|
2014-01-05 08:17:06 +08:00
|
|
|
* exist, and we should use the genphy driver.
|
|
|
|
*/
|
2015-08-29 02:35:14 +08:00
|
|
|
if (!d->driver) {
|
2014-01-10 14:27:54 +08:00
|
|
|
if (phydev->is_c45)
|
2019-04-07 19:55:01 +08:00
|
|
|
d->driver = &genphy_c45_driver.mdiodrv.driver;
|
2014-01-10 14:27:54 +08:00
|
|
|
else
|
2017-06-05 19:23:05 +08:00
|
|
|
d->driver = &genphy_driver.mdiodrv.driver;
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2017-02-09 11:05:26 +08:00
|
|
|
using_genphy = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!try_module_get(d->driver->owner)) {
|
2019-05-29 01:38:08 +08:00
|
|
|
phydev_err(phydev, "failed to get the device driver module\n");
|
2017-02-09 11:05:26 +08:00
|
|
|
err = -EIO;
|
|
|
|
goto error_put_device;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (using_genphy) {
|
2005-08-25 07:46:21 +08:00
|
|
|
err = d->driver->probe(d);
|
2006-10-01 19:27:46 +08:00
|
|
|
if (err >= 0)
|
|
|
|
err = device_bind_driver(d);
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2006-10-01 19:27:46 +08:00
|
|
|
if (err)
|
2017-02-09 11:05:26 +08:00
|
|
|
goto error_module_put;
|
2005-08-25 07:46:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phydev->attached_dev) {
|
2009-04-25 20:52:51 +08:00
|
|
|
dev_err(&dev->dev, "PHY already attached\n");
|
2015-09-25 03:36:02 +08:00
|
|
|
err = -EBUSY;
|
|
|
|
goto error;
|
2014-07-24 03:47:32 +08:00
|
|
|
}
|
|
|
|
|
2017-07-25 22:02:58 +08:00
|
|
|
phydev->phy_link_change = phy_link_change;
|
2019-05-29 01:38:08 +08:00
|
|
|
if (dev) {
|
|
|
|
phydev->attached_dev = dev;
|
|
|
|
dev->phydev = phydev;
|
2019-11-16 03:56:51 +08:00
|
|
|
|
|
|
|
if (phydev->sfp_bus_attached)
|
|
|
|
dev->sfp_bus = phydev->sfp_bus;
|
2019-05-29 01:38:08 +08:00
|
|
|
}
|
2017-05-28 01:42:25 +08:00
|
|
|
|
|
|
|
/* Some Ethernet drivers try to connect to a PHY device before
|
|
|
|
* calling register_netdevice() -> netdev_register_kobject() and
|
|
|
|
* does the dev->dev.kobj initialization. Here we only check for
|
|
|
|
* success which indicates that the network device kobject is
|
|
|
|
* ready. Once we do that we still need to keep track of whether
|
|
|
|
* links were successfully set up or not for phy_detach() to
|
|
|
|
* remove them accordingly.
|
|
|
|
*/
|
|
|
|
phydev->sysfs_links = false;
|
|
|
|
|
2019-05-29 01:38:07 +08:00
|
|
|
phy_sysfs_create_links(phydev);
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2019-05-29 01:38:10 +08:00
|
|
|
if (!phydev->attached_dev) {
|
|
|
|
err = sysfs_create_file(&phydev->mdio.dev.kobj,
|
|
|
|
&dev_attr_phy_standalone.attr);
|
|
|
|
if (err)
|
|
|
|
phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
|
|
|
|
}
|
|
|
|
|
2019-10-23 02:31:06 +08:00
|
|
|
phydev->dev_flags |= flags;
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2006-12-02 02:01:06 +08:00
|
|
|
phydev->interface = interface;
|
|
|
|
|
phylib: Fix race between returning phydev and calling adjust_link
It is possible that phylib will call adjust_link before returning
from {,of_}phy_connect(), which may cause the following [very rare,
though] oops upon reopening the device:
Unable to handle kernel paging request for data at address 0x0000024c
Oops: Kernel access of bad area, sig: 11 [#1]
PREEMPT SMP NR_CPUS=2 LTT NESTING LEVEL : 0
P1021 RDB
Modules linked in:
NIP: c0345dac LR: c0345dac CTR: c0345d84
TASK = dffab6b0[30] 'events/0' THREAD: c0d24000 CPU: 0
[...]
NIP [c0345dac] adjust_link+0x28/0x19c
LR [c0345dac] adjust_link+0x28/0x19c
Call Trace:
[c0d25f00] [000045e1] 0x45e1 (unreliable)
[c0d25f30] [c036c158] phy_state_machine+0x3ac/0x554
[...]
Here is why. Drivers store phydev in their private structures, e.g.
gianfar driver:
static int init_phy(struct net_device *dev)
{
...
priv->phydev = of_phy_connect(...);
...
}
So that adjust_link could retrieve it back:
static void adjust_link(struct net_device *dev)
{
...
struct phy_device *phydev = priv->phydev;
...
}
If the device has been opened before, then phydev->state is set to
PHY_HALTED (or undefined if the driver didn't call phy_stop()).
Now, phy_connect starts the PHY state machine before returning phydev to
the driver:
phy_start_machine(phydev, NULL);
if (phydev->irq > 0)
phy_start_interrupts(phydev);
return phydev;
The time between 'phy_start_machine()' and 'return phydev' is undefined.
The start machine routine delays execution for 1 second, which is enough
for most cases. But under heavy load, or if you're unlucky, it is quite
possible that PHY state machine will execute before phy_connect()
returns, and so adjust_link callback will try to dereference phydev,
which is not yet ready.
To fix the issue, simply initialize the PHY's state to PHY_READY during
phy_attach(). This will ensure that phylib won't call adjust_link before
phy_start().
Signed-off-by: Anton Vorontsov <avorontsov@mvista.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-08-25 05:46:12 +08:00
|
|
|
phydev->state = PHY_READY;
|
|
|
|
|
2016-01-15 04:57:18 +08:00
|
|
|
/* Initial carrier state is off as the phy is about to be
|
|
|
|
* (re)initialized.
|
|
|
|
*/
|
2019-05-29 01:38:08 +08:00
|
|
|
if (dev)
|
|
|
|
netif_carrier_off(phydev->attached_dev);
|
2016-01-15 04:57:18 +08:00
|
|
|
|
2006-12-02 02:01:06 +08:00
|
|
|
/* Do initial configuration here, now that
|
|
|
|
* we have certain key parameters
|
2014-01-05 08:17:06 +08:00
|
|
|
* (dev_flags and interface)
|
|
|
|
*/
|
2011-03-28 22:54:08 +08:00
|
|
|
err = phy_init_hw(phydev);
|
|
|
|
if (err)
|
2016-11-24 07:10:33 +08:00
|
|
|
goto error;
|
2013-12-13 17:20:28 +08:00
|
|
|
|
2016-11-24 07:10:33 +08:00
|
|
|
phy_resume(phydev);
|
2016-10-17 23:49:55 +08:00
|
|
|
phy_led_triggers_register(phydev);
|
|
|
|
|
2011-03-28 22:54:08 +08:00
|
|
|
return err;
|
2015-09-25 03:36:02 +08:00
|
|
|
|
|
|
|
error:
|
2017-02-09 11:05:26 +08:00
|
|
|
/* phy_detach() does all of the cleanup below */
|
2016-11-24 07:10:33 +08:00
|
|
|
phy_detach(phydev);
|
2017-02-09 11:05:26 +08:00
|
|
|
return err;
|
|
|
|
|
|
|
|
error_module_put:
|
2017-02-01 10:46:43 +08:00
|
|
|
module_put(d->driver->owner);
|
2017-02-09 11:05:26 +08:00
|
|
|
error_put_device:
|
|
|
|
put_device(d);
|
2016-12-07 12:54:43 +08:00
|
|
|
if (ndev_owner != bus->owner)
|
|
|
|
module_put(bus->owner);
|
2015-09-25 03:36:02 +08:00
|
|
|
return err;
|
2009-04-25 20:52:51 +08:00
|
|
|
}
|
2014-01-10 14:27:54 +08:00
|
|
|
EXPORT_SYMBOL(phy_attach_direct);
|
2009-04-25 20:52:51 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* phy_attach - attach a network device to a particular PHY device
|
|
|
|
* @dev: network device to attach
|
|
|
|
* @bus_id: Bus ID of PHY device to attach
|
|
|
|
* @interface: PHY device's interface
|
|
|
|
*
|
|
|
|
* Description: Same as phy_attach_direct() except that a PHY bus_id
|
|
|
|
* string is passed instead of a pointer to a struct phy_device.
|
|
|
|
*/
|
2014-01-05 08:17:06 +08:00
|
|
|
struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
|
|
|
|
phy_interface_t interface)
|
2009-04-25 20:52:51 +08:00
|
|
|
{
|
|
|
|
struct bus_type *bus = &mdio_bus_type;
|
|
|
|
struct phy_device *phydev;
|
|
|
|
struct device *d;
|
|
|
|
int rc;
|
|
|
|
|
2019-05-29 01:38:09 +08:00
|
|
|
if (!dev)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2009-04-25 20:52:51 +08:00
|
|
|
/* Search the list of PHY devices on the mdio bus for the
|
2014-01-05 08:17:06 +08:00
|
|
|
* PHY with the requested name
|
|
|
|
*/
|
2009-04-25 20:52:51 +08:00
|
|
|
d = bus_find_device_by_name(bus, NULL, bus_id);
|
|
|
|
if (!d) {
|
|
|
|
pr_err("PHY %s not found\n", bus_id);
|
|
|
|
return ERR_PTR(-ENODEV);
|
2006-12-02 02:01:06 +08:00
|
|
|
}
|
2009-04-25 20:52:51 +08:00
|
|
|
phydev = to_phy_device(d);
|
|
|
|
|
2013-01-14 08:52:52 +08:00
|
|
|
rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
|
2016-11-04 01:40:19 +08:00
|
|
|
put_device(d);
|
2009-04-25 20:52:51 +08:00
|
|
|
if (rc)
|
|
|
|
return ERR_PTR(rc);
|
2006-12-02 02:01:06 +08:00
|
|
|
|
2005-08-25 07:46:21 +08:00
|
|
|
return phydev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_attach);
|
|
|
|
|
2019-01-16 07:09:35 +08:00
|
|
|
static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
|
|
|
|
struct device_driver *driver)
|
|
|
|
{
|
|
|
|
struct device *d = &phydev->mdio.dev;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
if (!phydev->drv)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
get_device(d);
|
|
|
|
ret = d->driver == driver;
|
|
|
|
put_device(d);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool phy_driver_is_genphy(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
return phy_driver_is_genphy_kind(phydev,
|
|
|
|
&genphy_driver.mdiodrv.driver);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
|
|
|
|
|
|
|
|
bool phy_driver_is_genphy_10g(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
return phy_driver_is_genphy_kind(phydev,
|
2019-04-07 19:55:01 +08:00
|
|
|
&genphy_c45_driver.mdiodrv.driver);
|
2019-01-16 07:09:35 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
|
|
|
|
|
2020-05-06 22:53:13 +08:00
|
|
|
/**
|
|
|
|
* phy_package_join - join a common PHY group
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
* @addr: cookie and PHY address for global register access
|
|
|
|
* @priv_size: if non-zero allocate this amount of bytes for private data
|
|
|
|
*
|
|
|
|
* This joins a PHY group and provides a shared storage for all phydevs in
|
|
|
|
* this group. This is intended to be used for packages which contain
|
|
|
|
* more than one PHY, for example a quad PHY transceiver.
|
|
|
|
*
|
|
|
|
* The addr parameter serves as a cookie which has to have the same value
|
|
|
|
* for all members of one group and as a PHY address to access generic
|
|
|
|
* registers of a PHY package. Usually, one of the PHY addresses of the
|
|
|
|
* different PHYs in the package provides access to these global registers.
|
|
|
|
* The address which is given here, will be used in the phy_package_read()
|
|
|
|
* and phy_package_write() convenience functions. If your PHY doesn't have
|
|
|
|
* global registers you can just pick any of the PHY addresses.
|
|
|
|
*
|
|
|
|
* This will set the shared pointer of the phydev to the shared storage.
|
|
|
|
* If this is the first call for a this cookie the shared storage will be
|
|
|
|
* allocated. If priv_size is non-zero, the given amount of bytes are
|
|
|
|
* allocated for the priv member.
|
|
|
|
*
|
|
|
|
* Returns < 1 on error, 0 on success. Esp. calling phy_package_join()
|
|
|
|
* with the same cookie but a different priv_size is an error.
|
|
|
|
*/
|
|
|
|
int phy_package_join(struct phy_device *phydev, int addr, size_t priv_size)
|
|
|
|
{
|
|
|
|
struct mii_bus *bus = phydev->mdio.bus;
|
|
|
|
struct phy_package_shared *shared;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (addr < 0 || addr >= PHY_MAX_ADDR)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&bus->shared_lock);
|
|
|
|
shared = bus->shared[addr];
|
|
|
|
if (!shared) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
shared = kzalloc(sizeof(*shared), GFP_KERNEL);
|
|
|
|
if (!shared)
|
|
|
|
goto err_unlock;
|
|
|
|
if (priv_size) {
|
|
|
|
shared->priv = kzalloc(priv_size, GFP_KERNEL);
|
|
|
|
if (!shared->priv)
|
|
|
|
goto err_free;
|
|
|
|
shared->priv_size = priv_size;
|
|
|
|
}
|
|
|
|
shared->addr = addr;
|
|
|
|
refcount_set(&shared->refcnt, 1);
|
|
|
|
bus->shared[addr] = shared;
|
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (priv_size && priv_size != shared->priv_size)
|
|
|
|
goto err_unlock;
|
|
|
|
refcount_inc(&shared->refcnt);
|
|
|
|
}
|
|
|
|
mutex_unlock(&bus->shared_lock);
|
|
|
|
|
|
|
|
phydev->shared = shared;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free:
|
|
|
|
kfree(shared);
|
|
|
|
err_unlock:
|
|
|
|
mutex_unlock(&bus->shared_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(phy_package_join);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* phy_package_leave - leave a common PHY group
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* This leaves a PHY group created by phy_package_join(). If this phydev
|
|
|
|
* was the last user of the shared data between the group, this data is
|
|
|
|
* freed. Resets the phydev->shared pointer to NULL.
|
|
|
|
*/
|
|
|
|
void phy_package_leave(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct phy_package_shared *shared = phydev->shared;
|
|
|
|
struct mii_bus *bus = phydev->mdio.bus;
|
|
|
|
|
|
|
|
if (!shared)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (refcount_dec_and_mutex_lock(&shared->refcnt, &bus->shared_lock)) {
|
|
|
|
bus->shared[shared->addr] = NULL;
|
|
|
|
mutex_unlock(&bus->shared_lock);
|
|
|
|
kfree(shared->priv);
|
|
|
|
kfree(shared);
|
|
|
|
}
|
|
|
|
|
|
|
|
phydev->shared = NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(phy_package_leave);
|
|
|
|
|
|
|
|
static void devm_phy_package_leave(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
phy_package_leave(*(struct phy_device **)res);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_phy_package_join - resource managed phy_package_join()
|
|
|
|
* @dev: device that is registering this PHY package
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
* @addr: cookie and PHY address for global register access
|
|
|
|
* @priv_size: if non-zero allocate this amount of bytes for private data
|
|
|
|
*
|
|
|
|
* Managed phy_package_join(). Shared storage fetched by this function,
|
|
|
|
* phy_package_leave() is automatically called on driver detach. See
|
|
|
|
* phy_package_join() for more information.
|
|
|
|
*/
|
|
|
|
int devm_phy_package_join(struct device *dev, struct phy_device *phydev,
|
|
|
|
int addr, size_t priv_size)
|
|
|
|
{
|
|
|
|
struct phy_device **ptr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = phy_package_join(phydev, addr, priv_size);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
*ptr = phydev;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
} else {
|
|
|
|
devres_free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_phy_package_join);
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* phy_detach - detach a PHY device from its network device
|
|
|
|
* @phydev: target phy_device struct
|
2015-09-25 03:36:08 +08:00
|
|
|
*
|
|
|
|
* This detaches the phy device from its network device and the phy
|
|
|
|
* driver, and drops the reference count taken in phy_attach_direct().
|
2007-03-06 18:41:48 +08:00
|
|
|
*/
|
2005-08-25 07:46:21 +08:00
|
|
|
void phy_detach(struct phy_device *phydev)
|
|
|
|
{
|
2016-12-07 12:54:43 +08:00
|
|
|
struct net_device *dev = phydev->attached_dev;
|
2019-05-29 01:38:08 +08:00
|
|
|
struct module *ndev_owner = NULL;
|
2015-09-25 03:36:02 +08:00
|
|
|
struct mii_bus *bus;
|
2014-07-24 03:47:32 +08:00
|
|
|
|
2017-05-28 01:42:25 +08:00
|
|
|
if (phydev->sysfs_links) {
|
2019-05-29 01:38:08 +08:00
|
|
|
if (dev)
|
|
|
|
sysfs_remove_link(&dev->dev.kobj, "phydev");
|
2017-05-28 01:42:25 +08:00
|
|
|
sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
|
|
|
|
}
|
2019-05-29 01:38:10 +08:00
|
|
|
|
|
|
|
if (!phydev->attached_dev)
|
|
|
|
sysfs_remove_file(&phydev->mdio.dev.kobj,
|
|
|
|
&dev_attr_phy_standalone.attr);
|
|
|
|
|
2018-09-25 04:01:32 +08:00
|
|
|
phy_suspend(phydev);
|
2019-05-29 01:38:08 +08:00
|
|
|
if (dev) {
|
|
|
|
phydev->attached_dev->phydev = NULL;
|
|
|
|
phydev->attached_dev = NULL;
|
|
|
|
}
|
phylink: add phylink infrastructure
The link between the ethernet MAC and its PHY has become more complex
as the interface evolves. This is especially true with serdes links,
where the part of the PHY is effectively integrated into the MAC.
Serdes links can be connected to a variety of devices, including SFF
modules soldered down onto the board with the MAC, a SFP cage with
a hotpluggable SFP module which may contain a PHY or directly modulate
the serdes signals onto optical media with or without a PHY, or even
a classical PHY connection.
Moreover, the negotiation information on serdes links comes in two
varieties - SGMII mode, where the PHY provides its speed/duplex/flow
control information to the MAC, and 1000base-X mode where both ends
exchange their abilities and each resolve the link capabilities.
This means we need a more flexible means to support these arrangements,
particularly with the hotpluggable nature of SFP, where the PHY can
be attached or detached after the network device has been brought up.
Ethtool information can come from multiple sources:
- we may have a PHY operating in either SGMII or 1000base-X mode, in
which case we take ethtool/mii data directly from the PHY.
- we may have a optical SFP module without a PHY, with the MAC
operating in 1000base-X mode - the ethtool/mii data needs to come
from the MAC.
- we may have a copper SFP module with a PHY whic can't be accessed,
which means we need to take ethtool/mii data from the MAC.
Phylink aims to solve this by providing an intermediary between the
MAC and PHY, providing a safe way for PHYs to be hotplugged, and
allowing a SFP driver to reconfigure the serdes connection.
Phylink also takes over support of fixed link connections, where the
speed/duplex/flow control are fixed, but link status may be controlled
by a GPIO signal. By avoiding the fixed-phy implementation, phylink
can provide a faster response to link events: fixed-phy has to wait for
phylib to operate its state machine, which can take several seconds.
In comparison, phylink takes milliseconds.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
- remove sync status
- rework supported and advertisment handling
- add 1000base-x speed for fixed links
- use functionality exported from phy-core, reworking
__phylink_ethtool_ksettings_set for it
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-07-25 22:03:13 +08:00
|
|
|
phydev->phylink = NULL;
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2016-11-28 22:18:31 +08:00
|
|
|
phy_led_triggers_unregister(phydev);
|
|
|
|
|
2017-02-09 11:05:26 +08:00
|
|
|
module_put(phydev->mdio.dev.driver->owner);
|
|
|
|
|
2005-08-25 07:46:21 +08:00
|
|
|
/* If the device had no specific driver before (i.e. - it
|
|
|
|
* was using the generic driver), we unbind the device
|
|
|
|
* from the generic driver so that there's a chance a
|
2014-01-05 08:17:06 +08:00
|
|
|
* real driver could be loaded
|
|
|
|
*/
|
2019-01-16 07:09:35 +08:00
|
|
|
if (phy_driver_is_genphy(phydev) ||
|
|
|
|
phy_driver_is_genphy_10g(phydev))
|
2017-06-05 19:23:05 +08:00
|
|
|
device_release_driver(&phydev->mdio.dev);
|
2015-09-25 03:36:02 +08:00
|
|
|
|
2015-09-25 03:36:08 +08:00
|
|
|
/*
|
|
|
|
* The phydev might go away on the put_device() below, so avoid
|
|
|
|
* a use-after-free bug by reading the underlying bus first.
|
|
|
|
*/
|
2016-01-07 03:11:16 +08:00
|
|
|
bus = phydev->mdio.bus;
|
2015-09-25 03:36:02 +08:00
|
|
|
|
2016-01-07 03:11:16 +08:00
|
|
|
put_device(&phydev->mdio.dev);
|
2019-05-29 01:38:08 +08:00
|
|
|
if (dev)
|
|
|
|
ndev_owner = dev->dev.parent->driver->owner;
|
2016-12-07 12:54:43 +08:00
|
|
|
if (ndev_owner != bus->owner)
|
|
|
|
module_put(bus->owner);
|
2017-12-04 20:35:05 +08:00
|
|
|
|
|
|
|
/* Assert the reset signal */
|
|
|
|
phy_device_reset(phydev, 1);
|
2005-08-25 07:46:21 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_detach);
|
|
|
|
|
2013-12-13 17:20:27 +08:00
|
|
|
int phy_suspend(struct phy_device *phydev)
|
|
|
|
{
|
2014-03-14 17:07:44 +08:00
|
|
|
struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
|
2020-03-27 01:58:24 +08:00
|
|
|
struct net_device *netdev = phydev->attached_dev;
|
|
|
|
struct phy_driver *phydrv = phydev->drv;
|
|
|
|
int ret;
|
2013-12-13 17:20:27 +08:00
|
|
|
|
2020-04-24 03:34:33 +08:00
|
|
|
if (phydev->suspended)
|
|
|
|
return 0;
|
|
|
|
|
2013-12-13 17:20:27 +08:00
|
|
|
/* If the device has WOL enabled, we cannot suspend the PHY */
|
|
|
|
phy_ethtool_get_wol(phydev, &wol);
|
2018-09-25 04:01:32 +08:00
|
|
|
if (wol.wolopts || (netdev && netdev->wol_enabled))
|
2013-12-13 17:20:27 +08:00
|
|
|
return -EBUSY;
|
|
|
|
|
2020-03-27 01:58:24 +08:00
|
|
|
if (!phydrv || !phydrv->suspend)
|
|
|
|
return 0;
|
2015-01-27 14:05:39 +08:00
|
|
|
|
2020-03-27 01:58:24 +08:00
|
|
|
ret = phydrv->suspend(phydev);
|
|
|
|
if (!ret)
|
|
|
|
phydev->suspended = true;
|
2015-01-27 14:05:39 +08:00
|
|
|
|
|
|
|
return ret;
|
2013-12-13 17:20:27 +08:00
|
|
|
}
|
2014-07-09 01:38:36 +08:00
|
|
|
EXPORT_SYMBOL(phy_suspend);
|
2013-12-13 17:20:27 +08:00
|
|
|
|
2018-02-27 08:56:06 +08:00
|
|
|
int __phy_resume(struct phy_device *phydev)
|
2013-12-13 17:20:27 +08:00
|
|
|
{
|
2020-03-27 01:58:24 +08:00
|
|
|
struct phy_driver *phydrv = phydev->drv;
|
|
|
|
int ret;
|
2013-12-13 17:20:27 +08:00
|
|
|
|
2017-12-12 18:45:36 +08:00
|
|
|
WARN_ON(!mutex_is_locked(&phydev->lock));
|
|
|
|
|
2020-03-27 01:58:24 +08:00
|
|
|
if (!phydrv || !phydrv->resume)
|
|
|
|
return 0;
|
2015-01-27 14:05:39 +08:00
|
|
|
|
2020-03-27 01:58:24 +08:00
|
|
|
ret = phydrv->resume(phydev);
|
|
|
|
if (!ret)
|
|
|
|
phydev->suspended = false;
|
2015-01-27 14:05:39 +08:00
|
|
|
|
|
|
|
return ret;
|
2013-12-13 17:20:27 +08:00
|
|
|
}
|
2018-02-27 08:56:06 +08:00
|
|
|
EXPORT_SYMBOL(__phy_resume);
|
|
|
|
|
|
|
|
int phy_resume(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&phydev->lock);
|
|
|
|
ret = __phy_resume(phydev);
|
|
|
|
mutex_unlock(&phydev->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2014-07-09 01:38:36 +08:00
|
|
|
EXPORT_SYMBOL(phy_resume);
|
2005-08-25 07:46:21 +08:00
|
|
|
|
2017-06-30 17:44:15 +08:00
|
|
|
int phy_loopback(struct phy_device *phydev, bool enable)
|
|
|
|
{
|
|
|
|
struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&phydev->lock);
|
|
|
|
|
|
|
|
if (enable && phydev->loopback_enabled) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!enable && !phydev->loopback_enabled) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (phydev->drv && phydrv->set_loopback)
|
|
|
|
ret = phydrv->set_loopback(phydev, enable);
|
|
|
|
else
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
phydev->loopback_enabled = enable;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&phydev->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_loopback);
|
|
|
|
|
2017-12-11 20:16:58 +08:00
|
|
|
/**
|
|
|
|
* phy_reset_after_clk_enable - perform a PHY reset if needed
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Some PHYs are known to need a reset after their refclk was
|
|
|
|
* enabled. This function evaluates the flags and perform the reset if it's
|
|
|
|
* needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
|
|
|
|
* was reset.
|
|
|
|
*/
|
|
|
|
int phy_reset_after_clk_enable(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
if (!phydev || !phydev->drv)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
|
|
|
|
phy_device_reset(phydev, 1);
|
|
|
|
phy_device_reset(phydev, 0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_reset_after_clk_enable);
|
|
|
|
|
2005-07-31 07:31:23 +08:00
|
|
|
/* Generic PHY support and helper functions */
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
2011-03-31 09:57:33 +08:00
|
|
|
* genphy_config_advert - sanitize and advertise auto-negotiation parameters
|
2007-03-06 18:41:48 +08:00
|
|
|
* @phydev: target phy_device struct
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Writes MII_ADVERTISE with the appropriate values,
|
2005-07-31 07:31:23 +08:00
|
|
|
* after sanitizing the values to make sure we only advertise
|
2008-09-24 18:55:46 +08:00
|
|
|
* what is supported. Returns < 0 on error, 0 if the PHY's advertisement
|
|
|
|
* hasn't changed, and > 0 if it has changed.
|
2005-07-31 07:31:23 +08:00
|
|
|
*/
|
2010-10-21 16:37:41 +08:00
|
|
|
static int genphy_config_advert(struct phy_device *phydev)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
2019-08-10 02:43:04 +08:00
|
|
|
int err, bmsr, changed = 0;
|
|
|
|
u32 adv;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2014-01-05 08:17:06 +08:00
|
|
|
/* Only allow advertising what this PHY supports */
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_and(phydev->advertising, phydev->advertising,
|
|
|
|
phydev->supported);
|
2019-08-10 02:43:04 +08:00
|
|
|
|
|
|
|
adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
/* Setup standard advertisement */
|
2019-02-11 02:59:57 +08:00
|
|
|
err = phy_modify_changed(phydev, MII_ADVERTISE,
|
|
|
|
ADVERTISE_ALL | ADVERTISE_100BASE4 |
|
|
|
|
ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
|
2019-08-10 02:43:04 +08:00
|
|
|
adv);
|
2019-02-11 02:59:57 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (err > 0)
|
2008-09-24 18:55:46 +08:00
|
|
|
changed = 1;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
net: phy: ensure Gigabit features are masked off if requested
When a Gigabit PHY device is connected to a 10/100Mbits capable Ethernet
MAC, the driver will restrict the phydev->supported modes to mask off
Gigabit. If the Gigabit PHY comes out of reset with the Gigabit features
set by default in MII_CTRL1000, it will keep advertising these feature,
so by the time we call genphy_config_advert(), the condition on
phydev->supported having the Gigabit features on is false, and we do not
update MII_CTRL1000 with updated values, and we keep advertising Gigabit
features, eventually configuring the PHY for Gigabit whilst the Ethernet
MAC does not support that.
This patches fixes the problem by ensuring that the Gigabit feature bits
are always cleared in MII_CTRL1000, if the PHY happens to be a Gigabit
PHY, and then, if Gigabit features are supported, setting those and
updating MII_CTRL1000 accordingly.
Reported-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: Florian Fainelli <f.fainelli@gmail.com>
Tested-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-04 04:35:46 +08:00
|
|
|
bmsr = phy_read(phydev, MII_BMSR);
|
|
|
|
if (bmsr < 0)
|
|
|
|
return bmsr;
|
|
|
|
|
|
|
|
/* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
|
|
|
|
* 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
|
|
|
|
* logical 1.
|
|
|
|
*/
|
|
|
|
if (!(bmsr & BMSR_ESTATEN))
|
|
|
|
return changed;
|
|
|
|
|
2019-08-10 02:43:04 +08:00
|
|
|
adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-02-11 02:59:57 +08:00
|
|
|
err = phy_modify_changed(phydev, MII_CTRL1000,
|
|
|
|
ADVERTISE_1000FULL | ADVERTISE_1000HALF,
|
|
|
|
adv);
|
net: phy: ensure Gigabit features are masked off if requested
When a Gigabit PHY device is connected to a 10/100Mbits capable Ethernet
MAC, the driver will restrict the phydev->supported modes to mask off
Gigabit. If the Gigabit PHY comes out of reset with the Gigabit features
set by default in MII_CTRL1000, it will keep advertising these feature,
so by the time we call genphy_config_advert(), the condition on
phydev->supported having the Gigabit features on is false, and we do not
update MII_CTRL1000 with updated values, and we keep advertising Gigabit
features, eventually configuring the PHY for Gigabit whilst the Ethernet
MAC does not support that.
This patches fixes the problem by ensuring that the Gigabit feature bits
are always cleared in MII_CTRL1000, if the PHY happens to be a Gigabit
PHY, and then, if Gigabit features are supported, setting those and
updating MII_CTRL1000 accordingly.
Reported-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: Florian Fainelli <f.fainelli@gmail.com>
Tested-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-04 04:35:46 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2019-02-11 02:59:57 +08:00
|
|
|
if (err > 0)
|
|
|
|
changed = 1;
|
net: phy: ensure Gigabit features are masked off if requested
When a Gigabit PHY device is connected to a 10/100Mbits capable Ethernet
MAC, the driver will restrict the phydev->supported modes to mask off
Gigabit. If the Gigabit PHY comes out of reset with the Gigabit features
set by default in MII_CTRL1000, it will keep advertising these feature,
so by the time we call genphy_config_advert(), the condition on
phydev->supported having the Gigabit features on is false, and we do not
update MII_CTRL1000 with updated values, and we keep advertising Gigabit
features, eventually configuring the PHY for Gigabit whilst the Ethernet
MAC does not support that.
This patches fixes the problem by ensuring that the Gigabit feature bits
are always cleared in MII_CTRL1000, if the PHY happens to be a Gigabit
PHY, and then, if Gigabit features are supported, setting those and
updating MII_CTRL1000 accordingly.
Reported-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: Florian Fainelli <f.fainelli@gmail.com>
Tested-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-04 04:35:46 +08:00
|
|
|
|
2008-09-24 18:55:46 +08:00
|
|
|
return changed;
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
|
|
|
|
2019-10-23 02:31:07 +08:00
|
|
|
/**
|
|
|
|
* genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Writes MII_ADVERTISE with the appropriate values,
|
|
|
|
* after sanitizing the values to make sure we only advertise
|
|
|
|
* what is supported. Returns < 0 on error, 0 if the PHY's advertisement
|
|
|
|
* hasn't changed, and > 0 if it has changed. This function is intended
|
|
|
|
* for Clause 37 1000Base-X mode.
|
|
|
|
*/
|
|
|
|
static int genphy_c37_config_advert(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
u16 adv = 0;
|
|
|
|
|
|
|
|
/* Only allow advertising what this PHY supports */
|
|
|
|
linkmode_and(phydev->advertising, phydev->advertising,
|
|
|
|
phydev->supported);
|
|
|
|
|
|
|
|
if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
|
|
|
|
phydev->advertising))
|
|
|
|
adv |= ADVERTISE_1000XFULL;
|
|
|
|
if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
|
|
|
|
phydev->advertising))
|
|
|
|
adv |= ADVERTISE_1000XPAUSE;
|
|
|
|
if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
|
|
|
|
phydev->advertising))
|
|
|
|
adv |= ADVERTISE_1000XPSE_ASYM;
|
|
|
|
|
|
|
|
return phy_modify_changed(phydev, MII_ADVERTISE,
|
|
|
|
ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
|
|
|
|
ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
|
|
|
|
adv);
|
|
|
|
}
|
|
|
|
|
2016-11-28 17:46:46 +08:00
|
|
|
/**
|
|
|
|
* genphy_config_eee_advert - disable unwanted eee mode advertisement
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
|
|
|
|
* efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
|
|
|
|
* changed, and 1 if it has changed.
|
|
|
|
*/
|
2019-02-19 04:26:58 +08:00
|
|
|
int genphy_config_eee_advert(struct phy_device *phydev)
|
2016-11-28 17:46:46 +08:00
|
|
|
{
|
2019-02-12 05:16:13 +08:00
|
|
|
int err;
|
2016-11-28 17:46:46 +08:00
|
|
|
|
|
|
|
/* Nothing to disable */
|
2019-02-12 05:16:13 +08:00
|
|
|
if (!phydev->eee_broken_modes)
|
2016-11-28 17:46:46 +08:00
|
|
|
return 0;
|
|
|
|
|
2019-02-12 05:16:13 +08:00
|
|
|
err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
|
|
|
|
phydev->eee_broken_modes, 0);
|
|
|
|
/* If the call failed, we assume that EEE is not supported */
|
|
|
|
return err < 0 ? 0 : err;
|
2016-11-28 17:46:46 +08:00
|
|
|
}
|
2019-02-19 04:26:58 +08:00
|
|
|
EXPORT_SYMBOL(genphy_config_eee_advert);
|
2016-11-28 17:46:46 +08:00
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* genphy_setup_forced - configures/forces speed/duplex from @phydev
|
|
|
|
* @phydev: target phy_device struct
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Configures MII_BMCR to force speed/duplex
|
2005-07-31 07:31:23 +08:00
|
|
|
* to the values in phydev. Assumes that the values are valid.
|
2007-03-06 18:41:48 +08:00
|
|
|
* Please see phy_sanitize_settings().
|
|
|
|
*/
|
2013-11-21 06:38:19 +08:00
|
|
|
int genphy_setup_forced(struct phy_device *phydev)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
2018-01-02 18:58:58 +08:00
|
|
|
u16 ctl = 0;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2014-01-05 08:17:06 +08:00
|
|
|
phydev->pause = 0;
|
|
|
|
phydev->asym_pause = 0;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
if (SPEED_1000 == phydev->speed)
|
|
|
|
ctl |= BMCR_SPEED1000;
|
|
|
|
else if (SPEED_100 == phydev->speed)
|
|
|
|
ctl |= BMCR_SPEED100;
|
|
|
|
|
|
|
|
if (DUPLEX_FULL == phydev->duplex)
|
|
|
|
ctl |= BMCR_FULLDPLX;
|
2013-12-18 13:38:12 +08:00
|
|
|
|
2018-01-02 18:58:58 +08:00
|
|
|
return phy_modify(phydev, MII_BMCR,
|
2018-02-12 19:02:52 +08:00
|
|
|
~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
2013-11-21 06:38:19 +08:00
|
|
|
EXPORT_SYMBOL(genphy_setup_forced);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2020-05-05 14:35:05 +08:00
|
|
|
static int genphy_setup_master_slave(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
u16 ctl = 0;
|
|
|
|
|
|
|
|
if (!phydev->is_gigabit_capable)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (phydev->master_slave_set) {
|
|
|
|
case MASTER_SLAVE_CFG_MASTER_PREFERRED:
|
|
|
|
ctl |= CTL1000_PREFER_MASTER;
|
|
|
|
break;
|
|
|
|
case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
|
|
|
|
break;
|
|
|
|
case MASTER_SLAVE_CFG_MASTER_FORCE:
|
|
|
|
ctl |= CTL1000_AS_MASTER;
|
|
|
|
/* fallthrough */
|
|
|
|
case MASTER_SLAVE_CFG_SLAVE_FORCE:
|
|
|
|
ctl |= CTL1000_ENABLE_MASTER;
|
|
|
|
break;
|
|
|
|
case MASTER_SLAVE_CFG_UNKNOWN:
|
|
|
|
case MASTER_SLAVE_CFG_UNSUPPORTED:
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
phydev_warn(phydev, "Unsupported Master/Slave mode\n");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
return phy_modify_changed(phydev, MII_CTRL1000,
|
|
|
|
(CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
|
|
|
|
CTL1000_PREFER_MASTER), ctl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genphy_read_master_slave(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int cfg, state;
|
2020-05-07 22:34:30 +08:00
|
|
|
int val;
|
2020-05-05 14:35:05 +08:00
|
|
|
|
|
|
|
if (!phydev->is_gigabit_capable) {
|
|
|
|
phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
|
|
|
|
phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
|
|
|
|
phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
|
|
|
|
|
|
|
|
val = phy_read(phydev, MII_CTRL1000);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
if (val & CTL1000_ENABLE_MASTER) {
|
|
|
|
if (val & CTL1000_AS_MASTER)
|
|
|
|
cfg = MASTER_SLAVE_CFG_MASTER_FORCE;
|
|
|
|
else
|
|
|
|
cfg = MASTER_SLAVE_CFG_SLAVE_FORCE;
|
|
|
|
} else {
|
|
|
|
if (val & CTL1000_PREFER_MASTER)
|
|
|
|
cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED;
|
|
|
|
else
|
|
|
|
cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = phy_read(phydev, MII_STAT1000);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
if (val & LPA_1000MSFAIL) {
|
|
|
|
state = MASTER_SLAVE_STATE_ERR;
|
|
|
|
} else if (phydev->link) {
|
|
|
|
/* this bits are valid only for active link */
|
|
|
|
if (val & LPA_1000MSRES)
|
|
|
|
state = MASTER_SLAVE_STATE_MASTER;
|
|
|
|
else
|
|
|
|
state = MASTER_SLAVE_STATE_SLAVE;
|
|
|
|
} else {
|
|
|
|
state = MASTER_SLAVE_STATE_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
phydev->master_slave_get = cfg;
|
|
|
|
phydev->master_slave_state = state;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* genphy_restart_aneg - Enable and Restart Autonegotiation
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*/
|
2005-07-31 07:31:23 +08:00
|
|
|
int genphy_restart_aneg(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/* Don't isolate the PHY if we're negotiating */
|
2018-01-06 00:07:10 +08:00
|
|
|
return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
|
2018-01-02 18:58:58 +08:00
|
|
|
BMCR_ANENABLE | BMCR_ANRESTART);
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
2008-10-14 09:48:09 +08:00
|
|
|
EXPORT_SYMBOL(genphy_restart_aneg);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-12-17 21:39:11 +08:00
|
|
|
/**
|
|
|
|
* genphy_check_and_restart_aneg - Enable and restart auto-negotiation
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
* @restart: whether aneg restart is requested
|
|
|
|
*
|
|
|
|
* Check, and restart auto-negotiation if needed.
|
|
|
|
*/
|
|
|
|
int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
|
|
|
|
{
|
2020-02-26 15:10:45 +08:00
|
|
|
int ret;
|
2019-12-17 21:39:11 +08:00
|
|
|
|
|
|
|
if (!restart) {
|
|
|
|
/* Advertisement hasn't changed, but maybe aneg was never on to
|
|
|
|
* begin with? Or maybe phy was isolated?
|
|
|
|
*/
|
|
|
|
ret = phy_read(phydev, MII_BMCR);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
|
|
|
|
restart = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (restart)
|
2020-02-26 15:10:45 +08:00
|
|
|
return genphy_restart_aneg(phydev);
|
2019-12-17 21:39:11 +08:00
|
|
|
|
2020-02-26 15:10:45 +08:00
|
|
|
return 0;
|
2019-12-17 21:39:11 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_check_and_restart_aneg);
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
2019-08-10 02:43:50 +08:00
|
|
|
* __genphy_config_aneg - restart auto-negotiation or write BMCR
|
2007-03-06 18:41:48 +08:00
|
|
|
* @phydev: target phy_device struct
|
2019-08-10 02:43:50 +08:00
|
|
|
* @changed: whether autoneg is requested
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: If auto-negotiation is enabled, we configure the
|
2005-07-31 07:31:23 +08:00
|
|
|
* advertising, and then restart auto-negotiation. If it is not
|
2007-03-06 18:41:48 +08:00
|
|
|
* enabled, then we write the BMCR.
|
2005-07-31 07:31:23 +08:00
|
|
|
*/
|
2019-08-10 02:43:50 +08:00
|
|
|
int __genphy_config_aneg(struct phy_device *phydev, bool changed)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
2019-08-10 02:43:50 +08:00
|
|
|
int err;
|
2016-11-28 17:46:46 +08:00
|
|
|
|
2019-08-10 02:43:50 +08:00
|
|
|
if (genphy_config_eee_advert(phydev))
|
|
|
|
changed = true;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2020-05-05 14:35:05 +08:00
|
|
|
err = genphy_setup_master_slave(phydev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
else if (err)
|
|
|
|
changed = true;
|
|
|
|
|
2008-11-20 07:52:41 +08:00
|
|
|
if (AUTONEG_ENABLE != phydev->autoneg)
|
|
|
|
return genphy_setup_forced(phydev);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2016-11-28 17:46:46 +08:00
|
|
|
err = genphy_config_advert(phydev);
|
|
|
|
if (err < 0) /* error */
|
|
|
|
return err;
|
2019-08-10 02:43:50 +08:00
|
|
|
else if (err)
|
|
|
|
changed = true;
|
2016-11-28 17:46:46 +08:00
|
|
|
|
2019-12-17 21:39:11 +08:00
|
|
|
return genphy_check_and_restart_aneg(phydev, changed);
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
2019-08-10 02:43:50 +08:00
|
|
|
EXPORT_SYMBOL(__genphy_config_aneg);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-10-23 02:31:07 +08:00
|
|
|
/**
|
|
|
|
* genphy_c37_config_aneg - restart auto-negotiation or write BMCR
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: If auto-negotiation is enabled, we configure the
|
|
|
|
* advertising, and then restart auto-negotiation. If it is not
|
|
|
|
* enabled, then we write the BMCR. This function is intended
|
|
|
|
* for use with Clause 37 1000Base-X mode.
|
|
|
|
*/
|
|
|
|
int genphy_c37_config_aneg(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err, changed;
|
|
|
|
|
|
|
|
if (phydev->autoneg != AUTONEG_ENABLE)
|
|
|
|
return genphy_setup_forced(phydev);
|
|
|
|
|
|
|
|
err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
|
|
|
|
BMCR_SPEED1000);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
changed = genphy_c37_config_advert(phydev);
|
|
|
|
if (changed < 0) /* error */
|
|
|
|
return changed;
|
|
|
|
|
|
|
|
if (!changed) {
|
|
|
|
/* Advertisement hasn't changed, but maybe aneg was never on to
|
|
|
|
* begin with? Or maybe phy was isolated?
|
|
|
|
*/
|
|
|
|
int ctl = phy_read(phydev, MII_BMCR);
|
|
|
|
|
|
|
|
if (ctl < 0)
|
|
|
|
return ctl;
|
|
|
|
|
|
|
|
if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
|
|
|
|
changed = 1; /* do restart aneg */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only restart aneg if we are advertising something different
|
|
|
|
* than we were before.
|
|
|
|
*/
|
|
|
|
if (changed > 0)
|
|
|
|
return genphy_restart_aneg(phydev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_c37_config_aneg);
|
|
|
|
|
2014-02-12 09:27:36 +08:00
|
|
|
/**
|
|
|
|
* genphy_aneg_done - return auto-negotiation status
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Reads the status register and returns 0 either if
|
|
|
|
* auto-negotiation is incomplete, or if there was an error.
|
|
|
|
* Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
|
|
|
|
*/
|
|
|
|
int genphy_aneg_done(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int retval = phy_read(phydev, MII_BMSR);
|
|
|
|
|
|
|
|
return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_aneg_done);
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* genphy_update_link - update link status in @phydev
|
|
|
|
* @phydev: target phy_device struct
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Update the value in phydev->link to reflect the
|
2005-07-31 07:31:23 +08:00
|
|
|
* current link value. In order to do this, we need to read
|
2007-03-06 18:41:48 +08:00
|
|
|
* the status register twice, keeping the second value.
|
2005-07-31 07:31:23 +08:00
|
|
|
*/
|
|
|
|
int genphy_update_link(struct phy_device *phydev)
|
|
|
|
{
|
2019-08-13 03:20:02 +08:00
|
|
|
int status = 0, bmcr;
|
|
|
|
|
|
|
|
bmcr = phy_read(phydev, MII_BMCR);
|
|
|
|
if (bmcr < 0)
|
|
|
|
return bmcr;
|
|
|
|
|
|
|
|
/* Autoneg is being started, therefore disregard BMSR value and
|
|
|
|
* report link as down.
|
|
|
|
*/
|
|
|
|
if (bmcr & BMCR_ANRESTART)
|
|
|
|
goto done;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-02-07 02:39:52 +08:00
|
|
|
/* The link state is latched low so that momentary link
|
|
|
|
* drops can be detected. Do not double-read the status
|
phy: avoid unnecessary link-up delay in polling mode
commit 93c0970493c71f ("net: phy: consider latched link-down status in
polling mode") removed double-read of latched link-state register for
polling mode from genphy_update_link(). This added extra ~1s delay into
sequence link down->up.
Following scenario:
- After boot link goes up
- phy_start() is called triggering an aneg restart, hence link goes
down and link-down info is latched.
- After aneg has finished link goes up. In phy_state_machine is checked
link state but it is latched "link is down". The state machine is
scheduled after one second and there is detected "link is up". This
extra delay can be avoided when we keep link-state register double read
in case when link was down previously.
With this solution we don't miss a link-down event in polling mode and
link-up is faster.
Details about this quirky behavior on Realtek phy:
Without patch:
T0: aneg is started, link goes down, link-down status is latched
T0+3s: state machine runs, up-to-date link-down is read
T0+4s: state machine runs, aneg is finished (BMSR_ANEGCOMPLETE==1),
here i read link-down (BMSR_LSTATUS==0),
T0+5s: state machine runs, aneg is finished (BMSR_ANEGCOMPLETE==1),
up-to-date link-up is read (BMSR_LSTATUS==1),
phydev->link goes up, state change PHY_NOLINK to PHY_RUNNING
With patch:
T0: aneg is started, link goes down, link-down status is latched
T0+3s: state machine runs, up-to-date link-down is read
T0+4s: state machine runs, aneg is finished (BMSR_ANEGCOMPLETE==1),
first BMSR read: BMSR_ANEGCOMPLETE==1 and BMSR_LSTATUS==0,
second BMSR read: BMSR_ANEGCOMPLETE==1 and BMSR_LSTATUS==1,
phydev->link goes up, state change PHY_NOLINK to PHY_RUNNING
Signed-off-by: Petr Oros <poros@redhat.com>
Reviewed-by: Heiner Kallweit <hkallweit1@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-02-18 17:35:55 +08:00
|
|
|
* in polling mode to detect such short link drops except
|
|
|
|
* the link was already down.
|
2019-02-07 02:39:52 +08:00
|
|
|
*/
|
phy: avoid unnecessary link-up delay in polling mode
commit 93c0970493c71f ("net: phy: consider latched link-down status in
polling mode") removed double-read of latched link-state register for
polling mode from genphy_update_link(). This added extra ~1s delay into
sequence link down->up.
Following scenario:
- After boot link goes up
- phy_start() is called triggering an aneg restart, hence link goes
down and link-down info is latched.
- After aneg has finished link goes up. In phy_state_machine is checked
link state but it is latched "link is down". The state machine is
scheduled after one second and there is detected "link is up". This
extra delay can be avoided when we keep link-state register double read
in case when link was down previously.
With this solution we don't miss a link-down event in polling mode and
link-up is faster.
Details about this quirky behavior on Realtek phy:
Without patch:
T0: aneg is started, link goes down, link-down status is latched
T0+3s: state machine runs, up-to-date link-down is read
T0+4s: state machine runs, aneg is finished (BMSR_ANEGCOMPLETE==1),
here i read link-down (BMSR_LSTATUS==0),
T0+5s: state machine runs, aneg is finished (BMSR_ANEGCOMPLETE==1),
up-to-date link-up is read (BMSR_LSTATUS==1),
phydev->link goes up, state change PHY_NOLINK to PHY_RUNNING
With patch:
T0: aneg is started, link goes down, link-down status is latched
T0+3s: state machine runs, up-to-date link-down is read
T0+4s: state machine runs, aneg is finished (BMSR_ANEGCOMPLETE==1),
first BMSR read: BMSR_ANEGCOMPLETE==1 and BMSR_LSTATUS==0,
second BMSR read: BMSR_ANEGCOMPLETE==1 and BMSR_LSTATUS==1,
phydev->link goes up, state change PHY_NOLINK to PHY_RUNNING
Signed-off-by: Petr Oros <poros@redhat.com>
Reviewed-by: Heiner Kallweit <hkallweit1@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-02-18 17:35:55 +08:00
|
|
|
if (!phy_polling_mode(phydev) || !phydev->link) {
|
2019-02-07 02:39:52 +08:00
|
|
|
status = phy_read(phydev, MII_BMSR);
|
2019-04-09 01:28:28 +08:00
|
|
|
if (status < 0)
|
2019-02-07 02:39:52 +08:00
|
|
|
return status;
|
2019-04-09 01:28:28 +08:00
|
|
|
else if (status & BMSR_LSTATUS)
|
|
|
|
goto done;
|
2019-02-07 02:39:52 +08:00
|
|
|
}
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
/* Read link and autonegotiation status */
|
|
|
|
status = phy_read(phydev, MII_BMSR);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
2019-04-09 01:28:28 +08:00
|
|
|
done:
|
2019-04-03 02:43:30 +08:00
|
|
|
phydev->link = status & BMSR_LSTATUS ? 1 : 0;
|
|
|
|
phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-08-01 05:05:10 +08:00
|
|
|
/* Consider the case that autoneg was started and "aneg complete"
|
|
|
|
* bit has been reset, but "link up" bit not yet.
|
|
|
|
*/
|
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
|
|
|
|
phydev->link = 0;
|
|
|
|
|
2005-07-31 07:31:23 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2006-10-17 05:19:17 +08:00
|
|
|
EXPORT_SYMBOL(genphy_update_link);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-10-05 00:06:04 +08:00
|
|
|
int genphy_read_lpa(struct phy_device *phydev)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
2019-10-05 00:06:04 +08:00
|
|
|
int lpa, lpagb;
|
2019-03-30 17:22:45 +08:00
|
|
|
|
2019-10-16 10:30:39 +08:00
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE) {
|
|
|
|
if (!phydev->autoneg_complete) {
|
|
|
|
mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
|
|
|
|
0);
|
|
|
|
mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-04-06 03:23:13 +08:00
|
|
|
if (phydev->is_gigabit_capable) {
|
2005-07-31 07:31:23 +08:00
|
|
|
lpagb = phy_read(phydev, MII_STAT1000);
|
|
|
|
if (lpagb < 0)
|
|
|
|
return lpagb;
|
|
|
|
|
2018-07-21 21:48:47 +08:00
|
|
|
if (lpagb & LPA_1000MSFAIL) {
|
2019-08-15 19:15:19 +08:00
|
|
|
int adv = phy_read(phydev, MII_CTRL1000);
|
|
|
|
|
|
|
|
if (adv < 0)
|
|
|
|
return adv;
|
|
|
|
|
2018-07-21 21:48:47 +08:00
|
|
|
if (adv & CTL1000_ENABLE_MASTER)
|
|
|
|
phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
|
|
|
|
else
|
|
|
|
phydev_err(phydev, "Master/Slave resolution failed\n");
|
|
|
|
return -ENOLINK;
|
|
|
|
}
|
|
|
|
|
2018-12-06 04:49:41 +08:00
|
|
|
mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
|
|
|
|
lpagb);
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
lpa = phy_read(phydev, MII_LPA);
|
|
|
|
if (lpa < 0)
|
|
|
|
return lpa;
|
|
|
|
|
2018-12-06 04:49:43 +08:00
|
|
|
mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
|
2019-10-16 10:30:39 +08:00
|
|
|
} else {
|
|
|
|
linkmode_zero(phydev->lp_advertising);
|
2019-10-05 00:06:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_read_lpa);
|
|
|
|
|
2019-12-17 21:39:16 +08:00
|
|
|
/**
|
|
|
|
* genphy_read_status_fixed - read the link parameters for !aneg mode
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Read the current duplex and speed state for a PHY operating with
|
|
|
|
* autonegotiation disabled.
|
|
|
|
*/
|
|
|
|
int genphy_read_status_fixed(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int bmcr = phy_read(phydev, MII_BMCR);
|
|
|
|
|
|
|
|
if (bmcr < 0)
|
|
|
|
return bmcr;
|
|
|
|
|
|
|
|
if (bmcr & BMCR_FULLDPLX)
|
|
|
|
phydev->duplex = DUPLEX_FULL;
|
|
|
|
else
|
|
|
|
phydev->duplex = DUPLEX_HALF;
|
|
|
|
|
|
|
|
if (bmcr & BMCR_SPEED1000)
|
|
|
|
phydev->speed = SPEED_1000;
|
|
|
|
else if (bmcr & BMCR_SPEED100)
|
|
|
|
phydev->speed = SPEED_100;
|
|
|
|
else
|
|
|
|
phydev->speed = SPEED_10;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_read_status_fixed);
|
|
|
|
|
2019-10-05 00:06:04 +08:00
|
|
|
/**
|
|
|
|
* genphy_read_status - check the link status and update current link state
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Check the link, then figure out the current state
|
|
|
|
* by comparing what we advertise with what the link partner
|
|
|
|
* advertises. Start by checking the gigabit possibilities,
|
|
|
|
* then move on to 10/100.
|
|
|
|
*/
|
|
|
|
int genphy_read_status(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err, old_link = phydev->link;
|
|
|
|
|
|
|
|
/* Update the link, but return if there was an error */
|
|
|
|
err = genphy_update_link(phydev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* why bother the PHY if nothing can have changed */
|
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
phydev->speed = SPEED_UNKNOWN;
|
|
|
|
phydev->duplex = DUPLEX_UNKNOWN;
|
|
|
|
phydev->pause = 0;
|
|
|
|
phydev->asym_pause = 0;
|
|
|
|
|
2020-05-05 14:35:05 +08:00
|
|
|
err = genphy_read_master_slave(phydev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2019-10-05 00:06:04 +08:00
|
|
|
err = genphy_read_lpa(phydev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
|
2019-02-15 05:16:27 +08:00
|
|
|
phy_resolve_aneg_linkmode(phydev);
|
2019-03-30 17:22:45 +08:00
|
|
|
} else if (phydev->autoneg == AUTONEG_DISABLE) {
|
2019-12-17 21:39:16 +08:00
|
|
|
err = genphy_read_status_fixed(phydev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_read_status);
|
|
|
|
|
2019-10-23 02:31:07 +08:00
|
|
|
/**
|
|
|
|
* genphy_c37_read_status - check the link status and update current link state
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Check the link, then figure out the current state
|
|
|
|
* by comparing what we advertise with what the link partner
|
|
|
|
* advertises. This function is for Clause 37 1000Base-X mode.
|
|
|
|
*/
|
|
|
|
int genphy_c37_read_status(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int lpa, err, old_link = phydev->link;
|
|
|
|
|
|
|
|
/* Update the link, but return if there was an error */
|
|
|
|
err = genphy_update_link(phydev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* why bother the PHY if nothing can have changed */
|
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
phydev->duplex = DUPLEX_UNKNOWN;
|
|
|
|
phydev->pause = 0;
|
|
|
|
phydev->asym_pause = 0;
|
|
|
|
|
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
|
|
|
|
lpa = phy_read(phydev, MII_LPA);
|
|
|
|
if (lpa < 0)
|
|
|
|
return lpa;
|
|
|
|
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
|
|
|
|
phydev->lp_advertising, lpa & LPA_LPACK);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
|
|
|
|
phydev->lp_advertising, lpa & LPA_1000XFULL);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
|
|
|
|
phydev->lp_advertising, lpa & LPA_1000XPAUSE);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
|
|
|
|
phydev->lp_advertising,
|
|
|
|
lpa & LPA_1000XPAUSE_ASYM);
|
|
|
|
|
|
|
|
phy_resolve_aneg_linkmode(phydev);
|
|
|
|
} else if (phydev->autoneg == AUTONEG_DISABLE) {
|
|
|
|
int bmcr = phy_read(phydev, MII_BMCR);
|
|
|
|
|
|
|
|
if (bmcr < 0)
|
|
|
|
return bmcr;
|
|
|
|
|
|
|
|
if (bmcr & BMCR_FULLDPLX)
|
|
|
|
phydev->duplex = DUPLEX_FULL;
|
|
|
|
else
|
|
|
|
phydev->duplex = DUPLEX_HALF;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_c37_read_status);
|
|
|
|
|
2014-02-18 05:34:02 +08:00
|
|
|
/**
|
|
|
|
* genphy_soft_reset - software reset the PHY via BMCR_RESET bit
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Perform a software PHY reset using the standard
|
|
|
|
* BMCR_RESET bit and poll for the reset bit to be cleared.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, < 0 on failure
|
|
|
|
*/
|
|
|
|
int genphy_soft_reset(struct phy_device *phydev)
|
|
|
|
{
|
2019-04-25 03:41:06 +08:00
|
|
|
u16 res = BMCR_RESET;
|
2014-02-18 05:34:02 +08:00
|
|
|
int ret;
|
|
|
|
|
2019-04-25 03:41:06 +08:00
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE)
|
|
|
|
res |= BMCR_ANRESTART;
|
|
|
|
|
|
|
|
ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
|
2014-02-18 05:34:02 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2020-04-24 03:38:42 +08:00
|
|
|
/* Clause 22 states that setting bit BMCR_RESET sets control registers
|
|
|
|
* to their default value. Therefore the POWER DOWN bit is supposed to
|
|
|
|
* be cleared after soft reset.
|
|
|
|
*/
|
|
|
|
phydev->suspended = 0;
|
|
|
|
|
2019-04-25 03:41:06 +08:00
|
|
|
ret = phy_poll_reset(phydev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* BMCR may be reset to defaults */
|
|
|
|
if (phydev->autoneg == AUTONEG_DISABLE)
|
|
|
|
ret = genphy_setup_forced(phydev);
|
|
|
|
|
|
|
|
return ret;
|
2014-02-18 05:34:02 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_soft_reset);
|
|
|
|
|
2019-03-28 04:58:44 +08:00
|
|
|
/**
|
|
|
|
* genphy_read_abilities - read PHY abilities from Clause 22 registers
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Reads the PHY's abilities and populates
|
|
|
|
* phydev->supported accordingly.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, < 0 on failure
|
|
|
|
*/
|
|
|
|
int genphy_read_abilities(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int val;
|
|
|
|
|
|
|
|
linkmode_set_bit_array(phy_basic_ports_array,
|
|
|
|
ARRAY_SIZE(phy_basic_ports_array),
|
|
|
|
phydev->supported);
|
|
|
|
|
|
|
|
val = phy_read(phydev, MII_BMSR);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
|
|
|
|
val & BMSR_ANEGCAPABLE);
|
|
|
|
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
|
|
|
|
val & BMSR_100FULL);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
|
|
|
|
val & BMSR_100HALF);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
|
|
|
|
val & BMSR_10FULL);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
|
|
|
|
val & BMSR_10HALF);
|
|
|
|
|
|
|
|
if (val & BMSR_ESTATEN) {
|
|
|
|
val = phy_read(phydev, MII_ESTATUS);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
|
|
|
|
phydev->supported, val & ESTATUS_1000_TFULL);
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
|
|
|
|
phydev->supported, val & ESTATUS_1000_THALF);
|
2019-06-12 06:06:09 +08:00
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
|
|
|
|
phydev->supported, val & ESTATUS_1000_XFULL);
|
2019-03-28 04:58:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_read_abilities);
|
|
|
|
|
2018-03-20 09:44:52 +08:00
|
|
|
/* This is used for the phy device which doesn't support the MMD extended
|
|
|
|
* register access, but it does have side effect when we are trying to access
|
|
|
|
* the MMD register via indirect method.
|
|
|
|
*/
|
|
|
|
int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
|
|
|
|
{
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_read_mmd_unsupported);
|
|
|
|
|
|
|
|
int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
|
|
|
|
u16 regnum, u16 val)
|
|
|
|
{
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_write_mmd_unsupported);
|
|
|
|
|
2008-11-29 08:24:56 +08:00
|
|
|
int genphy_suspend(struct phy_device *phydev)
|
|
|
|
{
|
2018-01-13 04:20:36 +08:00
|
|
|
return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
|
2008-11-29 08:24:56 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_suspend);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2008-11-29 08:24:56 +08:00
|
|
|
int genphy_resume(struct phy_device *phydev)
|
|
|
|
{
|
2018-01-13 04:20:36 +08:00
|
|
|
return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
|
2008-11-29 08:24:56 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_resume);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2017-06-30 17:44:15 +08:00
|
|
|
int genphy_loopback(struct phy_device *phydev, bool enable)
|
|
|
|
{
|
2018-01-06 00:07:10 +08:00
|
|
|
return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
|
2018-01-02 18:58:58 +08:00
|
|
|
enable ? BMCR_LOOPBACK : 0);
|
2017-06-30 17:44:15 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(genphy_loopback);
|
|
|
|
|
2018-09-12 07:53:14 +08:00
|
|
|
/**
|
|
|
|
* phy_remove_link_mode - Remove a supported link mode
|
|
|
|
* @phydev: phy_device structure to remove link mode from
|
|
|
|
* @link_mode: Link mode to be removed
|
|
|
|
*
|
|
|
|
* Description: Some MACs don't support all link modes which the PHY
|
|
|
|
* does. e.g. a 1G MAC often does not support 1000Half. Add a helper
|
|
|
|
* to remove a link mode.
|
|
|
|
*/
|
|
|
|
void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
|
|
|
|
{
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_clear_bit(link_mode, phydev->supported);
|
2019-05-02 03:34:43 +08:00
|
|
|
phy_advertise_supported(phydev);
|
2018-09-12 07:53:14 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_remove_link_mode);
|
|
|
|
|
2019-05-02 03:34:43 +08:00
|
|
|
static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
|
|
|
|
{
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
|
|
|
|
linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
|
|
|
|
linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
|
|
|
|
linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* phy_advertise_supported - Advertise all supported modes
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Called to advertise all supported modes, doesn't touch
|
|
|
|
* pause mode advertising.
|
|
|
|
*/
|
|
|
|
void phy_advertise_supported(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(new);
|
|
|
|
|
|
|
|
linkmode_copy(new, phydev->supported);
|
|
|
|
phy_copy_pause_bits(new, phydev->advertising);
|
|
|
|
linkmode_copy(phydev->advertising, new);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_advertise_supported);
|
|
|
|
|
2018-09-12 07:53:16 +08:00
|
|
|
/**
|
|
|
|
* phy_support_sym_pause - Enable support of symmetrical pause
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Called by the MAC to indicate is supports symmetrical
|
|
|
|
* Pause, but not asym pause.
|
|
|
|
*/
|
|
|
|
void phy_support_sym_pause(struct phy_device *phydev)
|
|
|
|
{
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
|
2019-05-02 03:34:43 +08:00
|
|
|
phy_copy_pause_bits(phydev->advertising, phydev->supported);
|
2018-09-12 07:53:16 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_support_sym_pause);
|
|
|
|
|
2018-09-12 07:53:15 +08:00
|
|
|
/**
|
|
|
|
* phy_support_asym_pause - Enable support of asym pause
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
*
|
|
|
|
* Description: Called by the MAC to indicate is supports Asym Pause.
|
|
|
|
*/
|
|
|
|
void phy_support_asym_pause(struct phy_device *phydev)
|
|
|
|
{
|
2019-05-02 03:34:43 +08:00
|
|
|
phy_copy_pause_bits(phydev->advertising, phydev->supported);
|
2018-09-12 07:53:15 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_support_asym_pause);
|
|
|
|
|
2018-09-12 07:53:18 +08:00
|
|
|
/**
|
|
|
|
* phy_set_sym_pause - Configure symmetric Pause
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
* @rx: Receiver Pause is supported
|
|
|
|
* @tx: Transmit Pause is supported
|
|
|
|
* @autoneg: Auto neg should be used
|
|
|
|
*
|
|
|
|
* Description: Configure advertised Pause support depending on if
|
|
|
|
* receiver pause and pause auto neg is supported. Generally called
|
|
|
|
* from the set_pauseparam .ndo.
|
|
|
|
*/
|
|
|
|
void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
|
|
|
|
bool autoneg)
|
|
|
|
{
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
|
2018-09-12 07:53:18 +08:00
|
|
|
|
|
|
|
if (rx && tx && autoneg)
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
|
|
|
|
phydev->supported);
|
2018-09-12 07:53:18 +08:00
|
|
|
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_copy(phydev->advertising, phydev->supported);
|
2018-09-12 07:53:18 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_set_sym_pause);
|
|
|
|
|
2018-09-12 07:53:17 +08:00
|
|
|
/**
|
|
|
|
* phy_set_asym_pause - Configure Pause and Asym Pause
|
|
|
|
* @phydev: target phy_device struct
|
|
|
|
* @rx: Receiver Pause is supported
|
|
|
|
* @tx: Transmit Pause is supported
|
|
|
|
*
|
|
|
|
* Description: Configure advertised Pause support depending on if
|
|
|
|
* transmit and receiver pause is supported. If there has been a
|
|
|
|
* change in adverting, trigger a new autoneg. Generally called from
|
|
|
|
* the set_pauseparam .ndo.
|
|
|
|
*/
|
|
|
|
void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
|
|
|
|
{
|
2018-11-11 06:43:33 +08:00
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
|
2018-09-12 07:53:17 +08:00
|
|
|
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_copy(oldadv, phydev->advertising);
|
2020-02-15 23:49:32 +08:00
|
|
|
linkmode_set_pause(phydev->advertising, tx, rx);
|
2018-11-11 06:43:33 +08:00
|
|
|
|
|
|
|
if (!linkmode_equal(oldadv, phydev->advertising) &&
|
|
|
|
phydev->autoneg)
|
|
|
|
phy_start_aneg(phydev);
|
2018-09-12 07:53:17 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_set_asym_pause);
|
|
|
|
|
2018-09-12 07:53:19 +08:00
|
|
|
/**
|
|
|
|
* phy_validate_pause - Test if the PHY/MAC support the pause configuration
|
|
|
|
* @phydev: phy_device struct
|
|
|
|
* @pp: requested pause configuration
|
|
|
|
*
|
|
|
|
* Description: Test if the PHY/MAC combination supports the Pause
|
|
|
|
* configuration the user is requesting. Returns True if it is
|
|
|
|
* supported, false otherwise.
|
|
|
|
*/
|
|
|
|
bool phy_validate_pause(struct phy_device *phydev,
|
|
|
|
struct ethtool_pauseparam *pp)
|
|
|
|
{
|
2018-11-11 06:43:33 +08:00
|
|
|
if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
|
2019-05-02 03:54:28 +08:00
|
|
|
phydev->supported) && pp->rx_pause)
|
2018-09-12 07:53:19 +08:00
|
|
|
return false;
|
2019-05-02 03:54:28 +08:00
|
|
|
|
|
|
|
if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
|
|
|
|
phydev->supported) &&
|
|
|
|
pp->rx_pause != pp->tx_pause)
|
|
|
|
return false;
|
|
|
|
|
2018-09-12 07:53:19 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_validate_pause);
|
|
|
|
|
2020-02-15 23:49:27 +08:00
|
|
|
/**
|
|
|
|
* phy_get_pause - resolve negotiated pause modes
|
|
|
|
* @phydev: phy_device struct
|
|
|
|
* @tx_pause: pointer to bool to indicate whether transmit pause should be
|
|
|
|
* enabled.
|
|
|
|
* @rx_pause: pointer to bool to indicate whether receive pause should be
|
|
|
|
* enabled.
|
|
|
|
*
|
|
|
|
* Resolve and return the flow control modes according to the negotiation
|
|
|
|
* result. This includes checking that we are operating in full duplex mode.
|
|
|
|
* See linkmode_resolve_pause() for further details.
|
|
|
|
*/
|
|
|
|
void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
|
|
|
|
{
|
|
|
|
if (phydev->duplex != DUPLEX_FULL) {
|
|
|
|
*tx_pause = false;
|
|
|
|
*rx_pause = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
return linkmode_resolve_pause(phydev->advertising,
|
|
|
|
phydev->lp_advertising,
|
|
|
|
tx_pause, rx_pause);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_get_pause);
|
|
|
|
|
2018-11-10 01:16:28 +08:00
|
|
|
static bool phy_drv_supports_irq(struct phy_driver *phydrv)
|
|
|
|
{
|
2018-11-13 04:16:06 +08:00
|
|
|
return phydrv->config_intr && phydrv->ack_interrupt;
|
2018-11-10 01:16:28 +08:00
|
|
|
}
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* phy_probe - probe and init a PHY device
|
|
|
|
* @dev: device to probe and init
|
2005-07-31 07:31:23 +08:00
|
|
|
*
|
2007-03-06 18:41:48 +08:00
|
|
|
* Description: Take care of setting up the phy_device structure,
|
2005-07-31 07:31:23 +08:00
|
|
|
* set the state to READY (the driver's init function should
|
|
|
|
* set it to STARTING if needed).
|
|
|
|
*/
|
|
|
|
static int phy_probe(struct device *dev)
|
|
|
|
{
|
2014-01-05 08:23:19 +08:00
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
2016-01-07 03:11:16 +08:00
|
|
|
struct device_driver *drv = phydev->mdio.dev.driver;
|
2014-01-05 08:23:19 +08:00
|
|
|
struct phy_driver *phydrv = to_phy_driver(drv);
|
2005-07-31 07:31:23 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
phydev->drv = phydrv;
|
|
|
|
|
2013-05-20 06:53:42 +08:00
|
|
|
/* Disable the interrupt if the PHY doesn't support it
|
|
|
|
* but the interrupt is still a valid one
|
|
|
|
*/
|
2018-11-10 01:16:28 +08:00
|
|
|
if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
|
2005-07-31 07:31:23 +08:00
|
|
|
phydev->irq = PHY_POLL;
|
|
|
|
|
2013-05-23 09:11:12 +08:00
|
|
|
if (phydrv->flags & PHY_IS_INTERNAL)
|
|
|
|
phydev->is_internal = true;
|
|
|
|
|
2008-01-30 00:05:09 +08:00
|
|
|
mutex_lock(&phydev->lock);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-02-09 21:46:30 +08:00
|
|
|
if (phydev->drv->probe) {
|
|
|
|
/* Deassert the reset signal */
|
|
|
|
phy_device_reset(phydev, 0);
|
|
|
|
|
|
|
|
err = phydev->drv->probe(phydev);
|
|
|
|
if (err) {
|
|
|
|
/* Assert the reset signal */
|
|
|
|
phy_device_reset(phydev, 1);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-07-31 07:31:23 +08:00
|
|
|
/* Start out supporting everything. Eventually,
|
|
|
|
* a controller will attach, and may modify one
|
2014-01-05 08:17:06 +08:00
|
|
|
* or both of these values
|
|
|
|
*/
|
2019-02-09 22:24:47 +08:00
|
|
|
if (phydrv->features) {
|
|
|
|
linkmode_copy(phydev->supported, phydrv->features);
|
2019-04-04 05:14:33 +08:00
|
|
|
} else if (phydrv->get_features) {
|
2019-02-09 22:24:47 +08:00
|
|
|
err = phydrv->get_features(phydev);
|
2019-04-04 05:14:33 +08:00
|
|
|
} else if (phydev->is_c45) {
|
|
|
|
err = genphy_c45_pma_read_abilities(phydev);
|
|
|
|
} else {
|
|
|
|
err = genphy_read_abilities(phydev);
|
2019-02-09 22:24:47 +08:00
|
|
|
}
|
|
|
|
|
2019-04-04 05:14:33 +08:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2019-04-17 05:54:00 +08:00
|
|
|
if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
|
|
|
|
phydev->supported))
|
|
|
|
phydev->autoneg = 0;
|
|
|
|
|
2019-04-06 03:23:13 +08:00
|
|
|
if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
|
|
|
|
phydev->supported))
|
|
|
|
phydev->is_gigabit_capable = 1;
|
|
|
|
if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
|
|
|
|
phydev->supported))
|
|
|
|
phydev->is_gigabit_capable = 1;
|
|
|
|
|
2014-05-21 21:29:45 +08:00
|
|
|
of_set_phy_supported(phydev);
|
2019-05-02 03:34:43 +08:00
|
|
|
phy_advertise_supported(phydev);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2016-11-28 17:46:46 +08:00
|
|
|
/* Get the EEE modes we want to prohibit. We will ask
|
|
|
|
* the PHY stop advertising these mode later on
|
|
|
|
*/
|
|
|
|
of_set_phy_eee_broken(phydev);
|
|
|
|
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
/* The Pause Frame bits indicate that the PHY can support passing
|
|
|
|
* pause frames. During autonegotiation, the PHYs will determine if
|
|
|
|
* they should allow pause frames to pass. The MAC driver should then
|
|
|
|
* use that result to determine whether to enable flow control via
|
|
|
|
* pause frames.
|
|
|
|
*
|
|
|
|
* Normally, PHY drivers should not set the Pause bits, and instead
|
|
|
|
* allow phylib to do that. However, there may be some situations
|
|
|
|
* (e.g. hardware erratum) where the driver wants to set only one
|
|
|
|
* of these bits.
|
|
|
|
*/
|
2019-02-09 22:24:47 +08:00
|
|
|
if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
|
|
|
|
!test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
|
2018-11-11 06:43:33 +08:00
|
|
|
linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
|
|
|
|
phydev->supported);
|
|
|
|
linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
|
|
|
|
phydev->supported);
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
}
|
|
|
|
|
2005-07-31 07:31:23 +08:00
|
|
|
/* Set the state to READY by default */
|
|
|
|
phydev->state = PHY_READY;
|
|
|
|
|
2019-02-09 21:46:30 +08:00
|
|
|
out:
|
2008-01-30 00:05:09 +08:00
|
|
|
mutex_unlock(&phydev->lock);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int phy_remove(struct device *dev)
|
|
|
|
{
|
2014-01-05 08:23:19 +08:00
|
|
|
struct phy_device *phydev = to_phy_device(dev);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2017-02-18 08:07:33 +08:00
|
|
|
cancel_delayed_work_sync(&phydev->state_queue);
|
|
|
|
|
2008-01-30 00:05:09 +08:00
|
|
|
mutex_lock(&phydev->lock);
|
2005-07-31 07:31:23 +08:00
|
|
|
phydev->state = PHY_DOWN;
|
2008-01-30 00:05:09 +08:00
|
|
|
mutex_unlock(&phydev->lock);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2019-11-16 03:56:51 +08:00
|
|
|
sfp_bus_del_upstream(phydev->sfp_bus);
|
|
|
|
phydev->sfp_bus = NULL;
|
|
|
|
|
2017-12-04 20:35:05 +08:00
|
|
|
if (phydev->drv && phydev->drv->remove) {
|
2005-07-31 07:31:23 +08:00
|
|
|
phydev->drv->remove(phydev);
|
2017-12-04 20:35:05 +08:00
|
|
|
|
|
|
|
/* Assert the reset signal */
|
|
|
|
phy_device_reset(phydev, 1);
|
|
|
|
}
|
2005-07-31 07:31:23 +08:00
|
|
|
phydev->drv = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-06 18:41:48 +08:00
|
|
|
/**
|
|
|
|
* phy_driver_register - register a phy_driver with the PHY layer
|
|
|
|
* @new_driver: new phy_driver to register
|
2016-01-07 03:11:22 +08:00
|
|
|
* @owner: module owning this PHY
|
2007-03-06 18:41:48 +08:00
|
|
|
*/
|
2016-01-07 03:11:22 +08:00
|
|
|
int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
2019-02-09 22:24:47 +08:00
|
|
|
/* Either the features are hard coded, or dynamically
|
2019-04-04 05:14:33 +08:00
|
|
|
* determined. It cannot be both.
|
2019-02-09 22:24:47 +08:00
|
|
|
*/
|
2019-04-04 05:14:33 +08:00
|
|
|
if (WARN_ON(new_driver->features && new_driver->get_features)) {
|
|
|
|
pr_err("%s: features and get_features must not both be set\n",
|
|
|
|
new_driver->name);
|
2019-01-17 20:22:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-01-07 03:11:26 +08:00
|
|
|
new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
|
|
|
|
new_driver->mdiodrv.driver.name = new_driver->name;
|
|
|
|
new_driver->mdiodrv.driver.bus = &mdio_bus_type;
|
|
|
|
new_driver->mdiodrv.driver.probe = phy_probe;
|
|
|
|
new_driver->mdiodrv.driver.remove = phy_remove;
|
|
|
|
new_driver->mdiodrv.driver.owner = owner;
|
2020-03-27 08:00:22 +08:00
|
|
|
new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2016-01-07 03:11:26 +08:00
|
|
|
retval = driver_register(&new_driver->mdiodrv.driver);
|
2005-07-31 07:31:23 +08:00
|
|
|
if (retval) {
|
2012-06-09 15:49:07 +08:00
|
|
|
pr_err("%s: Error %d in registering driver\n",
|
|
|
|
new_driver->name, retval);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-11-05 06:09:23 +08:00
|
|
|
pr_debug("%s: Registered new driver\n", new_driver->name);
|
2005-07-31 07:31:23 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_driver_register);
|
|
|
|
|
2016-01-07 03:11:22 +08:00
|
|
|
int phy_drivers_register(struct phy_driver *new_driver, int n,
|
|
|
|
struct module *owner)
|
2012-07-04 13:44:34 +08:00
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
2016-01-07 03:11:22 +08:00
|
|
|
ret = phy_driver_register(new_driver + i, owner);
|
2012-07-04 13:44:34 +08:00
|
|
|
if (ret) {
|
|
|
|
while (i-- > 0)
|
|
|
|
phy_driver_unregister(new_driver + i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_drivers_register);
|
|
|
|
|
2005-07-31 07:31:23 +08:00
|
|
|
void phy_driver_unregister(struct phy_driver *drv)
|
|
|
|
{
|
2016-01-07 03:11:26 +08:00
|
|
|
driver_unregister(&drv->mdiodrv.driver);
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_driver_unregister);
|
|
|
|
|
2012-07-04 13:44:34 +08:00
|
|
|
void phy_drivers_unregister(struct phy_driver *drv, int n)
|
|
|
|
{
|
|
|
|
int i;
|
2014-01-05 08:17:06 +08:00
|
|
|
|
|
|
|
for (i = 0; i < n; i++)
|
2012-07-04 13:44:34 +08:00
|
|
|
phy_driver_unregister(drv + i);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(phy_drivers_unregister);
|
|
|
|
|
2017-06-05 19:23:05 +08:00
|
|
|
static struct phy_driver genphy_driver = {
|
2005-08-25 07:46:21 +08:00
|
|
|
.phy_id = 0xffffffff,
|
|
|
|
.phy_id_mask = 0xffffffff,
|
|
|
|
.name = "Generic PHY",
|
2019-03-28 04:59:33 +08:00
|
|
|
.get_features = genphy_read_abilities,
|
2008-11-29 08:24:56 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2017-06-30 17:44:15 +08:00
|
|
|
.set_loopback = genphy_loopback,
|
2017-06-05 19:23:05 +08:00
|
|
|
};
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2005-08-11 14:07:25 +08:00
|
|
|
static int __init phy_init(void)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
2005-08-11 14:07:25 +08:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = mdio_bus_init();
|
|
|
|
if (rc)
|
2005-08-25 07:46:21 +08:00
|
|
|
return rc;
|
2005-07-31 07:31:23 +08:00
|
|
|
|
2018-09-30 05:04:16 +08:00
|
|
|
features_init();
|
|
|
|
|
2019-04-07 19:55:01 +08:00
|
|
|
rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
|
2005-08-25 07:46:21 +08:00
|
|
|
if (rc)
|
2019-04-07 19:55:01 +08:00
|
|
|
goto err_c45;
|
2017-06-05 19:23:05 +08:00
|
|
|
|
|
|
|
rc = phy_driver_register(&genphy_driver, THIS_MODULE);
|
|
|
|
if (rc) {
|
2019-04-07 19:55:01 +08:00
|
|
|
phy_driver_unregister(&genphy_c45_driver);
|
|
|
|
err_c45:
|
2005-08-25 07:46:21 +08:00
|
|
|
mdio_bus_exit();
|
2017-06-05 19:23:05 +08:00
|
|
|
}
|
2005-08-11 14:07:25 +08:00
|
|
|
|
|
|
|
return rc;
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
|
|
|
|
2005-08-11 14:07:25 +08:00
|
|
|
static void __exit phy_exit(void)
|
2005-07-31 07:31:23 +08:00
|
|
|
{
|
2019-04-07 19:55:01 +08:00
|
|
|
phy_driver_unregister(&genphy_c45_driver);
|
2017-06-05 19:23:05 +08:00
|
|
|
phy_driver_unregister(&genphy_driver);
|
2005-08-25 07:46:21 +08:00
|
|
|
mdio_bus_exit();
|
2005-07-31 07:31:23 +08:00
|
|
|
}
|
|
|
|
|
2005-08-25 07:46:21 +08:00
|
|
|
subsys_initcall(phy_init);
|
2005-08-11 14:07:25 +08:00
|
|
|
module_exit(phy_exit);
|