2019-01-21 21:05:50 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2012-10-14 23:07:16 +04:00
|
|
|
/*
|
|
|
|
* drivers/net/phy/at803x.c
|
|
|
|
*
|
2019-11-07 01:36:16 +03:00
|
|
|
* Driver for Qualcomm Atheros AR803x PHY
|
2012-10-14 23:07:16 +04:00
|
|
|
*
|
|
|
|
* Author: Matus Ujhelyi <ujhelyi.m@gmail.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/phy.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
#include <linux/ethtool_netlink.h>
|
2014-06-18 13:01:43 +04:00
|
|
|
#include <linux/of_gpio.h>
|
2019-11-07 01:36:14 +03:00
|
|
|
#include <linux/bitfield.h>
|
2014-06-18 13:01:43 +04:00
|
|
|
#include <linux/gpio/consumer.h>
|
2019-11-07 01:36:14 +03:00
|
|
|
#include <linux/regulator/of_regulator.h>
|
|
|
|
#include <linux/regulator/driver.h>
|
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include <dt-bindings/net/qca-ar803x.h>
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2020-07-19 11:05:30 +03:00
|
|
|
#define AT803X_SPECIFIC_FUNCTION_CONTROL 0x10
|
|
|
|
#define AT803X_SFC_ASSERT_CRS BIT(11)
|
|
|
|
#define AT803X_SFC_FORCE_LINK BIT(10)
|
|
|
|
#define AT803X_SFC_MDI_CROSSOVER_MODE_M GENMASK(6, 5)
|
|
|
|
#define AT803X_SFC_AUTOMATIC_CROSSOVER 0x3
|
|
|
|
#define AT803X_SFC_MANUAL_MDIX 0x1
|
|
|
|
#define AT803X_SFC_MANUAL_MDI 0x0
|
|
|
|
#define AT803X_SFC_SQE_TEST BIT(2)
|
|
|
|
#define AT803X_SFC_POLARITY_REVERSAL BIT(1)
|
|
|
|
#define AT803X_SFC_DISABLE_JABBER BIT(0)
|
|
|
|
|
2019-10-04 19:06:14 +03:00
|
|
|
#define AT803X_SPECIFIC_STATUS 0x11
|
|
|
|
#define AT803X_SS_SPEED_MASK (3 << 14)
|
|
|
|
#define AT803X_SS_SPEED_1000 (2 << 14)
|
|
|
|
#define AT803X_SS_SPEED_100 (1 << 14)
|
|
|
|
#define AT803X_SS_SPEED_10 (0 << 14)
|
|
|
|
#define AT803X_SS_DUPLEX BIT(13)
|
|
|
|
#define AT803X_SS_SPEED_DUPLEX_RESOLVED BIT(11)
|
|
|
|
#define AT803X_SS_MDIX BIT(6)
|
|
|
|
|
2012-10-14 23:07:16 +04:00
|
|
|
#define AT803X_INTR_ENABLE 0x12
|
2016-01-15 03:55:24 +03:00
|
|
|
#define AT803X_INTR_ENABLE_AUTONEG_ERR BIT(15)
|
|
|
|
#define AT803X_INTR_ENABLE_SPEED_CHANGED BIT(14)
|
|
|
|
#define AT803X_INTR_ENABLE_DUPLEX_CHANGED BIT(13)
|
|
|
|
#define AT803X_INTR_ENABLE_PAGE_RECEIVED BIT(12)
|
|
|
|
#define AT803X_INTR_ENABLE_LINK_FAIL BIT(11)
|
|
|
|
#define AT803X_INTR_ENABLE_LINK_SUCCESS BIT(10)
|
|
|
|
#define AT803X_INTR_ENABLE_WIRESPEED_DOWNGRADE BIT(5)
|
|
|
|
#define AT803X_INTR_ENABLE_POLARITY_CHANGED BIT(1)
|
|
|
|
#define AT803X_INTR_ENABLE_WOL BIT(0)
|
|
|
|
|
2012-10-14 23:07:16 +04:00
|
|
|
#define AT803X_INTR_STATUS 0x13
|
2016-01-15 03:55:23 +03:00
|
|
|
|
2014-06-18 13:01:43 +04:00
|
|
|
#define AT803X_SMART_SPEED 0x14
|
2020-04-29 00:15:02 +03:00
|
|
|
#define AT803X_SMART_SPEED_ENABLE BIT(5)
|
|
|
|
#define AT803X_SMART_SPEED_RETRY_LIMIT_MASK GENMASK(4, 2)
|
|
|
|
#define AT803X_SMART_SPEED_BYPASS_TIMER BIT(1)
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
#define AT803X_CDT 0x16
|
|
|
|
#define AT803X_CDT_MDI_PAIR_MASK GENMASK(9, 8)
|
|
|
|
#define AT803X_CDT_ENABLE_TEST BIT(0)
|
|
|
|
#define AT803X_CDT_STATUS 0x1c
|
|
|
|
#define AT803X_CDT_STATUS_STAT_NORMAL 0
|
|
|
|
#define AT803X_CDT_STATUS_STAT_SHORT 1
|
|
|
|
#define AT803X_CDT_STATUS_STAT_OPEN 2
|
|
|
|
#define AT803X_CDT_STATUS_STAT_FAIL 3
|
|
|
|
#define AT803X_CDT_STATUS_STAT_MASK GENMASK(9, 8)
|
|
|
|
#define AT803X_CDT_STATUS_DELTA_TIME_MASK GENMASK(7, 0)
|
2014-06-18 13:01:43 +04:00
|
|
|
#define AT803X_LED_CONTROL 0x18
|
2016-01-15 03:55:23 +03:00
|
|
|
|
2012-10-14 23:07:16 +04:00
|
|
|
#define AT803X_LOC_MAC_ADDR_0_15_OFFSET 0x804C
|
|
|
|
#define AT803X_LOC_MAC_ADDR_16_31_OFFSET 0x804B
|
|
|
|
#define AT803X_LOC_MAC_ADDR_32_47_OFFSET 0x804A
|
2016-10-24 13:40:54 +03:00
|
|
|
#define AT803X_REG_CHIP_CONFIG 0x1f
|
|
|
|
#define AT803X_BT_BX_REG_SEL 0x8000
|
2016-01-15 03:55:23 +03:00
|
|
|
|
2013-06-04 00:10:06 +04:00
|
|
|
#define AT803X_DEBUG_ADDR 0x1D
|
|
|
|
#define AT803X_DEBUG_DATA 0x1E
|
2016-01-15 03:55:23 +03:00
|
|
|
|
2016-10-24 13:40:54 +03:00
|
|
|
#define AT803X_MODE_CFG_MASK 0x0F
|
|
|
|
#define AT803X_MODE_CFG_SGMII 0x01
|
|
|
|
|
2021-05-15 00:00:14 +03:00
|
|
|
#define AT803X_PSSR 0x11 /*PHY-Specific Status Register*/
|
|
|
|
#define AT803X_PSSR_MR_AN_COMPLETE 0x0200
|
2016-10-24 13:40:54 +03:00
|
|
|
|
2021-10-10 01:46:18 +03:00
|
|
|
#define AT803X_DEBUG_ANALOG_TEST_CTRL 0x00
|
2021-10-10 01:46:16 +03:00
|
|
|
#define QCA8327_DEBUG_MANU_CTRL_EN BIT(2)
|
|
|
|
#define QCA8337_DEBUG_MANU_CTRL_EN GENMASK(3, 2)
|
2016-01-15 03:55:22 +03:00
|
|
|
#define AT803X_DEBUG_RX_CLK_DLY_EN BIT(15)
|
2016-01-15 03:55:23 +03:00
|
|
|
|
2021-10-10 01:46:18 +03:00
|
|
|
#define AT803X_DEBUG_SYSTEM_CTRL_MODE 0x05
|
2016-01-15 03:55:22 +03:00
|
|
|
#define AT803X_DEBUG_TX_CLK_DLY_EN BIT(8)
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2021-10-10 01:46:15 +03:00
|
|
|
#define AT803X_DEBUG_REG_HIB_CTRL 0x0b
|
|
|
|
#define AT803X_DEBUG_HIB_CTRL_SEL_RST_80U BIT(10)
|
|
|
|
#define AT803X_DEBUG_HIB_CTRL_EN_ANY_CHANGE BIT(13)
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
#define AT803X_DEBUG_REG_3C 0x3C
|
|
|
|
|
2021-10-10 01:46:18 +03:00
|
|
|
#define AT803X_DEBUG_REG_GREEN 0x3D
|
2021-10-10 01:46:15 +03:00
|
|
|
#define AT803X_DEBUG_GATE_CLK_IN1000 BIT(6)
|
2021-05-15 00:00:15 +03:00
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
#define AT803X_DEBUG_REG_1F 0x1F
|
|
|
|
#define AT803X_DEBUG_PLL_ON BIT(2)
|
|
|
|
#define AT803X_DEBUG_RGMII_1V8 BIT(3)
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
#define MDIO_AZ_DEBUG 0x800D
|
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
/* AT803x supports either the XTAL input pad, an internal PLL or the
|
|
|
|
* DSP as clock reference for the clock output pad. The XTAL reference
|
|
|
|
* is only used for 25 MHz output, all other frequencies need the PLL.
|
|
|
|
* The DSP as a clock reference is used in synchronous ethernet
|
|
|
|
* applications.
|
|
|
|
*
|
|
|
|
* By default the PLL is only enabled if there is a link. Otherwise
|
|
|
|
* the PHY will go into low power state and disabled the PLL. You can
|
|
|
|
* set the PLL_ON bit (see debug register 0x1f) to keep the PLL always
|
|
|
|
* enabled.
|
|
|
|
*/
|
|
|
|
#define AT803X_MMD7_CLK25M 0x8016
|
|
|
|
#define AT803X_CLK_OUT_MASK GENMASK(4, 2)
|
|
|
|
#define AT803X_CLK_OUT_25MHZ_XTAL 0
|
|
|
|
#define AT803X_CLK_OUT_25MHZ_DSP 1
|
|
|
|
#define AT803X_CLK_OUT_50MHZ_PLL 2
|
|
|
|
#define AT803X_CLK_OUT_50MHZ_DSP 3
|
|
|
|
#define AT803X_CLK_OUT_62_5MHZ_PLL 4
|
|
|
|
#define AT803X_CLK_OUT_62_5MHZ_DSP 5
|
|
|
|
#define AT803X_CLK_OUT_125MHZ_PLL 6
|
|
|
|
#define AT803X_CLK_OUT_125MHZ_DSP 7
|
|
|
|
|
2019-11-07 01:36:15 +03:00
|
|
|
/* The AR8035 has another mask which is compatible with the AR8031/AR8033 mask
|
|
|
|
* but doesn't support choosing between XTAL/PLL and DSP.
|
2019-11-07 01:36:14 +03:00
|
|
|
*/
|
|
|
|
#define AT8035_CLK_OUT_MASK GENMASK(4, 3)
|
|
|
|
|
|
|
|
#define AT803X_CLK_OUT_STRENGTH_MASK GENMASK(8, 7)
|
|
|
|
#define AT803X_CLK_OUT_STRENGTH_FULL 0
|
|
|
|
#define AT803X_CLK_OUT_STRENGTH_HALF 1
|
|
|
|
#define AT803X_CLK_OUT_STRENGTH_QUARTER 2
|
|
|
|
|
2021-05-15 00:00:14 +03:00
|
|
|
#define AT803X_DEFAULT_DOWNSHIFT 5
|
|
|
|
#define AT803X_MIN_DOWNSHIFT 2
|
|
|
|
#define AT803X_MAX_DOWNSHIFT 9
|
2020-04-29 00:15:02 +03:00
|
|
|
|
2021-01-14 13:45:49 +03:00
|
|
|
#define AT803X_MMD3_SMARTEEE_CTL1 0x805b
|
|
|
|
#define AT803X_MMD3_SMARTEEE_CTL2 0x805c
|
|
|
|
#define AT803X_MMD3_SMARTEEE_CTL3 0x805d
|
|
|
|
#define AT803X_MMD3_SMARTEEE_CTL3_LPI_EN BIT(8)
|
|
|
|
|
2021-05-15 00:00:14 +03:00
|
|
|
#define ATH9331_PHY_ID 0x004dd041
|
|
|
|
#define ATH8030_PHY_ID 0x004dd076
|
|
|
|
#define ATH8031_PHY_ID 0x004dd074
|
|
|
|
#define ATH8032_PHY_ID 0x004dd023
|
|
|
|
#define ATH8035_PHY_ID 0x004dd072
|
2020-05-22 12:53:31 +03:00
|
|
|
#define AT8030_PHY_ID_MASK 0xffffffef
|
2014-06-18 13:01:42 +04:00
|
|
|
|
2021-09-19 19:28:15 +03:00
|
|
|
#define QCA8327_A_PHY_ID 0x004dd033
|
|
|
|
#define QCA8327_B_PHY_ID 0x004dd034
|
2021-05-15 00:00:15 +03:00
|
|
|
#define QCA8337_PHY_ID 0x004dd036
|
2021-10-06 01:54:01 +03:00
|
|
|
#define QCA9561_PHY_ID 0x004dd042
|
2021-05-15 00:00:15 +03:00
|
|
|
#define QCA8K_PHY_ID_MASK 0xffffffff
|
|
|
|
|
|
|
|
#define QCA8K_DEVFLAGS_REVISION_MASK GENMASK(2, 0)
|
|
|
|
|
2021-05-15 00:00:14 +03:00
|
|
|
#define AT803X_PAGE_FIBER 0
|
|
|
|
#define AT803X_PAGE_COPPER 1
|
|
|
|
|
|
|
|
/* don't turn off internal PLL */
|
|
|
|
#define AT803X_KEEP_PLL_ENABLED BIT(0)
|
|
|
|
#define AT803X_DISABLE_SMARTEEE BIT(1)
|
2021-04-15 04:26:50 +03:00
|
|
|
|
2019-11-07 01:36:16 +03:00
|
|
|
MODULE_DESCRIPTION("Qualcomm Atheros AR803x PHY driver");
|
2012-10-14 23:07:16 +04:00
|
|
|
MODULE_AUTHOR("Matus Ujhelyi");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
enum stat_access_type {
|
|
|
|
PHY,
|
|
|
|
MMD
|
|
|
|
};
|
|
|
|
|
|
|
|
struct at803x_hw_stat {
|
|
|
|
const char *string;
|
|
|
|
u8 reg;
|
|
|
|
u32 mask;
|
|
|
|
enum stat_access_type access_type;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct at803x_hw_stat at803x_hw_stats[] = {
|
|
|
|
{ "phy_idle_errors", 0xa, GENMASK(7, 0), PHY},
|
|
|
|
{ "phy_receive_errors", 0x15, GENMASK(15, 0), PHY},
|
|
|
|
{ "eee_wake_errors", 0x16, GENMASK(15, 0), MMD},
|
|
|
|
};
|
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
struct at803x_priv {
|
|
|
|
int flags;
|
|
|
|
u16 clk_25m_reg;
|
|
|
|
u16 clk_25m_mask;
|
2021-01-14 13:45:49 +03:00
|
|
|
u8 smarteee_lpi_tw_1g;
|
|
|
|
u8 smarteee_lpi_tw_100m;
|
2019-11-07 01:36:14 +03:00
|
|
|
struct regulator_dev *vddio_rdev;
|
|
|
|
struct regulator_dev *vddh_rdev;
|
|
|
|
struct regulator *vddio;
|
2021-05-15 00:00:15 +03:00
|
|
|
u64 stats[ARRAY_SIZE(at803x_hw_stats)];
|
2019-11-07 01:36:14 +03:00
|
|
|
};
|
|
|
|
|
2014-06-18 13:01:43 +04:00
|
|
|
struct at803x_context {
|
|
|
|
u16 bmcr;
|
|
|
|
u16 advertise;
|
|
|
|
u16 control1000;
|
|
|
|
u16 int_enable;
|
|
|
|
u16 smart_speed;
|
|
|
|
u16 led_control;
|
|
|
|
};
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
static int at803x_debug_reg_write(struct phy_device *phydev, u16 reg, u16 data)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = phy_write(phydev, AT803X_DEBUG_ADDR, reg);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return phy_write(phydev, AT803X_DEBUG_DATA, data);
|
|
|
|
}
|
|
|
|
|
2016-01-15 03:55:22 +03:00
|
|
|
static int at803x_debug_reg_read(struct phy_device *phydev, u16 reg)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = phy_write(phydev, AT803X_DEBUG_ADDR, reg);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return phy_read(phydev, AT803X_DEBUG_DATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_debug_reg_mask(struct phy_device *phydev, u16 reg,
|
|
|
|
u16 clear, u16 set)
|
|
|
|
{
|
|
|
|
u16 val;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = at803x_debug_reg_read(phydev, reg);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
val = ret & 0xffff;
|
|
|
|
val &= ~clear;
|
|
|
|
val |= set;
|
|
|
|
|
|
|
|
return phy_write(phydev, AT803X_DEBUG_DATA, val);
|
|
|
|
}
|
|
|
|
|
2021-04-15 04:26:50 +03:00
|
|
|
static int at803x_write_page(struct phy_device *phydev, int page)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
int set;
|
|
|
|
|
|
|
|
if (page == AT803X_PAGE_COPPER) {
|
|
|
|
set = AT803X_BT_BX_REG_SEL;
|
|
|
|
mask = 0;
|
|
|
|
} else {
|
|
|
|
set = 0;
|
|
|
|
mask = AT803X_BT_BX_REG_SEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return __phy_modify(phydev, AT803X_REG_CHIP_CONFIG, mask, set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_read_page(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ccr = __phy_read(phydev, AT803X_REG_CHIP_CONFIG);
|
|
|
|
|
|
|
|
if (ccr < 0)
|
|
|
|
return ccr;
|
|
|
|
|
|
|
|
if (ccr & AT803X_BT_BX_REG_SEL)
|
|
|
|
return AT803X_PAGE_COPPER;
|
|
|
|
|
|
|
|
return AT803X_PAGE_FIBER;
|
|
|
|
}
|
|
|
|
|
2019-02-21 13:23:15 +03:00
|
|
|
static int at803x_enable_rx_delay(struct phy_device *phydev)
|
|
|
|
{
|
2021-10-10 01:46:18 +03:00
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_ANALOG_TEST_CTRL, 0,
|
2019-02-21 13:23:15 +03:00
|
|
|
AT803X_DEBUG_RX_CLK_DLY_EN);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_enable_tx_delay(struct phy_device *phydev)
|
|
|
|
{
|
2021-10-10 01:46:18 +03:00
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_SYSTEM_CTRL_MODE, 0,
|
2019-02-21 13:23:15 +03:00
|
|
|
AT803X_DEBUG_TX_CLK_DLY_EN);
|
|
|
|
}
|
|
|
|
|
2019-02-21 13:23:14 +03:00
|
|
|
static int at803x_disable_rx_delay(struct phy_device *phydev)
|
2016-01-15 03:55:22 +03:00
|
|
|
{
|
2021-10-10 01:46:18 +03:00
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_ANALOG_TEST_CTRL,
|
2019-01-21 12:13:17 +03:00
|
|
|
AT803X_DEBUG_RX_CLK_DLY_EN, 0);
|
2016-01-15 03:55:22 +03:00
|
|
|
}
|
|
|
|
|
2019-02-21 13:23:14 +03:00
|
|
|
static int at803x_disable_tx_delay(struct phy_device *phydev)
|
2016-01-15 03:55:22 +03:00
|
|
|
{
|
2021-10-10 01:46:18 +03:00
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_SYSTEM_CTRL_MODE,
|
2019-01-21 12:13:17 +03:00
|
|
|
AT803X_DEBUG_TX_CLK_DLY_EN, 0);
|
2016-01-15 03:55:22 +03:00
|
|
|
}
|
|
|
|
|
2014-06-18 13:01:43 +04:00
|
|
|
/* save relevant PHY registers to private copy */
|
|
|
|
static void at803x_context_save(struct phy_device *phydev,
|
|
|
|
struct at803x_context *context)
|
|
|
|
{
|
|
|
|
context->bmcr = phy_read(phydev, MII_BMCR);
|
|
|
|
context->advertise = phy_read(phydev, MII_ADVERTISE);
|
|
|
|
context->control1000 = phy_read(phydev, MII_CTRL1000);
|
|
|
|
context->int_enable = phy_read(phydev, AT803X_INTR_ENABLE);
|
|
|
|
context->smart_speed = phy_read(phydev, AT803X_SMART_SPEED);
|
|
|
|
context->led_control = phy_read(phydev, AT803X_LED_CONTROL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* restore relevant PHY registers from private copy */
|
|
|
|
static void at803x_context_restore(struct phy_device *phydev,
|
|
|
|
const struct at803x_context *context)
|
|
|
|
{
|
|
|
|
phy_write(phydev, MII_BMCR, context->bmcr);
|
|
|
|
phy_write(phydev, MII_ADVERTISE, context->advertise);
|
|
|
|
phy_write(phydev, MII_CTRL1000, context->control1000);
|
|
|
|
phy_write(phydev, AT803X_INTR_ENABLE, context->int_enable);
|
|
|
|
phy_write(phydev, AT803X_SMART_SPEED, context->smart_speed);
|
|
|
|
phy_write(phydev, AT803X_LED_CONTROL, context->led_control);
|
|
|
|
}
|
|
|
|
|
2013-06-04 00:10:05 +04:00
|
|
|
static int at803x_set_wol(struct phy_device *phydev,
|
|
|
|
struct ethtool_wolinfo *wol)
|
2012-10-14 23:07:16 +04:00
|
|
|
{
|
|
|
|
struct net_device *ndev = phydev->attached_dev;
|
|
|
|
const u8 *mac;
|
2013-06-04 00:10:05 +04:00
|
|
|
int ret;
|
|
|
|
u32 value;
|
2021-10-24 11:27:25 +03:00
|
|
|
unsigned int i;
|
|
|
|
const unsigned int offsets[] = {
|
2012-10-14 23:07:16 +04:00
|
|
|
AT803X_LOC_MAC_ADDR_32_47_OFFSET,
|
|
|
|
AT803X_LOC_MAC_ADDR_16_31_OFFSET,
|
|
|
|
AT803X_LOC_MAC_ADDR_0_15_OFFSET,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!ndev)
|
2013-06-04 00:10:05 +04:00
|
|
|
return -ENODEV;
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2013-06-04 00:10:05 +04:00
|
|
|
if (wol->wolopts & WAKE_MAGIC) {
|
|
|
|
mac = (const u8 *) ndev->dev_addr;
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2013-06-04 00:10:05 +04:00
|
|
|
if (!is_valid_ether_addr(mac))
|
2017-10-10 20:42:56 +03:00
|
|
|
return -EINVAL;
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2019-01-25 15:35:10 +03:00
|
|
|
for (i = 0; i < 3; i++)
|
2021-10-24 11:27:25 +03:00
|
|
|
phy_write_mmd(phydev, MDIO_MMD_PCS, offsets[i],
|
2019-01-25 15:35:10 +03:00
|
|
|
mac[(i * 2) + 1] | (mac[(i * 2)] << 8));
|
2013-06-04 00:10:05 +04:00
|
|
|
|
|
|
|
value = phy_read(phydev, AT803X_INTR_ENABLE);
|
2016-01-15 03:55:24 +03:00
|
|
|
value |= AT803X_INTR_ENABLE_WOL;
|
2013-06-04 00:10:05 +04:00
|
|
|
ret = phy_write(phydev, AT803X_INTR_ENABLE, value);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
value = phy_read(phydev, AT803X_INTR_STATUS);
|
|
|
|
} else {
|
|
|
|
value = phy_read(phydev, AT803X_INTR_ENABLE);
|
2016-01-15 03:55:24 +03:00
|
|
|
value &= (~AT803X_INTR_ENABLE_WOL);
|
2013-06-04 00:10:05 +04:00
|
|
|
ret = phy_write(phydev, AT803X_INTR_ENABLE, value);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
value = phy_read(phydev, AT803X_INTR_STATUS);
|
2012-10-14 23:07:16 +04:00
|
|
|
}
|
2013-06-04 00:10:05 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void at803x_get_wol(struct phy_device *phydev,
|
|
|
|
struct ethtool_wolinfo *wol)
|
|
|
|
{
|
|
|
|
u32 value;
|
|
|
|
|
|
|
|
wol->supported = WAKE_MAGIC;
|
|
|
|
wol->wolopts = 0;
|
|
|
|
|
|
|
|
value = phy_read(phydev, AT803X_INTR_ENABLE);
|
2016-01-15 03:55:24 +03:00
|
|
|
if (value & AT803X_INTR_ENABLE_WOL)
|
2013-06-04 00:10:05 +04:00
|
|
|
wol->wolopts |= WAKE_MAGIC;
|
2012-10-14 23:07:16 +04:00
|
|
|
}
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
static int at803x_get_sset_count(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
return ARRAY_SIZE(at803x_hw_stats);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void at803x_get_strings(struct phy_device *phydev, u8 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(at803x_hw_stats); i++) {
|
|
|
|
strscpy(data + i * ETH_GSTRING_LEN,
|
|
|
|
at803x_hw_stats[i].string, ETH_GSTRING_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 at803x_get_stat(struct phy_device *phydev, int i)
|
|
|
|
{
|
|
|
|
struct at803x_hw_stat stat = at803x_hw_stats[i];
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
|
|
|
int val;
|
|
|
|
u64 ret;
|
|
|
|
|
|
|
|
if (stat.access_type == MMD)
|
|
|
|
val = phy_read_mmd(phydev, MDIO_MMD_PCS, stat.reg);
|
|
|
|
else
|
|
|
|
val = phy_read(phydev, stat.reg);
|
|
|
|
|
|
|
|
if (val < 0) {
|
|
|
|
ret = U64_MAX;
|
|
|
|
} else {
|
|
|
|
val = val & stat.mask;
|
|
|
|
priv->stats[i] += val;
|
|
|
|
ret = priv->stats[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void at803x_get_stats(struct phy_device *phydev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(at803x_hw_stats); i++)
|
|
|
|
data[i] = at803x_get_stat(phydev, i);
|
|
|
|
}
|
|
|
|
|
2013-09-21 18:53:02 +04:00
|
|
|
static int at803x_suspend(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int value;
|
|
|
|
int wol_enabled;
|
|
|
|
|
|
|
|
value = phy_read(phydev, AT803X_INTR_ENABLE);
|
2016-01-15 03:55:24 +03:00
|
|
|
wol_enabled = value & AT803X_INTR_ENABLE_WOL;
|
2013-09-21 18:53:02 +04:00
|
|
|
|
|
|
|
if (wol_enabled)
|
2018-01-02 13:58:58 +03:00
|
|
|
value = BMCR_ISOLATE;
|
2013-09-21 18:53:02 +04:00
|
|
|
else
|
2018-01-02 13:58:58 +03:00
|
|
|
value = BMCR_PDOWN;
|
2013-09-21 18:53:02 +04:00
|
|
|
|
2018-01-02 13:58:58 +03:00
|
|
|
phy_modify(phydev, MII_BMCR, 0, value);
|
2013-09-21 18:53:02 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_resume(struct phy_device *phydev)
|
|
|
|
{
|
2018-01-05 19:07:10 +03:00
|
|
|
return phy_modify(phydev, MII_BMCR, BMCR_PDOWN | BMCR_ISOLATE, 0);
|
2013-09-21 18:53:02 +04:00
|
|
|
}
|
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
static int at803x_rgmii_reg_set_voltage_sel(struct regulator_dev *rdev,
|
|
|
|
unsigned int selector)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = rdev_get_drvdata(rdev);
|
|
|
|
|
|
|
|
if (selector)
|
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
|
|
|
|
0, AT803X_DEBUG_RGMII_1V8);
|
|
|
|
else
|
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
|
|
|
|
AT803X_DEBUG_RGMII_1V8, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_rgmii_reg_get_voltage_sel(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = rdev_get_drvdata(rdev);
|
|
|
|
int val;
|
|
|
|
|
|
|
|
val = at803x_debug_reg_read(phydev, AT803X_DEBUG_REG_1F);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
return (val & AT803X_DEBUG_RGMII_1V8) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2020-08-27 01:56:06 +03:00
|
|
|
static const struct regulator_ops vddio_regulator_ops = {
|
2019-11-07 01:36:14 +03:00
|
|
|
.list_voltage = regulator_list_voltage_table,
|
|
|
|
.set_voltage_sel = at803x_rgmii_reg_set_voltage_sel,
|
|
|
|
.get_voltage_sel = at803x_rgmii_reg_get_voltage_sel,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const unsigned int vddio_voltage_table[] = {
|
|
|
|
1500000,
|
|
|
|
1800000,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct regulator_desc vddio_desc = {
|
|
|
|
.name = "vddio",
|
|
|
|
.of_match = of_match_ptr("vddio-regulator"),
|
|
|
|
.n_voltages = ARRAY_SIZE(vddio_voltage_table),
|
|
|
|
.volt_table = vddio_voltage_table,
|
|
|
|
.ops = &vddio_regulator_ops,
|
|
|
|
.type = REGULATOR_VOLTAGE,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2020-08-27 01:56:06 +03:00
|
|
|
static const struct regulator_ops vddh_regulator_ops = {
|
2019-11-07 01:36:14 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct regulator_desc vddh_desc = {
|
|
|
|
.name = "vddh",
|
|
|
|
.of_match = of_match_ptr("vddh-regulator"),
|
|
|
|
.n_voltages = 1,
|
|
|
|
.fixed_uV = 2500000,
|
|
|
|
.ops = &vddh_regulator_ops,
|
|
|
|
.type = REGULATOR_VOLTAGE,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int at8031_register_regulators(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
|
|
|
struct device *dev = &phydev->mdio.dev;
|
|
|
|
struct regulator_config config = { };
|
|
|
|
|
|
|
|
config.dev = dev;
|
|
|
|
config.driver_data = phydev;
|
|
|
|
|
|
|
|
priv->vddio_rdev = devm_regulator_register(dev, &vddio_desc, &config);
|
|
|
|
if (IS_ERR(priv->vddio_rdev)) {
|
|
|
|
phydev_err(phydev, "failed to register VDDIO regulator\n");
|
|
|
|
return PTR_ERR(priv->vddio_rdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->vddh_rdev = devm_regulator_register(dev, &vddh_desc, &config);
|
|
|
|
if (IS_ERR(priv->vddh_rdev)) {
|
|
|
|
phydev_err(phydev, "failed to register VDDH regulator\n");
|
|
|
|
return PTR_ERR(priv->vddh_rdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_parse_dt(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct device_node *node = phydev->mdio.dev.of_node;
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
2021-01-14 13:45:49 +03:00
|
|
|
u32 freq, strength, tw;
|
2020-07-07 04:49:33 +03:00
|
|
|
unsigned int sel;
|
2019-11-07 01:36:14 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!IS_ENABLED(CONFIG_OF_MDIO))
|
|
|
|
return 0;
|
|
|
|
|
2021-01-14 13:45:49 +03:00
|
|
|
if (of_property_read_bool(node, "qca,disable-smarteee"))
|
|
|
|
priv->flags |= AT803X_DISABLE_SMARTEEE;
|
|
|
|
|
|
|
|
if (!of_property_read_u32(node, "qca,smarteee-tw-us-1g", &tw)) {
|
|
|
|
if (!tw || tw > 255) {
|
|
|
|
phydev_err(phydev, "invalid qca,smarteee-tw-us-1g\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
priv->smarteee_lpi_tw_1g = tw;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!of_property_read_u32(node, "qca,smarteee-tw-us-100m", &tw)) {
|
|
|
|
if (!tw || tw > 255) {
|
|
|
|
phydev_err(phydev, "invalid qca,smarteee-tw-us-100m\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
priv->smarteee_lpi_tw_100m = tw;
|
|
|
|
}
|
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
ret = of_property_read_u32(node, "qca,clk-out-frequency", &freq);
|
|
|
|
if (!ret) {
|
|
|
|
switch (freq) {
|
|
|
|
case 25000000:
|
|
|
|
sel = AT803X_CLK_OUT_25MHZ_XTAL;
|
|
|
|
break;
|
|
|
|
case 50000000:
|
|
|
|
sel = AT803X_CLK_OUT_50MHZ_PLL;
|
|
|
|
break;
|
|
|
|
case 62500000:
|
|
|
|
sel = AT803X_CLK_OUT_62_5MHZ_PLL;
|
|
|
|
break;
|
|
|
|
case 125000000:
|
|
|
|
sel = AT803X_CLK_OUT_125MHZ_PLL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
phydev_err(phydev, "invalid qca,clk-out-frequency\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2020-07-07 04:49:33 +03:00
|
|
|
priv->clk_25m_reg |= FIELD_PREP(AT803X_CLK_OUT_MASK, sel);
|
|
|
|
priv->clk_25m_mask |= AT803X_CLK_OUT_MASK;
|
2019-11-07 01:36:14 +03:00
|
|
|
|
|
|
|
/* Fixup for the AR8030/AR8035. This chip has another mask and
|
|
|
|
* doesn't support the DSP reference. Eg. the lowest bit of the
|
|
|
|
* mask. The upper two bits select the same frequencies. Mask
|
|
|
|
* the lowest bit here.
|
|
|
|
*
|
|
|
|
* Warning:
|
|
|
|
* There was no datasheet for the AR8030 available so this is
|
|
|
|
* just a guess. But the AR8035 is listed as pin compatible
|
|
|
|
* to the AR8030 so there might be a good chance it works on
|
|
|
|
* the AR8030 too.
|
|
|
|
*/
|
2021-07-20 16:33:49 +03:00
|
|
|
if (phydev->drv->phy_id == ATH8030_PHY_ID ||
|
|
|
|
phydev->drv->phy_id == ATH8035_PHY_ID) {
|
2020-04-01 12:57:32 +03:00
|
|
|
priv->clk_25m_reg &= AT8035_CLK_OUT_MASK;
|
|
|
|
priv->clk_25m_mask &= AT8035_CLK_OUT_MASK;
|
2019-11-07 01:36:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = of_property_read_u32(node, "qca,clk-out-strength", &strength);
|
|
|
|
if (!ret) {
|
|
|
|
priv->clk_25m_mask |= AT803X_CLK_OUT_STRENGTH_MASK;
|
|
|
|
switch (strength) {
|
|
|
|
case AR803X_STRENGTH_FULL:
|
|
|
|
priv->clk_25m_reg |= AT803X_CLK_OUT_STRENGTH_FULL;
|
|
|
|
break;
|
|
|
|
case AR803X_STRENGTH_HALF:
|
|
|
|
priv->clk_25m_reg |= AT803X_CLK_OUT_STRENGTH_HALF;
|
|
|
|
break;
|
|
|
|
case AR803X_STRENGTH_QUARTER:
|
|
|
|
priv->clk_25m_reg |= AT803X_CLK_OUT_STRENGTH_QUARTER;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
phydev_err(phydev, "invalid qca,clk-out-strength\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-07 01:36:15 +03:00
|
|
|
/* Only supported on AR8031/AR8033, the AR8030/AR8035 use strapping
|
|
|
|
* options.
|
|
|
|
*/
|
2021-07-20 16:33:49 +03:00
|
|
|
if (phydev->drv->phy_id == ATH8031_PHY_ID) {
|
2019-11-07 01:36:14 +03:00
|
|
|
if (of_property_read_bool(node, "qca,keep-pll-enabled"))
|
|
|
|
priv->flags |= AT803X_KEEP_PLL_ENABLED;
|
|
|
|
|
|
|
|
ret = at8031_register_regulators(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
priv->vddio = devm_regulator_get_optional(&phydev->mdio.dev,
|
|
|
|
"vddio");
|
|
|
|
if (IS_ERR(priv->vddio)) {
|
|
|
|
phydev_err(phydev, "failed to get VDDIO regulator\n");
|
|
|
|
return PTR_ERR(priv->vddio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_probe(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct device *dev = &phydev->mdio.dev;
|
|
|
|
struct at803x_priv *priv;
|
2021-04-15 04:26:50 +03:00
|
|
|
int ret;
|
2019-11-07 01:36:14 +03:00
|
|
|
|
|
|
|
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
|
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
phydev->priv = priv;
|
|
|
|
|
2021-04-15 04:26:50 +03:00
|
|
|
ret = at803x_parse_dt(phydev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2021-04-20 13:29:29 +03:00
|
|
|
if (priv->vddio) {
|
|
|
|
ret = regulator_enable(priv->vddio);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-04-15 04:26:50 +03:00
|
|
|
/* Some bootloaders leave the fiber page selected.
|
|
|
|
* Switch to the copper page, as otherwise we read
|
|
|
|
* the PHY capabilities from the fiber side.
|
|
|
|
*/
|
2021-07-20 16:33:49 +03:00
|
|
|
if (phydev->drv->phy_id == ATH8031_PHY_ID) {
|
2021-04-20 13:29:29 +03:00
|
|
|
phy_lock_mdio_bus(phydev);
|
|
|
|
ret = at803x_write_page(phydev, AT803X_PAGE_COPPER);
|
|
|
|
phy_unlock_mdio_bus(phydev);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2021-04-15 04:26:50 +03:00
|
|
|
}
|
|
|
|
|
2021-04-20 13:29:29 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (priv->vddio)
|
|
|
|
regulator_disable(priv->vddio);
|
|
|
|
|
2021-04-15 04:26:50 +03:00
|
|
|
return ret;
|
2019-11-07 01:36:14 +03:00
|
|
|
}
|
|
|
|
|
2020-01-30 20:54:02 +03:00
|
|
|
static void at803x_remove(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
|
|
|
|
|
|
|
if (priv->vddio)
|
|
|
|
regulator_disable(priv->vddio);
|
|
|
|
}
|
|
|
|
|
2021-06-27 13:16:07 +03:00
|
|
|
static int at803x_get_features(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = genphy_read_abilities(phydev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2021-07-20 20:24:33 +03:00
|
|
|
if (phydev->drv->phy_id != ATH8031_PHY_ID)
|
2021-06-27 13:16:07 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* AR8031/AR8033 have different status registers
|
|
|
|
* for copper and fiber operation. However, the
|
|
|
|
* extended status register is the same for both
|
|
|
|
* operation modes.
|
|
|
|
*
|
|
|
|
* As a result of that, ESTATUS_1000_XFULL is set
|
|
|
|
* to 1 even when operating in copper TP mode.
|
|
|
|
*
|
|
|
|
* Remove this mode from the supported link modes,
|
|
|
|
* as this driver currently only supports copper
|
|
|
|
* operation.
|
|
|
|
*/
|
|
|
|
linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
|
|
|
|
phydev->supported);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-01-14 13:45:49 +03:00
|
|
|
static int at803x_smarteee_config(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
|
|
|
u16 mask = 0, val = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (priv->flags & AT803X_DISABLE_SMARTEEE)
|
|
|
|
return phy_modify_mmd(phydev, MDIO_MMD_PCS,
|
|
|
|
AT803X_MMD3_SMARTEEE_CTL3,
|
|
|
|
AT803X_MMD3_SMARTEEE_CTL3_LPI_EN, 0);
|
|
|
|
|
|
|
|
if (priv->smarteee_lpi_tw_1g) {
|
|
|
|
mask |= 0xff00;
|
|
|
|
val |= priv->smarteee_lpi_tw_1g << 8;
|
|
|
|
}
|
|
|
|
if (priv->smarteee_lpi_tw_100m) {
|
|
|
|
mask |= 0x00ff;
|
|
|
|
val |= priv->smarteee_lpi_tw_100m;
|
|
|
|
}
|
|
|
|
if (!mask)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = phy_modify_mmd(phydev, MDIO_MMD_PCS, AT803X_MMD3_SMARTEEE_CTL1,
|
|
|
|
mask, val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return phy_modify_mmd(phydev, MDIO_MMD_PCS, AT803X_MMD3_SMARTEEE_CTL3,
|
|
|
|
AT803X_MMD3_SMARTEEE_CTL3_LPI_EN,
|
|
|
|
AT803X_MMD3_SMARTEEE_CTL3_LPI_EN);
|
|
|
|
}
|
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
static int at803x_clk_out_config(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
|
|
|
|
|
|
|
if (!priv->clk_25m_mask)
|
|
|
|
return 0;
|
|
|
|
|
2021-01-10 17:54:36 +03:00
|
|
|
return phy_modify_mmd(phydev, MDIO_MMD_AN, AT803X_MMD7_CLK25M,
|
|
|
|
priv->clk_25m_mask, priv->clk_25m_reg);
|
2019-11-07 01:36:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int at8031_pll_config(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct at803x_priv *priv = phydev->priv;
|
|
|
|
|
|
|
|
/* The default after hardware reset is PLL OFF. After a soft reset, the
|
|
|
|
* values are retained.
|
|
|
|
*/
|
|
|
|
if (priv->flags & AT803X_KEEP_PLL_ENABLED)
|
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
|
|
|
|
0, AT803X_DEBUG_PLL_ON);
|
|
|
|
else
|
|
|
|
return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
|
|
|
|
AT803X_DEBUG_PLL_ON, 0);
|
|
|
|
}
|
|
|
|
|
2012-10-14 23:07:16 +04:00
|
|
|
static int at803x_config_init(struct phy_device *phydev)
|
|
|
|
{
|
2013-06-04 00:10:06 +04:00
|
|
|
int ret;
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2019-02-21 13:23:15 +03:00
|
|
|
/* The RX and TX delay default is:
|
|
|
|
* after HW reset: RX delay enabled and TX delay disabled
|
|
|
|
* after SW reset: RX delay enabled, while TX delay retains the
|
|
|
|
* value before reset.
|
|
|
|
*/
|
|
|
|
if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
|
2019-08-09 14:20:25 +03:00
|
|
|
phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
|
2019-02-21 13:23:15 +03:00
|
|
|
ret = at803x_enable_rx_delay(phydev);
|
2019-08-09 14:20:25 +03:00
|
|
|
else
|
|
|
|
ret = at803x_disable_rx_delay(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2016-01-15 03:55:22 +03:00
|
|
|
|
2019-02-21 13:23:15 +03:00
|
|
|
if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
|
2019-08-09 14:20:25 +03:00
|
|
|
phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
|
2019-02-21 13:23:15 +03:00
|
|
|
ret = at803x_enable_tx_delay(phydev);
|
2019-08-09 14:20:25 +03:00
|
|
|
else
|
|
|
|
ret = at803x_disable_tx_delay(phydev);
|
2019-11-07 01:36:14 +03:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2013-06-04 00:10:06 +04:00
|
|
|
|
2021-01-14 13:45:49 +03:00
|
|
|
ret = at803x_smarteee_config(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2019-11-07 01:36:14 +03:00
|
|
|
ret = at803x_clk_out_config(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2021-07-20 16:33:49 +03:00
|
|
|
if (phydev->drv->phy_id == ATH8031_PHY_ID) {
|
2019-11-07 01:36:14 +03:00
|
|
|
ret = at8031_pll_config(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-01-13 01:59:43 +03:00
|
|
|
/* Ar803x extended next page bit is enabled by default. Cisco
|
|
|
|
* multigig switches read this bit and attempt to negotiate 10Gbps
|
|
|
|
* rates even if the next page bit is disabled. This is incorrect
|
|
|
|
* behaviour but we still need to accommodate it. XNP is only needed
|
|
|
|
* for 10Gbps support, so disable XNP.
|
|
|
|
*/
|
|
|
|
return phy_modify(phydev, MII_ADVERTISE, MDIO_AN_CTRL1_XNP, 0);
|
2012-10-14 23:07:16 +04:00
|
|
|
}
|
|
|
|
|
2014-03-28 11:39:41 +04:00
|
|
|
static int at803x_ack_interrupt(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2016-01-15 03:55:23 +03:00
|
|
|
err = phy_read(phydev, AT803X_INTR_STATUS);
|
2014-03-28 11:39:41 +04:00
|
|
|
|
|
|
|
return (err < 0) ? err : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_config_intr(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int value;
|
|
|
|
|
2016-01-15 03:55:23 +03:00
|
|
|
value = phy_read(phydev, AT803X_INTR_ENABLE);
|
2014-03-28 11:39:41 +04:00
|
|
|
|
2016-01-15 03:55:24 +03:00
|
|
|
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
2020-11-01 15:51:00 +03:00
|
|
|
/* Clear any pending interrupts */
|
|
|
|
err = at803x_ack_interrupt(phydev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2016-01-15 03:55:24 +03:00
|
|
|
value |= AT803X_INTR_ENABLE_AUTONEG_ERR;
|
|
|
|
value |= AT803X_INTR_ENABLE_SPEED_CHANGED;
|
|
|
|
value |= AT803X_INTR_ENABLE_DUPLEX_CHANGED;
|
|
|
|
value |= AT803X_INTR_ENABLE_LINK_FAIL;
|
|
|
|
value |= AT803X_INTR_ENABLE_LINK_SUCCESS;
|
|
|
|
|
|
|
|
err = phy_write(phydev, AT803X_INTR_ENABLE, value);
|
2020-11-01 15:51:00 +03:00
|
|
|
} else {
|
2016-01-15 03:55:23 +03:00
|
|
|
err = phy_write(phydev, AT803X_INTR_ENABLE, 0);
|
2020-11-01 15:51:00 +03:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Clear any pending interrupts */
|
|
|
|
err = at803x_ack_interrupt(phydev);
|
|
|
|
}
|
2014-03-28 11:39:41 +04:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2020-11-01 15:50:59 +03:00
|
|
|
static irqreturn_t at803x_handle_interrupt(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int irq_status, int_enabled;
|
|
|
|
|
|
|
|
irq_status = phy_read(phydev, AT803X_INTR_STATUS);
|
|
|
|
if (irq_status < 0) {
|
|
|
|
phy_error(phydev);
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read the current enabled interrupts */
|
|
|
|
int_enabled = phy_read(phydev, AT803X_INTR_ENABLE);
|
|
|
|
if (int_enabled < 0) {
|
|
|
|
phy_error(phydev);
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See if this was one of our enabled interrupts */
|
|
|
|
if (!(irq_status & int_enabled))
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
|
|
|
phy_trigger_machine(phydev);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2014-06-18 13:01:43 +04:00
|
|
|
static void at803x_link_change_notify(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Conduct a hardware reset for AT8030 every time a link loss is
|
|
|
|
* signalled. This is necessary to circumvent a hardware bug that
|
|
|
|
* occurs when the cable is unplugged while TX packets are pending
|
|
|
|
* in the FIFO. In such cases, the FIFO enters an error mode it
|
|
|
|
* cannot recover from by software.
|
|
|
|
*/
|
2019-04-18 00:59:22 +03:00
|
|
|
if (phydev->state == PHY_NOLINK && phydev->mdio.reset_gpio) {
|
2019-03-19 21:56:51 +03:00
|
|
|
struct at803x_context context;
|
2016-04-26 20:44:18 +03:00
|
|
|
|
2019-03-19 21:56:51 +03:00
|
|
|
at803x_context_save(phydev, &context);
|
2016-04-26 20:44:18 +03:00
|
|
|
|
2019-03-19 21:56:51 +03:00
|
|
|
phy_device_reset(phydev, 1);
|
|
|
|
msleep(1);
|
|
|
|
phy_device_reset(phydev, 0);
|
|
|
|
msleep(1);
|
2016-04-26 20:44:18 +03:00
|
|
|
|
2019-03-19 21:56:51 +03:00
|
|
|
at803x_context_restore(phydev, &context);
|
2016-04-26 20:44:18 +03:00
|
|
|
|
2019-03-19 21:56:51 +03:00
|
|
|
phydev_dbg(phydev, "%s(): phy was reset\n", __func__);
|
2014-06-18 13:01:43 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-04 19:06:14 +03:00
|
|
|
static int at803x_read_status(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ss, 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;
|
|
|
|
|
|
|
|
err = genphy_read_lpa(phydev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Read the AT8035 PHY-Specific Status register, which indicates the
|
|
|
|
* speed and duplex that the PHY is actually using, irrespective of
|
|
|
|
* whether we are in autoneg mode or not.
|
|
|
|
*/
|
|
|
|
ss = phy_read(phydev, AT803X_SPECIFIC_STATUS);
|
|
|
|
if (ss < 0)
|
|
|
|
return ss;
|
|
|
|
|
|
|
|
if (ss & AT803X_SS_SPEED_DUPLEX_RESOLVED) {
|
2020-07-19 11:05:30 +03:00
|
|
|
int sfc;
|
|
|
|
|
|
|
|
sfc = phy_read(phydev, AT803X_SPECIFIC_FUNCTION_CONTROL);
|
|
|
|
if (sfc < 0)
|
|
|
|
return sfc;
|
|
|
|
|
2019-10-04 19:06:14 +03:00
|
|
|
switch (ss & AT803X_SS_SPEED_MASK) {
|
|
|
|
case AT803X_SS_SPEED_10:
|
|
|
|
phydev->speed = SPEED_10;
|
|
|
|
break;
|
|
|
|
case AT803X_SS_SPEED_100:
|
|
|
|
phydev->speed = SPEED_100;
|
|
|
|
break;
|
|
|
|
case AT803X_SS_SPEED_1000:
|
|
|
|
phydev->speed = SPEED_1000;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ss & AT803X_SS_DUPLEX)
|
|
|
|
phydev->duplex = DUPLEX_FULL;
|
|
|
|
else
|
|
|
|
phydev->duplex = DUPLEX_HALF;
|
2020-07-19 11:05:30 +03:00
|
|
|
|
2019-10-04 19:06:14 +03:00
|
|
|
if (ss & AT803X_SS_MDIX)
|
|
|
|
phydev->mdix = ETH_TP_MDI_X;
|
|
|
|
else
|
|
|
|
phydev->mdix = ETH_TP_MDI;
|
2020-07-19 11:05:30 +03:00
|
|
|
|
|
|
|
switch (FIELD_GET(AT803X_SFC_MDI_CROSSOVER_MODE_M, sfc)) {
|
|
|
|
case AT803X_SFC_MANUAL_MDI:
|
|
|
|
phydev->mdix_ctrl = ETH_TP_MDI;
|
|
|
|
break;
|
|
|
|
case AT803X_SFC_MANUAL_MDIX:
|
|
|
|
phydev->mdix_ctrl = ETH_TP_MDI_X;
|
|
|
|
break;
|
|
|
|
case AT803X_SFC_AUTOMATIC_CROSSOVER:
|
|
|
|
phydev->mdix_ctrl = ETH_TP_MDI_AUTO;
|
|
|
|
break;
|
|
|
|
}
|
2019-10-04 19:06:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete)
|
|
|
|
phy_resolve_aneg_pause(phydev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-07-19 11:05:30 +03:00
|
|
|
static int at803x_config_mdix(struct phy_device *phydev, u8 ctrl)
|
|
|
|
{
|
|
|
|
u16 val;
|
|
|
|
|
|
|
|
switch (ctrl) {
|
|
|
|
case ETH_TP_MDI:
|
|
|
|
val = AT803X_SFC_MANUAL_MDI;
|
|
|
|
break;
|
|
|
|
case ETH_TP_MDI_X:
|
|
|
|
val = AT803X_SFC_MANUAL_MDIX;
|
|
|
|
break;
|
|
|
|
case ETH_TP_MDI_AUTO:
|
|
|
|
val = AT803X_SFC_AUTOMATIC_CROSSOVER;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return phy_modify_changed(phydev, AT803X_SPECIFIC_FUNCTION_CONTROL,
|
|
|
|
AT803X_SFC_MDI_CROSSOVER_MODE_M,
|
|
|
|
FIELD_PREP(AT803X_SFC_MDI_CROSSOVER_MODE_M, val));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_config_aneg(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = at803x_config_mdix(phydev, phydev->mdix_ctrl);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Changes of the midx bits are disruptive to the normal operation;
|
|
|
|
* therefore any changes to these registers must be followed by a
|
|
|
|
* software reset to take effect.
|
|
|
|
*/
|
|
|
|
if (ret == 1) {
|
|
|
|
ret = genphy_soft_reset(phydev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return genphy_config_aneg(phydev);
|
|
|
|
}
|
|
|
|
|
2020-04-29 00:15:02 +03:00
|
|
|
static int at803x_get_downshift(struct phy_device *phydev, u8 *d)
|
|
|
|
{
|
|
|
|
int val;
|
|
|
|
|
|
|
|
val = phy_read(phydev, AT803X_SMART_SPEED);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
if (val & AT803X_SMART_SPEED_ENABLE)
|
|
|
|
*d = FIELD_GET(AT803X_SMART_SPEED_RETRY_LIMIT_MASK, val) + 2;
|
|
|
|
else
|
|
|
|
*d = DOWNSHIFT_DEV_DISABLE;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_set_downshift(struct phy_device *phydev, u8 cnt)
|
|
|
|
{
|
|
|
|
u16 mask, set;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
switch (cnt) {
|
|
|
|
case DOWNSHIFT_DEV_DEFAULT_COUNT:
|
|
|
|
cnt = AT803X_DEFAULT_DOWNSHIFT;
|
|
|
|
fallthrough;
|
|
|
|
case AT803X_MIN_DOWNSHIFT ... AT803X_MAX_DOWNSHIFT:
|
|
|
|
set = AT803X_SMART_SPEED_ENABLE |
|
|
|
|
AT803X_SMART_SPEED_BYPASS_TIMER |
|
|
|
|
FIELD_PREP(AT803X_SMART_SPEED_RETRY_LIMIT_MASK, cnt - 2);
|
|
|
|
mask = AT803X_SMART_SPEED_RETRY_LIMIT_MASK;
|
|
|
|
break;
|
|
|
|
case DOWNSHIFT_DEV_DISABLE:
|
|
|
|
set = 0;
|
|
|
|
mask = AT803X_SMART_SPEED_ENABLE |
|
|
|
|
AT803X_SMART_SPEED_BYPASS_TIMER;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = phy_modify_changed(phydev, AT803X_SMART_SPEED, mask, set);
|
|
|
|
|
|
|
|
/* After changing the smart speed settings, we need to perform a
|
|
|
|
* software reset, use phy_init_hw() to make sure we set the
|
|
|
|
* reapply any values which might got lost during software reset.
|
|
|
|
*/
|
|
|
|
if (ret == 1)
|
|
|
|
ret = phy_init_hw(phydev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_get_tunable(struct phy_device *phydev,
|
|
|
|
struct ethtool_tunable *tuna, void *data)
|
|
|
|
{
|
|
|
|
switch (tuna->id) {
|
|
|
|
case ETHTOOL_PHY_DOWNSHIFT:
|
|
|
|
return at803x_get_downshift(phydev, data);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_set_tunable(struct phy_device *phydev,
|
|
|
|
struct ethtool_tunable *tuna, const void *data)
|
|
|
|
{
|
|
|
|
switch (tuna->id) {
|
|
|
|
case ETHTOOL_PHY_DOWNSHIFT:
|
|
|
|
return at803x_set_downshift(phydev, *(const u8 *)data);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
static int at803x_cable_test_result_trans(u16 status)
|
|
|
|
{
|
|
|
|
switch (FIELD_GET(AT803X_CDT_STATUS_STAT_MASK, status)) {
|
|
|
|
case AT803X_CDT_STATUS_STAT_NORMAL:
|
|
|
|
return ETHTOOL_A_CABLE_RESULT_CODE_OK;
|
|
|
|
case AT803X_CDT_STATUS_STAT_SHORT:
|
|
|
|
return ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT;
|
|
|
|
case AT803X_CDT_STATUS_STAT_OPEN:
|
|
|
|
return ETHTOOL_A_CABLE_RESULT_CODE_OPEN;
|
|
|
|
case AT803X_CDT_STATUS_STAT_FAIL:
|
|
|
|
default:
|
|
|
|
return ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool at803x_cdt_test_failed(u16 status)
|
|
|
|
{
|
|
|
|
return FIELD_GET(AT803X_CDT_STATUS_STAT_MASK, status) ==
|
|
|
|
AT803X_CDT_STATUS_STAT_FAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool at803x_cdt_fault_length_valid(u16 status)
|
|
|
|
{
|
|
|
|
switch (FIELD_GET(AT803X_CDT_STATUS_STAT_MASK, status)) {
|
|
|
|
case AT803X_CDT_STATUS_STAT_OPEN:
|
|
|
|
case AT803X_CDT_STATUS_STAT_SHORT:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_cdt_fault_length(u16 status)
|
|
|
|
{
|
|
|
|
int dt;
|
|
|
|
|
|
|
|
/* According to the datasheet the distance to the fault is
|
|
|
|
* DELTA_TIME * 0.824 meters.
|
|
|
|
*
|
|
|
|
* The author suspect the correct formula is:
|
|
|
|
*
|
|
|
|
* fault_distance = DELTA_TIME * (c * VF) / 125MHz / 2
|
|
|
|
*
|
|
|
|
* where c is the speed of light, VF is the velocity factor of
|
|
|
|
* the twisted pair cable, 125MHz the counter frequency and
|
|
|
|
* we need to divide by 2 because the hardware will measure the
|
|
|
|
* round trip time to the fault and back to the PHY.
|
|
|
|
*
|
|
|
|
* With a VF of 0.69 we get the factor 0.824 mentioned in the
|
|
|
|
* datasheet.
|
|
|
|
*/
|
|
|
|
dt = FIELD_GET(AT803X_CDT_STATUS_DELTA_TIME_MASK, status);
|
|
|
|
|
|
|
|
return (dt * 824) / 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_cdt_start(struct phy_device *phydev, int pair)
|
|
|
|
{
|
|
|
|
u16 cdt;
|
|
|
|
|
|
|
|
cdt = FIELD_PREP(AT803X_CDT_MDI_PAIR_MASK, pair) |
|
|
|
|
AT803X_CDT_ENABLE_TEST;
|
|
|
|
|
|
|
|
return phy_write(phydev, AT803X_CDT, cdt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_cdt_wait_for_completion(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int val, ret;
|
|
|
|
|
|
|
|
/* One test run takes about 25ms */
|
|
|
|
ret = phy_read_poll_timeout(phydev, AT803X_CDT, val,
|
|
|
|
!(val & AT803X_CDT_ENABLE_TEST),
|
|
|
|
30000, 100000, true);
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_cable_test_one_pair(struct phy_device *phydev, int pair)
|
|
|
|
{
|
|
|
|
static const int ethtool_pair[] = {
|
|
|
|
ETHTOOL_A_CABLE_PAIR_A,
|
|
|
|
ETHTOOL_A_CABLE_PAIR_B,
|
|
|
|
ETHTOOL_A_CABLE_PAIR_C,
|
|
|
|
ETHTOOL_A_CABLE_PAIR_D,
|
|
|
|
};
|
|
|
|
int ret, val;
|
|
|
|
|
|
|
|
ret = at803x_cdt_start(phydev, pair);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = at803x_cdt_wait_for_completion(phydev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
val = phy_read(phydev, AT803X_CDT_STATUS);
|
|
|
|
if (val < 0)
|
|
|
|
return val;
|
|
|
|
|
|
|
|
if (at803x_cdt_test_failed(val))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ethnl_cable_test_result(phydev, ethtool_pair[pair],
|
|
|
|
at803x_cable_test_result_trans(val));
|
|
|
|
|
|
|
|
if (at803x_cdt_fault_length_valid(val))
|
|
|
|
ethnl_cable_test_fault_length(phydev, ethtool_pair[pair],
|
|
|
|
at803x_cdt_fault_length(val));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_cable_test_get_status(struct phy_device *phydev,
|
|
|
|
bool *finished)
|
|
|
|
{
|
2020-05-27 08:08:43 +03:00
|
|
|
unsigned long pair_mask;
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
int retries = 20;
|
|
|
|
int pair, ret;
|
|
|
|
|
2020-05-27 08:08:43 +03:00
|
|
|
if (phydev->phy_id == ATH9331_PHY_ID ||
|
2021-10-06 01:54:01 +03:00
|
|
|
phydev->phy_id == ATH8032_PHY_ID ||
|
|
|
|
phydev->phy_id == QCA9561_PHY_ID)
|
2020-05-27 08:08:43 +03:00
|
|
|
pair_mask = 0x3;
|
|
|
|
else
|
|
|
|
pair_mask = 0xf;
|
|
|
|
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
*finished = false;
|
|
|
|
|
|
|
|
/* According to the datasheet the CDT can be performed when
|
|
|
|
* there is no link partner or when the link partner is
|
|
|
|
* auto-negotiating. Starting the test will restart the AN
|
|
|
|
* automatically. It seems that doing this repeatedly we will
|
|
|
|
* get a slot where our link partner won't disturb our
|
|
|
|
* measurement.
|
|
|
|
*/
|
|
|
|
while (pair_mask && retries--) {
|
|
|
|
for_each_set_bit(pair, &pair_mask, 4) {
|
|
|
|
ret = at803x_cable_test_one_pair(phydev, pair);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret)
|
|
|
|
clear_bit(pair, &pair_mask);
|
|
|
|
}
|
|
|
|
if (pair_mask)
|
|
|
|
msleep(250);
|
|
|
|
}
|
|
|
|
|
|
|
|
*finished = true;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int at803x_cable_test_start(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/* Enable auto-negotiation, but advertise no capabilities, no link
|
|
|
|
* will be established. A restart of the auto-negotiation is not
|
|
|
|
* required, because the cable test will automatically break the link.
|
|
|
|
*/
|
|
|
|
phy_write(phydev, MII_BMCR, BMCR_ANENABLE);
|
|
|
|
phy_write(phydev, MII_ADVERTISE, ADVERTISE_CSMA);
|
2020-05-27 08:08:43 +03:00
|
|
|
if (phydev->phy_id != ATH9331_PHY_ID &&
|
2021-10-06 01:54:01 +03:00
|
|
|
phydev->phy_id != ATH8032_PHY_ID &&
|
|
|
|
phydev->phy_id != QCA9561_PHY_ID)
|
2020-05-27 08:08:43 +03:00
|
|
|
phy_write(phydev, MII_CTRL1000, 0);
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
|
|
|
|
/* we do all the (time consuming) work later */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
static int qca83xx_config_init(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
u8 switch_revision;
|
|
|
|
|
|
|
|
switch_revision = phydev->dev_flags & QCA8K_DEVFLAGS_REVISION_MASK;
|
|
|
|
|
|
|
|
switch (switch_revision) {
|
|
|
|
case 1:
|
|
|
|
/* For 100M waveform */
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_write(phydev, AT803X_DEBUG_ANALOG_TEST_CTRL, 0x02ea);
|
2021-05-15 00:00:15 +03:00
|
|
|
/* Turn on Gigabit clock */
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_write(phydev, AT803X_DEBUG_REG_GREEN, 0x68a0);
|
2021-05-15 00:00:15 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, 0x0);
|
|
|
|
fallthrough;
|
|
|
|
case 4:
|
|
|
|
phy_write_mmd(phydev, MDIO_MMD_PCS, MDIO_AZ_DEBUG, 0x803f);
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_write(phydev, AT803X_DEBUG_REG_GREEN, 0x6860);
|
|
|
|
at803x_debug_reg_write(phydev, AT803X_DEBUG_SYSTEM_CTRL_MODE, 0x2c46);
|
2021-05-15 00:00:15 +03:00
|
|
|
at803x_debug_reg_write(phydev, AT803X_DEBUG_REG_3C, 0x6000);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2021-10-10 01:46:16 +03:00
|
|
|
/* QCA8327 require DAC amplitude adjustment for 100m set to +6%.
|
|
|
|
* Disable on init and enable only with 100m speed following
|
|
|
|
* qca original source code.
|
|
|
|
*/
|
|
|
|
if (phydev->drv->phy_id == QCA8327_A_PHY_ID ||
|
|
|
|
phydev->drv->phy_id == QCA8327_B_PHY_ID)
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_mask(phydev, AT803X_DEBUG_ANALOG_TEST_CTRL,
|
2021-10-10 01:46:16 +03:00
|
|
|
QCA8327_DEBUG_MANU_CTRL_EN, 0);
|
|
|
|
|
2021-10-10 01:46:17 +03:00
|
|
|
/* Following original QCA sourcecode set port to prefer master */
|
|
|
|
phy_set_bits(phydev, MII_CTRL1000, CTL1000_PREFER_MASTER);
|
|
|
|
|
2021-05-15 00:00:15 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-10-10 01:46:16 +03:00
|
|
|
static void qca83xx_link_change_notify(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/* QCA8337 doesn't require DAC Amplitude adjustement */
|
|
|
|
if (phydev->drv->phy_id == QCA8337_PHY_ID)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Set DAC Amplitude adjustment to +6% for 100m on link running */
|
|
|
|
if (phydev->state == PHY_RUNNING) {
|
|
|
|
if (phydev->speed == SPEED_100)
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_mask(phydev, AT803X_DEBUG_ANALOG_TEST_CTRL,
|
2021-10-10 01:46:16 +03:00
|
|
|
QCA8327_DEBUG_MANU_CTRL_EN,
|
|
|
|
QCA8327_DEBUG_MANU_CTRL_EN);
|
|
|
|
} else {
|
|
|
|
/* Reset DAC Amplitude adjustment */
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_mask(phydev, AT803X_DEBUG_ANALOG_TEST_CTRL,
|
2021-10-10 01:46:16 +03:00
|
|
|
QCA8327_DEBUG_MANU_CTRL_EN, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-10 01:46:15 +03:00
|
|
|
static int qca83xx_resume(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ret, val;
|
|
|
|
|
|
|
|
/* Skip reset if not suspended */
|
|
|
|
if (!phydev->suspended)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Reinit the port, reset values set by suspend */
|
|
|
|
qca83xx_config_init(phydev);
|
|
|
|
|
|
|
|
/* Reset the port on port resume */
|
|
|
|
phy_set_bits(phydev, MII_BMCR, BMCR_RESET | BMCR_ANENABLE);
|
|
|
|
|
|
|
|
/* On resume from suspend the switch execute a reset and
|
|
|
|
* restart auto-negotiation. Wait for reset to complete.
|
|
|
|
*/
|
|
|
|
ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
|
|
|
|
50000, 600000, true);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qca83xx_suspend(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
u16 mask = 0;
|
|
|
|
|
|
|
|
/* Only QCA8337 support actual suspend.
|
|
|
|
* QCA8327 cause port unreliability when phy suspend
|
|
|
|
* is set.
|
|
|
|
*/
|
|
|
|
if (phydev->drv->phy_id == QCA8337_PHY_ID) {
|
|
|
|
genphy_suspend(phydev);
|
|
|
|
} else {
|
|
|
|
mask |= ~(BMCR_SPEED1000 | BMCR_FULLDPLX);
|
|
|
|
phy_modify(phydev, MII_BMCR, mask, 0);
|
|
|
|
}
|
|
|
|
|
2021-10-10 01:46:18 +03:00
|
|
|
at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_GREEN,
|
2021-10-10 01:46:15 +03:00
|
|
|
AT803X_DEBUG_GATE_CLK_IN1000, 0);
|
|
|
|
|
|
|
|
at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_HIB_CTRL,
|
|
|
|
AT803X_DEBUG_HIB_CTRL_EN_ANY_CHANGE |
|
|
|
|
AT803X_DEBUG_HIB_CTRL_SEL_RST_80U, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-04 00:10:04 +04:00
|
|
|
static struct phy_driver at803x_driver[] = {
|
|
|
|
{
|
2019-11-07 01:36:16 +03:00
|
|
|
/* Qualcomm Atheros AR8035 */
|
2020-05-22 12:53:31 +03:00
|
|
|
PHY_ID_MATCH_EXACT(ATH8035_PHY_ID),
|
2019-11-07 01:36:16 +03:00
|
|
|
.name = "Qualcomm Atheros AR8035",
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
.flags = PHY_POLL_CABLE_TEST,
|
2019-11-07 01:36:14 +03:00
|
|
|
.probe = at803x_probe,
|
2020-01-30 20:54:02 +03:00
|
|
|
.remove = at803x_remove,
|
2020-07-19 11:05:30 +03:00
|
|
|
.config_aneg = at803x_config_aneg,
|
2014-06-18 13:01:43 +04:00
|
|
|
.config_init = at803x_config_init,
|
2020-04-29 00:15:02 +03:00
|
|
|
.soft_reset = genphy_soft_reset,
|
2014-06-18 13:01:43 +04:00
|
|
|
.set_wol = at803x_set_wol,
|
|
|
|
.get_wol = at803x_get_wol,
|
|
|
|
.suspend = at803x_suspend,
|
|
|
|
.resume = at803x_resume,
|
2019-04-12 21:47:03 +03:00
|
|
|
/* PHY_GBIT_FEATURES */
|
2019-10-04 19:06:14 +03:00
|
|
|
.read_status = at803x_read_status,
|
2015-11-12 20:40:20 +03:00
|
|
|
.config_intr = at803x_config_intr,
|
2020-11-01 15:50:59 +03:00
|
|
|
.handle_interrupt = at803x_handle_interrupt,
|
2020-04-29 00:15:02 +03:00
|
|
|
.get_tunable = at803x_get_tunable,
|
|
|
|
.set_tunable = at803x_set_tunable,
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
.cable_test_start = at803x_cable_test_start,
|
|
|
|
.cable_test_get_status = at803x_cable_test_get_status,
|
2013-06-04 00:10:04 +04:00
|
|
|
}, {
|
2019-11-07 01:36:16 +03:00
|
|
|
/* Qualcomm Atheros AR8030 */
|
2014-06-18 13:01:43 +04:00
|
|
|
.phy_id = ATH8030_PHY_ID,
|
2019-11-07 01:36:16 +03:00
|
|
|
.name = "Qualcomm Atheros AR8030",
|
2020-05-22 12:53:31 +03:00
|
|
|
.phy_id_mask = AT8030_PHY_ID_MASK,
|
2019-11-07 01:36:14 +03:00
|
|
|
.probe = at803x_probe,
|
2020-01-30 20:54:02 +03:00
|
|
|
.remove = at803x_remove,
|
2014-06-18 13:01:43 +04:00
|
|
|
.config_init = at803x_config_init,
|
|
|
|
.link_change_notify = at803x_link_change_notify,
|
|
|
|
.set_wol = at803x_set_wol,
|
|
|
|
.get_wol = at803x_get_wol,
|
|
|
|
.suspend = at803x_suspend,
|
|
|
|
.resume = at803x_resume,
|
2019-04-12 21:47:03 +03:00
|
|
|
/* PHY_BASIC_FEATURES */
|
2015-11-12 20:40:20 +03:00
|
|
|
.config_intr = at803x_config_intr,
|
2020-11-01 15:50:59 +03:00
|
|
|
.handle_interrupt = at803x_handle_interrupt,
|
2013-06-04 00:10:07 +04:00
|
|
|
}, {
|
2019-11-07 01:36:16 +03:00
|
|
|
/* Qualcomm Atheros AR8031/AR8033 */
|
2020-05-22 12:53:31 +03:00
|
|
|
PHY_ID_MATCH_EXACT(ATH8031_PHY_ID),
|
2019-11-07 01:36:16 +03:00
|
|
|
.name = "Qualcomm Atheros AR8031/AR8033",
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
.flags = PHY_POLL_CABLE_TEST,
|
2019-11-07 01:36:14 +03:00
|
|
|
.probe = at803x_probe,
|
2020-01-30 20:54:02 +03:00
|
|
|
.remove = at803x_remove,
|
2014-06-18 13:01:43 +04:00
|
|
|
.config_init = at803x_config_init,
|
2021-02-14 04:17:11 +03:00
|
|
|
.config_aneg = at803x_config_aneg,
|
2020-04-29 00:15:02 +03:00
|
|
|
.soft_reset = genphy_soft_reset,
|
2014-06-18 13:01:43 +04:00
|
|
|
.set_wol = at803x_set_wol,
|
|
|
|
.get_wol = at803x_get_wol,
|
|
|
|
.suspend = at803x_suspend,
|
|
|
|
.resume = at803x_resume,
|
2021-04-15 04:26:50 +03:00
|
|
|
.read_page = at803x_read_page,
|
|
|
|
.write_page = at803x_write_page,
|
2021-06-27 13:16:07 +03:00
|
|
|
.get_features = at803x_get_features,
|
2019-10-04 19:06:14 +03:00
|
|
|
.read_status = at803x_read_status,
|
2014-06-18 13:01:43 +04:00
|
|
|
.config_intr = &at803x_config_intr,
|
2020-11-01 15:50:59 +03:00
|
|
|
.handle_interrupt = at803x_handle_interrupt,
|
2020-04-29 00:15:02 +03:00
|
|
|
.get_tunable = at803x_get_tunable,
|
|
|
|
.set_tunable = at803x_set_tunable,
|
net: phy: at803x: add cable diagnostics support
The AR8031/AR8033 and the AR8035 support cable diagnostics. Adding
driver support is straightforward, so lets add it.
The PHY just do one pair at a time, so we have to start the test four
times. The cable_test_get_status() can block and therefore we can just
busy poll the test completion and continue with the next pair until we
are done.
The time delta counter seems to run at 125MHz which just gives us a
resolution of about 82.4cm per tick.
100m cable, A/B/C/D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: Open Circuit
Pair: Pair A, fault length: 107.94m
Pair: Pair B, result: Open Circuit
Pair: Pair B, fault length: 104.64m
Pair: Pair C, result: Open Circuit
Pair: Pair C, fault length: 105.47m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 107.94m
1m cable, A/B connected, C shorted, D open:
Cable test started for device eth0.
Cable test completed for device eth0.
Pair: Pair A, result: OK
Pair: Pair B, result: OK
Pair: Pair C, result: Short within Pair
Pair: Pair C, fault length: 0.82m
Pair: Pair D, result: Open Circuit
Pair: Pair D, fault length: 0.82m
Signed-off-by: Michael Walle <michael@walle.cc>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-13 23:38:07 +03:00
|
|
|
.cable_test_start = at803x_cable_test_start,
|
|
|
|
.cable_test_get_status = at803x_cable_test_get_status,
|
2020-04-17 16:41:59 +03:00
|
|
|
}, {
|
|
|
|
/* Qualcomm Atheros AR8032 */
|
|
|
|
PHY_ID_MATCH_EXACT(ATH8032_PHY_ID),
|
|
|
|
.name = "Qualcomm Atheros AR8032",
|
|
|
|
.probe = at803x_probe,
|
|
|
|
.remove = at803x_remove,
|
2020-05-27 08:08:43 +03:00
|
|
|
.flags = PHY_POLL_CABLE_TEST,
|
2020-04-17 16:41:59 +03:00
|
|
|
.config_init = at803x_config_init,
|
|
|
|
.link_change_notify = at803x_link_change_notify,
|
|
|
|
.set_wol = at803x_set_wol,
|
|
|
|
.get_wol = at803x_get_wol,
|
|
|
|
.suspend = at803x_suspend,
|
|
|
|
.resume = at803x_resume,
|
|
|
|
/* PHY_BASIC_FEATURES */
|
|
|
|
.config_intr = at803x_config_intr,
|
2020-11-01 15:50:59 +03:00
|
|
|
.handle_interrupt = at803x_handle_interrupt,
|
2020-05-27 08:08:43 +03:00
|
|
|
.cable_test_start = at803x_cable_test_start,
|
|
|
|
.cable_test_get_status = at803x_cable_test_get_status,
|
2019-10-03 11:21:12 +03:00
|
|
|
}, {
|
|
|
|
/* ATHEROS AR9331 */
|
|
|
|
PHY_ID_MATCH_EXACT(ATH9331_PHY_ID),
|
2019-11-07 01:36:16 +03:00
|
|
|
.name = "Qualcomm Atheros AR9331 built-in PHY",
|
2019-10-03 11:21:12 +03:00
|
|
|
.suspend = at803x_suspend,
|
|
|
|
.resume = at803x_resume,
|
2020-05-27 08:08:43 +03:00
|
|
|
.flags = PHY_POLL_CABLE_TEST,
|
2019-10-03 11:21:12 +03:00
|
|
|
/* PHY_BASIC_FEATURES */
|
|
|
|
.config_intr = &at803x_config_intr,
|
2020-11-01 15:50:59 +03:00
|
|
|
.handle_interrupt = at803x_handle_interrupt,
|
2020-05-27 08:08:43 +03:00
|
|
|
.cable_test_start = at803x_cable_test_start,
|
|
|
|
.cable_test_get_status = at803x_cable_test_get_status,
|
2020-07-19 11:05:30 +03:00
|
|
|
.read_status = at803x_read_status,
|
|
|
|
.soft_reset = genphy_soft_reset,
|
|
|
|
.config_aneg = at803x_config_aneg,
|
2021-10-06 01:54:01 +03:00
|
|
|
}, {
|
|
|
|
/* Qualcomm Atheros QCA9561 */
|
|
|
|
PHY_ID_MATCH_EXACT(QCA9561_PHY_ID),
|
|
|
|
.name = "Qualcomm Atheros QCA9561 built-in PHY",
|
|
|
|
.suspend = at803x_suspend,
|
|
|
|
.resume = at803x_resume,
|
|
|
|
.flags = PHY_POLL_CABLE_TEST,
|
|
|
|
/* PHY_BASIC_FEATURES */
|
|
|
|
.config_intr = &at803x_config_intr,
|
|
|
|
.handle_interrupt = at803x_handle_interrupt,
|
|
|
|
.cable_test_start = at803x_cable_test_start,
|
|
|
|
.cable_test_get_status = at803x_cable_test_get_status,
|
|
|
|
.read_status = at803x_read_status,
|
|
|
|
.soft_reset = genphy_soft_reset,
|
|
|
|
.config_aneg = at803x_config_aneg,
|
2021-05-15 00:00:15 +03:00
|
|
|
}, {
|
|
|
|
/* QCA8337 */
|
2021-09-19 19:28:17 +03:00
|
|
|
.phy_id = QCA8337_PHY_ID,
|
|
|
|
.phy_id_mask = QCA8K_PHY_ID_MASK,
|
|
|
|
.name = "Qualcomm Atheros 8337 internal PHY",
|
2021-05-15 00:00:15 +03:00
|
|
|
/* PHY_GBIT_FEATURES */
|
2021-10-10 01:46:16 +03:00
|
|
|
.link_change_notify = qca83xx_link_change_notify,
|
2021-09-19 19:28:17 +03:00
|
|
|
.probe = at803x_probe,
|
|
|
|
.flags = PHY_IS_INTERNAL,
|
|
|
|
.config_init = qca83xx_config_init,
|
|
|
|
.soft_reset = genphy_soft_reset,
|
|
|
|
.get_sset_count = at803x_get_sset_count,
|
|
|
|
.get_strings = at803x_get_strings,
|
|
|
|
.get_stats = at803x_get_stats,
|
2021-10-10 01:46:15 +03:00
|
|
|
.suspend = qca83xx_suspend,
|
|
|
|
.resume = qca83xx_resume,
|
2021-09-14 15:33:45 +03:00
|
|
|
}, {
|
2021-09-19 19:28:15 +03:00
|
|
|
/* QCA8327-A from switch QCA8327-AL1A */
|
2021-09-19 19:28:17 +03:00
|
|
|
.phy_id = QCA8327_A_PHY_ID,
|
|
|
|
.phy_id_mask = QCA8K_PHY_ID_MASK,
|
|
|
|
.name = "Qualcomm Atheros 8327-A internal PHY",
|
2021-09-19 19:28:15 +03:00
|
|
|
/* PHY_GBIT_FEATURES */
|
2021-10-10 01:46:16 +03:00
|
|
|
.link_change_notify = qca83xx_link_change_notify,
|
2021-09-19 19:28:17 +03:00
|
|
|
.probe = at803x_probe,
|
|
|
|
.flags = PHY_IS_INTERNAL,
|
|
|
|
.config_init = qca83xx_config_init,
|
|
|
|
.soft_reset = genphy_soft_reset,
|
|
|
|
.get_sset_count = at803x_get_sset_count,
|
|
|
|
.get_strings = at803x_get_strings,
|
|
|
|
.get_stats = at803x_get_stats,
|
2021-10-10 01:46:15 +03:00
|
|
|
.suspend = qca83xx_suspend,
|
|
|
|
.resume = qca83xx_resume,
|
2021-09-19 19:28:15 +03:00
|
|
|
}, {
|
|
|
|
/* QCA8327-B from switch QCA8327-BL1A */
|
2021-09-19 19:28:17 +03:00
|
|
|
.phy_id = QCA8327_B_PHY_ID,
|
|
|
|
.phy_id_mask = QCA8K_PHY_ID_MASK,
|
|
|
|
.name = "Qualcomm Atheros 8327-B internal PHY",
|
2021-09-14 15:33:45 +03:00
|
|
|
/* PHY_GBIT_FEATURES */
|
2021-10-10 01:46:16 +03:00
|
|
|
.link_change_notify = qca83xx_link_change_notify,
|
2021-09-19 19:28:17 +03:00
|
|
|
.probe = at803x_probe,
|
|
|
|
.flags = PHY_IS_INTERNAL,
|
|
|
|
.config_init = qca83xx_config_init,
|
|
|
|
.soft_reset = genphy_soft_reset,
|
|
|
|
.get_sset_count = at803x_get_sset_count,
|
|
|
|
.get_strings = at803x_get_strings,
|
|
|
|
.get_stats = at803x_get_stats,
|
2021-10-10 01:46:15 +03:00
|
|
|
.suspend = qca83xx_suspend,
|
|
|
|
.resume = qca83xx_resume,
|
2021-05-15 00:00:15 +03:00
|
|
|
}, };
|
2012-10-14 23:07:16 +04:00
|
|
|
|
2014-11-11 21:45:59 +03:00
|
|
|
module_phy_driver(at803x_driver);
|
2012-10-14 23:07:16 +04:00
|
|
|
|
|
|
|
static struct mdio_device_id __maybe_unused atheros_tbl[] = {
|
2020-05-22 12:53:31 +03:00
|
|
|
{ ATH8030_PHY_ID, AT8030_PHY_ID_MASK },
|
|
|
|
{ PHY_ID_MATCH_EXACT(ATH8031_PHY_ID) },
|
2020-04-17 16:41:59 +03:00
|
|
|
{ PHY_ID_MATCH_EXACT(ATH8032_PHY_ID) },
|
2020-05-22 12:53:31 +03:00
|
|
|
{ PHY_ID_MATCH_EXACT(ATH8035_PHY_ID) },
|
2019-10-03 11:21:12 +03:00
|
|
|
{ PHY_ID_MATCH_EXACT(ATH9331_PHY_ID) },
|
2021-09-14 15:33:45 +03:00
|
|
|
{ PHY_ID_MATCH_EXACT(QCA8337_PHY_ID) },
|
2021-09-19 19:28:15 +03:00
|
|
|
{ PHY_ID_MATCH_EXACT(QCA8327_A_PHY_ID) },
|
|
|
|
{ PHY_ID_MATCH_EXACT(QCA8327_B_PHY_ID) },
|
2021-10-06 01:54:01 +03:00
|
|
|
{ PHY_ID_MATCH_EXACT(QCA9561_PHY_ID) },
|
2012-10-14 23:07:16 +04:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(mdio, atheros_tbl);
|