drivers/net/phy/at803x.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * drivers/net/phy/at803x.c
   4  *
   5  * Driver for Qualcomm Atheros AR803x PHY
   6  *
   7  * Author: Matus Ujhelyi <ujhelyi.m@gmail.com>
   8  */
   9
  10 #include <linux/phy.h>
  11 #include <linux/module.h>
  12 #include <linux/string.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/ethtool_netlink.h>
  16 #include <linux/of_gpio.h>
  17 #include <linux/bitfield.h>
  18 #include <linux/gpio/consumer.h>
  19 #include <linux/regulator/of_regulator.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/regulator/consumer.h>
  22 #include <dt-bindings/net/qca-ar803x.h>
  23
  24 #define AT803X_SPECIFIC_FUNCTION_CONTROL        0x10
  25 #define AT803X_SFC_ASSERT_CRS                   BIT(11)
  26 #define AT803X_SFC_FORCE_LINK                   BIT(10)
  27 #define AT803X_SFC_MDI_CROSSOVER_MODE_M         GENMASK(6, 5)
  28 #define AT803X_SFC_AUTOMATIC_CROSSOVER          0x3
  29 #define AT803X_SFC_MANUAL_MDIX                  0x1
  30 #define AT803X_SFC_MANUAL_MDI                   0x0
  31 #define AT803X_SFC_SQE_TEST                     BIT(2)
  32 #define AT803X_SFC_POLARITY_REVERSAL            BIT(1)
  33 #define AT803X_SFC_DISABLE_JABBER               BIT(0)
  34
  35 #define AT803X_SPECIFIC_STATUS                  0x11
  36 #define AT803X_SS_SPEED_MASK                    (3 << 14)
  37 #define AT803X_SS_SPEED_1000                    (2 << 14)
  38 #define AT803X_SS_SPEED_100                     (1 << 14)
  39 #define AT803X_SS_SPEED_10                      (0 << 14)
  40 #define AT803X_SS_DUPLEX                        BIT(13)
  41 #define AT803X_SS_SPEED_DUPLEX_RESOLVED         BIT(11)
  42 #define AT803X_SS_MDIX                          BIT(6)
  43
  44 #define AT803X_INTR_ENABLE                      0x12
  45 #define AT803X_INTR_ENABLE_AUTONEG_ERR          BIT(15)
  46 #define AT803X_INTR_ENABLE_SPEED_CHANGED        BIT(14)
  47 #define AT803X_INTR_ENABLE_DUPLEX_CHANGED       BIT(13)
  48 #define AT803X_INTR_ENABLE_PAGE_RECEIVED        BIT(12)
  49 #define AT803X_INTR_ENABLE_LINK_FAIL            BIT(11)
  50 #define AT803X_INTR_ENABLE_LINK_SUCCESS         BIT(10)
  51 #define AT803X_INTR_ENABLE_WIRESPEED_DOWNGRADE  BIT(5)
  52 #define AT803X_INTR_ENABLE_POLARITY_CHANGED     BIT(1)
  53 #define AT803X_INTR_ENABLE_WOL                  BIT(0)
  54
  55 #define AT803X_INTR_STATUS                      0x13
  56
  57 #define AT803X_SMART_SPEED                      0x14
  58 #define AT803X_SMART_SPEED_ENABLE               BIT(5)
  59 #define AT803X_SMART_SPEED_RETRY_LIMIT_MASK     GENMASK(4, 2)
  60 #define AT803X_SMART_SPEED_BYPASS_TIMER         BIT(1)
  61 #define AT803X_CDT                              0x16
  62 #define AT803X_CDT_MDI_PAIR_MASK                GENMASK(9, 8)
  63 #define AT803X_CDT_ENABLE_TEST                  BIT(0)
  64 #define AT803X_CDT_STATUS                       0x1c
  65 #define AT803X_CDT_STATUS_STAT_NORMAL           0
  66 #define AT803X_CDT_STATUS_STAT_SHORT            1
  67 #define AT803X_CDT_STATUS_STAT_OPEN             2
  68 #define AT803X_CDT_STATUS_STAT_FAIL             3
  69 #define AT803X_CDT_STATUS_STAT_MASK             GENMASK(9, 8)
  70 #define AT803X_CDT_STATUS_DELTA_TIME_MASK       GENMASK(7, 0)
  71 #define AT803X_LED_CONTROL                      0x18
  72
  73 #define AT803X_DEVICE_ADDR                      0x03
  74 #define AT803X_LOC_MAC_ADDR_0_15_OFFSET         0x804C
  75 #define AT803X_LOC_MAC_ADDR_16_31_OFFSET        0x804B
  76 #define AT803X_LOC_MAC_ADDR_32_47_OFFSET        0x804A
  77 #define AT803X_REG_CHIP_CONFIG                  0x1f
  78 #define AT803X_BT_BX_REG_SEL                    0x8000
  79
  80 #define AT803X_DEBUG_ADDR                       0x1D
  81 #define AT803X_DEBUG_DATA                       0x1E
  82
  83 #define AT803X_MODE_CFG_MASK                    0x0F
  84 #define AT803X_MODE_CFG_SGMII                   0x01
  85
  86 #define AT803X_PSSR                     0x11    /*PHY-Specific Status Register*/
  87 #define AT803X_PSSR_MR_AN_COMPLETE      0x0200
  88
  89 #define AT803X_DEBUG_REG_0                      0x00
  90 #define AT803X_DEBUG_RX_CLK_DLY_EN              BIT(15)
  91
  92 #define AT803X_DEBUG_REG_5                      0x05
  93 #define AT803X_DEBUG_TX_CLK_DLY_EN              BIT(8)
  94
  95 #define AT803X_DEBUG_REG_1F                     0x1F
  96 #define AT803X_DEBUG_PLL_ON                     BIT(2)
  97 #define AT803X_DEBUG_RGMII_1V8                  BIT(3)
  98
  99 /* AT803x supports either the XTAL input pad, an internal PLL or the
 100  * DSP as clock reference for the clock output pad. The XTAL reference
 101  * is only used for 25 MHz output, all other frequencies need the PLL.
 102  * The DSP as a clock reference is used in synchronous ethernet
 103  * applications.
 104  *
 105  * By default the PLL is only enabled if there is a link. Otherwise
 106  * the PHY will go into low power state and disabled the PLL. You can
 107  * set the PLL_ON bit (see debug register 0x1f) to keep the PLL always
 108  * enabled.
 109  */
 110 #define AT803X_MMD7_CLK25M                      0x8016
 111 #define AT803X_CLK_OUT_MASK                     GENMASK(4, 2)
 112 #define AT803X_CLK_OUT_25MHZ_XTAL               0
 113 #define AT803X_CLK_OUT_25MHZ_DSP                1
 114 #define AT803X_CLK_OUT_50MHZ_PLL                2
 115 #define AT803X_CLK_OUT_50MHZ_DSP                3
 116 #define AT803X_CLK_OUT_62_5MHZ_PLL              4
 117 #define AT803X_CLK_OUT_62_5MHZ_DSP              5
 118 #define AT803X_CLK_OUT_125MHZ_PLL               6
 119 #define AT803X_CLK_OUT_125MHZ_DSP               7
 120
 121 /* The AR8035 has another mask which is compatible with the AR8031/AR8033 mask
 122  * but doesn't support choosing between XTAL/PLL and DSP.
 123  */
 124 #define AT8035_CLK_OUT_MASK                     GENMASK(4, 3)
 125
 126 #define AT803X_CLK_OUT_STRENGTH_MASK            GENMASK(8, 7)
 127 #define AT803X_CLK_OUT_STRENGTH_FULL            0
 128 #define AT803X_CLK_OUT_STRENGTH_HALF            1
 129 #define AT803X_CLK_OUT_STRENGTH_QUARTER         2
 130
 131 #define AT803X_DEFAULT_DOWNSHIFT 5
 132 #define AT803X_MIN_DOWNSHIFT 2
 133 #define AT803X_MAX_DOWNSHIFT 9
 134
 135 #define ATH9331_PHY_ID 0x004dd041
 136 #define ATH8030_PHY_ID 0x004dd076
 137 #define ATH8031_PHY_ID 0x004dd074
 138 #define ATH8032_PHY_ID 0x004dd023
 139 #define ATH8035_PHY_ID 0x004dd072
 140 #define AT8030_PHY_ID_MASK                      0xffffffef
 141
 142 MODULE_DESCRIPTION("Qualcomm Atheros AR803x PHY driver");
 143 MODULE_AUTHOR("Matus Ujhelyi");
 144 MODULE_LICENSE("GPL");
 145
 146 struct at803x_priv {
 147         int flags;
 148 #define AT803X_KEEP_PLL_ENABLED BIT(0)  /* don't turn off internal PLL */
 149         u16 clk_25m_reg;
 150         u16 clk_25m_mask;
 151         struct regulator_dev *vddio_rdev;
 152         struct regulator_dev *vddh_rdev;
 153         struct regulator *vddio;
 154 };
 155
 156 struct at803x_context {
 157         u16 bmcr;
 158         u16 advertise;
 159         u16 control1000;
 160         u16 int_enable;
 161         u16 smart_speed;
 162         u16 led_control;
 163 };
 164
 165 static int at803x_debug_reg_read(struct phy_device *phydev, u16 reg)
 166 {
 167         int ret;
 168
 169         ret = phy_write(phydev, AT803X_DEBUG_ADDR, reg);
 170         if (ret < 0)
 171                 return ret;
 172
 173         return phy_read(phydev, AT803X_DEBUG_DATA);
 174 }
 175
 176 static int at803x_debug_reg_mask(struct phy_device *phydev, u16 reg,
 177                                  u16 clear, u16 set)
 178 {
 179         u16 val;
 180         int ret;
 181
 182         ret = at803x_debug_reg_read(phydev, reg);
 183         if (ret < 0)
 184                 return ret;
 185
 186         val = ret & 0xffff;
 187         val &= ~clear;
 188         val |= set;
 189
 190         return phy_write(phydev, AT803X_DEBUG_DATA, val);
 191 }
 192
 193 static int at803x_enable_rx_delay(struct phy_device *phydev)
 194 {
 195         return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_0, 0,
 196                                      AT803X_DEBUG_RX_CLK_DLY_EN);
 197 }
 198
 199 static int at803x_enable_tx_delay(struct phy_device *phydev)
 200 {
 201         return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_5, 0,
 202                                      AT803X_DEBUG_TX_CLK_DLY_EN);
 203 }
 204
 205 static int at803x_disable_rx_delay(struct phy_device *phydev)
 206 {
 207         return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_0,
 208                                      AT803X_DEBUG_RX_CLK_DLY_EN, 0);
 209 }
 210
 211 static int at803x_disable_tx_delay(struct phy_device *phydev)
 212 {
 213         return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_5,
 214                                      AT803X_DEBUG_TX_CLK_DLY_EN, 0);
 215 }
 216
 217 /* save relevant PHY registers to private copy */
 218 static void at803x_context_save(struct phy_device *phydev,
 219                                 struct at803x_context *context)
 220 {
 221         context->bmcr = phy_read(phydev, MII_BMCR);
 222         context->advertise = phy_read(phydev, MII_ADVERTISE);
 223         context->control1000 = phy_read(phydev, MII_CTRL1000);
 224         context->int_enable = phy_read(phydev, AT803X_INTR_ENABLE);
 225         context->smart_speed = phy_read(phydev, AT803X_SMART_SPEED);
 226         context->led_control = phy_read(phydev, AT803X_LED_CONTROL);
 227 }
 228
 229 /* restore relevant PHY registers from private copy */
 230 static void at803x_context_restore(struct phy_device *phydev,
 231                                    const struct at803x_context *context)
 232 {
 233         phy_write(phydev, MII_BMCR, context->bmcr);
 234         phy_write(phydev, MII_ADVERTISE, context->advertise);
 235         phy_write(phydev, MII_CTRL1000, context->control1000);
 236         phy_write(phydev, AT803X_INTR_ENABLE, context->int_enable);
 237         phy_write(phydev, AT803X_SMART_SPEED, context->smart_speed);
 238         phy_write(phydev, AT803X_LED_CONTROL, context->led_control);
 239 }
 240
 241 static int at803x_set_wol(struct phy_device *phydev,
 242                           struct ethtool_wolinfo *wol)
 243 {
 244         struct net_device *ndev = phydev->attached_dev;
 245         const u8 *mac;
 246         int ret;
 247         u32 value;
 248         unsigned int i, offsets[] = {
 249                 AT803X_LOC_MAC_ADDR_32_47_OFFSET,
 250                 AT803X_LOC_MAC_ADDR_16_31_OFFSET,
 251                 AT803X_LOC_MAC_ADDR_0_15_OFFSET,
 252         };
 253
 254         if (!ndev)
 255                 return -ENODEV;
 256
 257         if (wol->wolopts & WAKE_MAGIC) {
 258                 mac = (const u8 *) ndev->dev_addr;
 259
 260                 if (!is_valid_ether_addr(mac))
 261                         return -EINVAL;
 262
 263                 for (i = 0; i < 3; i++)
 264                         phy_write_mmd(phydev, AT803X_DEVICE_ADDR, offsets[i],
 265                                       mac[(i * 2) + 1] | (mac[(i * 2)] << 8));
 266
 267                 value = phy_read(phydev, AT803X_INTR_ENABLE);
 268                 value |= AT803X_INTR_ENABLE_WOL;
 269                 ret = phy_write(phydev, AT803X_INTR_ENABLE, value);
 270                 if (ret)
 271                         return ret;
 272                 value = phy_read(phydev, AT803X_INTR_STATUS);
 273         } else {
 274                 value = phy_read(phydev, AT803X_INTR_ENABLE);
 275                 value &= (~AT803X_INTR_ENABLE_WOL);
 276                 ret = phy_write(phydev, AT803X_INTR_ENABLE, value);
 277                 if (ret)
 278                         return ret;
 279                 value = phy_read(phydev, AT803X_INTR_STATUS);
 280         }
 281
 282         return ret;
 283 }
 284
 285 static void at803x_get_wol(struct phy_device *phydev,
 286                            struct ethtool_wolinfo *wol)
 287 {
 288         u32 value;
 289
 290         wol->supported = WAKE_MAGIC;
 291         wol->wolopts = 0;
 292
 293         value = phy_read(phydev, AT803X_INTR_ENABLE);
 294         if (value & AT803X_INTR_ENABLE_WOL)
 295                 wol->wolopts |= WAKE_MAGIC;
 296 }
 297
 298 static int at803x_suspend(struct phy_device *phydev)
 299 {
 300         int value;
 301         int wol_enabled;
 302
 303         value = phy_read(phydev, AT803X_INTR_ENABLE);
 304         wol_enabled = value & AT803X_INTR_ENABLE_WOL;
 305
 306         if (wol_enabled)
 307                 value = BMCR_ISOLATE;
 308         else
 309                 value = BMCR_PDOWN;
 310
 311         phy_modify(phydev, MII_BMCR, 0, value);
 312
 313         return 0;
 314 }
 315
 316 static int at803x_resume(struct phy_device *phydev)
 317 {
 318         return phy_modify(phydev, MII_BMCR, BMCR_PDOWN | BMCR_ISOLATE, 0);
 319 }
 320
 321 static int at803x_rgmii_reg_set_voltage_sel(struct regulator_dev *rdev,
 322                                             unsigned int selector)
 323 {
 324         struct phy_device *phydev = rdev_get_drvdata(rdev);
 325
 326         if (selector)
 327                 return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
 328                                              0, AT803X_DEBUG_RGMII_1V8);
 329         else
 330                 return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
 331                                              AT803X_DEBUG_RGMII_1V8, 0);
 332 }
 333
 334 static int at803x_rgmii_reg_get_voltage_sel(struct regulator_dev *rdev)
 335 {
 336         struct phy_device *phydev = rdev_get_drvdata(rdev);
 337         int val;
 338
 339         val = at803x_debug_reg_read(phydev, AT803X_DEBUG_REG_1F);
 340         if (val < 0)
 341                 return val;
 342
 343         return (val & AT803X_DEBUG_RGMII_1V8) ? 1 : 0;
 344 }
 345
 346 static const struct regulator_ops vddio_regulator_ops = {
 347         .list_voltage = regulator_list_voltage_table,
 348         .set_voltage_sel = at803x_rgmii_reg_set_voltage_sel,
 349         .get_voltage_sel = at803x_rgmii_reg_get_voltage_sel,
 350 };
 351
 352 static const unsigned int vddio_voltage_table[] = {
 353         1500000,
 354         1800000,
 355 };
 356
 357 static const struct regulator_desc vddio_desc = {
 358         .name = "vddio",
 359         .of_match = of_match_ptr("vddio-regulator"),
 360         .n_voltages = ARRAY_SIZE(vddio_voltage_table),
 361         .volt_table = vddio_voltage_table,
 362         .ops = &vddio_regulator_ops,
 363         .type = REGULATOR_VOLTAGE,
 364         .owner = THIS_MODULE,
 365 };
 366
 367 static const struct regulator_ops vddh_regulator_ops = {
 368 };
 369
 370 static const struct regulator_desc vddh_desc = {
 371         .name = "vddh",
 372         .of_match = of_match_ptr("vddh-regulator"),
 373         .n_voltages = 1,
 374         .fixed_uV = 2500000,
 375         .ops = &vddh_regulator_ops,
 376         .type = REGULATOR_VOLTAGE,
 377         .owner = THIS_MODULE,
 378 };
 379
 380 static int at8031_register_regulators(struct phy_device *phydev)
 381 {
 382         struct at803x_priv *priv = phydev->priv;
 383         struct device *dev = &phydev->mdio.dev;
 384         struct regulator_config config = { };
 385
 386         config.dev = dev;
 387         config.driver_data = phydev;
 388
 389         priv->vddio_rdev = devm_regulator_register(dev, &vddio_desc, &config);
 390         if (IS_ERR(priv->vddio_rdev)) {
 391                 phydev_err(phydev, "failed to register VDDIO regulator\n");
 392                 return PTR_ERR(priv->vddio_rdev);
 393         }
 394
 395         priv->vddh_rdev = devm_regulator_register(dev, &vddh_desc, &config);
 396         if (IS_ERR(priv->vddh_rdev)) {
 397                 phydev_err(phydev, "failed to register VDDH regulator\n");
 398                 return PTR_ERR(priv->vddh_rdev);
 399         }
 400
 401         return 0;
 402 }
 403
 404 static bool at803x_match_phy_id(struct phy_device *phydev, u32 phy_id)
 405 {
 406         return (phydev->phy_id & phydev->drv->phy_id_mask)
 407                 == (phy_id & phydev->drv->phy_id_mask);
 408 }
 409
 410 static int at803x_parse_dt(struct phy_device *phydev)
 411 {
 412         struct device_node *node = phydev->mdio.dev.of_node;
 413         struct at803x_priv *priv = phydev->priv;
 414         u32 freq, strength;
 415         unsigned int sel;
 416         int ret;
 417
 418         if (!IS_ENABLED(CONFIG_OF_MDIO))
 419                 return 0;
 420
 421         ret = of_property_read_u32(node, "qca,clk-out-frequency", &freq);
 422         if (!ret) {
 423                 switch (freq) {
 424                 case 25000000:
 425                         sel = AT803X_CLK_OUT_25MHZ_XTAL;
 426                         break;
 427                 case 50000000:
 428                         sel = AT803X_CLK_OUT_50MHZ_PLL;
 429                         break;
 430                 case 62500000:
 431                         sel = AT803X_CLK_OUT_62_5MHZ_PLL;
 432                         break;
 433                 case 125000000:
 434                         sel = AT803X_CLK_OUT_125MHZ_PLL;
 435                         break;
 436                 default:
 437                         phydev_err(phydev, "invalid qca,clk-out-frequency\n");
 438                         return -EINVAL;
 439                 }
 440
 441                 priv->clk_25m_reg |= FIELD_PREP(AT803X_CLK_OUT_MASK, sel);
 442                 priv->clk_25m_mask |= AT803X_CLK_OUT_MASK;
 443
 444                 /* Fixup for the AR8030/AR8035. This chip has another mask and
 445                  * doesn't support the DSP reference. Eg. the lowest bit of the
 446                  * mask. The upper two bits select the same frequencies. Mask
 447                  * the lowest bit here.
 448                  *
 449                  * Warning:
 450                  *   There was no datasheet for the AR8030 available so this is
 451                  *   just a guess. But the AR8035 is listed as pin compatible
 452                  *   to the AR8030 so there might be a good chance it works on
 453                  *   the AR8030 too.
 454                  */
 455                 if (at803x_match_phy_id(phydev, ATH8030_PHY_ID) ||
 456                     at803x_match_phy_id(phydev, ATH8035_PHY_ID)) {
 457                         priv->clk_25m_reg &= AT8035_CLK_OUT_MASK;
 458                         priv->clk_25m_mask &= AT8035_CLK_OUT_MASK;
 459                 }
 460         }
 461
 462         ret = of_property_read_u32(node, "qca,clk-out-strength", &strength);
 463         if (!ret) {
 464                 priv->clk_25m_mask |= AT803X_CLK_OUT_STRENGTH_MASK;
 465                 switch (strength) {
 466                 case AR803X_STRENGTH_FULL:
 467                         priv->clk_25m_reg |= AT803X_CLK_OUT_STRENGTH_FULL;
 468                         break;
 469                 case AR803X_STRENGTH_HALF:
 470                         priv->clk_25m_reg |= AT803X_CLK_OUT_STRENGTH_HALF;
 471                         break;
 472                 case AR803X_STRENGTH_QUARTER:
 473                         priv->clk_25m_reg |= AT803X_CLK_OUT_STRENGTH_QUARTER;
 474                         break;
 475                 default:
 476                         phydev_err(phydev, "invalid qca,clk-out-strength\n");
 477                         return -EINVAL;
 478                 }
 479         }
 480
 481         /* Only supported on AR8031/AR8033, the AR8030/AR8035 use strapping
 482          * options.
 483          */
 484         if (at803x_match_phy_id(phydev, ATH8031_PHY_ID)) {
 485                 if (of_property_read_bool(node, "qca,keep-pll-enabled"))
 486                         priv->flags |= AT803X_KEEP_PLL_ENABLED;
 487
 488                 ret = at8031_register_regulators(phydev);
 489                 if (ret < 0)
 490                         return ret;
 491
 492                 priv->vddio = devm_regulator_get_optional(&phydev->mdio.dev,
 493                                                           "vddio");
 494                 if (IS_ERR(priv->vddio)) {
 495                         phydev_err(phydev, "failed to get VDDIO regulator\n");
 496                         return PTR_ERR(priv->vddio);
 497                 }
 498
 499                 ret = regulator_enable(priv->vddio);
 500                 if (ret < 0)
 501                         return ret;
 502         }
 503
 504         return 0;
 505 }
 506
 507 static int at803x_probe(struct phy_device *phydev)
 508 {
 509         struct device *dev = &phydev->mdio.dev;
 510         struct at803x_priv *priv;
 511
 512         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 513         if (!priv)
 514                 return -ENOMEM;
 515
 516         phydev->priv = priv;
 517
 518         return at803x_parse_dt(phydev);
 519 }
 520
 521 static void at803x_remove(struct phy_device *phydev)
 522 {
 523         struct at803x_priv *priv = phydev->priv;
 524
 525         if (priv->vddio)
 526                 regulator_disable(priv->vddio);
 527 }
 528
 529 static int at803x_clk_out_config(struct phy_device *phydev)
 530 {
 531         struct at803x_priv *priv = phydev->priv;
 532         int val;
 533
 534         if (!priv->clk_25m_mask)
 535                 return 0;
 536
 537         val = phy_read_mmd(phydev, MDIO_MMD_AN, AT803X_MMD7_CLK25M);
 538         if (val < 0)
 539                 return val;
 540
 541         val &= ~priv->clk_25m_mask;
 542         val |= priv->clk_25m_reg;
 543
 544         return phy_write_mmd(phydev, MDIO_MMD_AN, AT803X_MMD7_CLK25M, val);
 545 }
 546
 547 static int at8031_pll_config(struct phy_device *phydev)
 548 {
 549         struct at803x_priv *priv = phydev->priv;
 550
 551         /* The default after hardware reset is PLL OFF. After a soft reset, the
 552          * values are retained.
 553          */
 554         if (priv->flags & AT803X_KEEP_PLL_ENABLED)
 555                 return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
 556                                              0, AT803X_DEBUG_PLL_ON);
 557         else
 558                 return at803x_debug_reg_mask(phydev, AT803X_DEBUG_REG_1F,
 559                                              AT803X_DEBUG_PLL_ON, 0);
 560 }
 561
 562 static int at803x_config_init(struct phy_device *phydev)
 563 {
 564         int ret;
 565
 566         /* The RX and TX delay default is:
 567          *   after HW reset: RX delay enabled and TX delay disabled
 568          *   after SW reset: RX delay enabled, while TX delay retains the
 569          *   value before reset.
 570          */
 571         if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
 572             phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
 573                 ret = at803x_enable_rx_delay(phydev);
 574         else
 575                 ret = at803x_disable_rx_delay(phydev);
 576         if (ret < 0)
 577                 return ret;
 578
 579         if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
 580             phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
 581                 ret = at803x_enable_tx_delay(phydev);
 582         else
 583                 ret = at803x_disable_tx_delay(phydev);
 584         if (ret < 0)
 585                 return ret;
 586
 587         ret = at803x_clk_out_config(phydev);
 588         if (ret < 0)
 589                 return ret;
 590
 591         if (at803x_match_phy_id(phydev, ATH8031_PHY_ID)) {
 592                 ret = at8031_pll_config(phydev);
 593                 if (ret < 0)
 594                         return ret;
 595         }
 596
 597         return 0;
 598 }
 599
 600 static int at803x_ack_interrupt(struct phy_device *phydev)
 601 {
 602         int err;
 603
 604         err = phy_read(phydev, AT803X_INTR_STATUS);
 605
 606         return (err < 0) ? err : 0;
 607 }
 608
 609 static int at803x_config_intr(struct phy_device *phydev)
 610 {
 611         int err;
 612         int value;
 613
 614         value = phy_read(phydev, AT803X_INTR_ENABLE);
 615
 616         if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
 617                 /* Clear any pending interrupts */
 618                 err = at803x_ack_interrupt(phydev);
 619                 if (err)
 620                         return err;
 621
 622                 value |= AT803X_INTR_ENABLE_AUTONEG_ERR;
 623                 value |= AT803X_INTR_ENABLE_SPEED_CHANGED;
 624                 value |= AT803X_INTR_ENABLE_DUPLEX_CHANGED;
 625                 value |= AT803X_INTR_ENABLE_LINK_FAIL;
 626                 value |= AT803X_INTR_ENABLE_LINK_SUCCESS;
 627
 628                 err = phy_write(phydev, AT803X_INTR_ENABLE, value);
 629         } else {
 630                 err = phy_write(phydev, AT803X_INTR_ENABLE, 0);
 631                 if (err)
 632                         return err;
 633
 634                 /* Clear any pending interrupts */
 635                 err = at803x_ack_interrupt(phydev);
 636         }
 637
 638         return err;
 639 }
 640
 641 static irqreturn_t at803x_handle_interrupt(struct phy_device *phydev)
 642 {
 643         int irq_status, int_enabled;
 644
 645         irq_status = phy_read(phydev, AT803X_INTR_STATUS);
 646         if (irq_status < 0) {
 647                 phy_error(phydev);
 648                 return IRQ_NONE;
 649         }
 650
 651         /* Read the current enabled interrupts */
 652         int_enabled = phy_read(phydev, AT803X_INTR_ENABLE);
 653         if (int_enabled < 0) {
 654                 phy_error(phydev);
 655                 return IRQ_NONE;
 656         }
 657
 658         /* See if this was one of our enabled interrupts */
 659         if (!(irq_status & int_enabled))
 660                 return IRQ_NONE;
 661
 662         phy_trigger_machine(phydev);
 663
 664         return IRQ_HANDLED;
 665 }
 666
 667 static void at803x_link_change_notify(struct phy_device *phydev)
 668 {
 669         /*
 670          * Conduct a hardware reset for AT8030 every time a link loss is
 671          * signalled. This is necessary to circumvent a hardware bug that
 672          * occurs when the cable is unplugged while TX packets are pending
 673          * in the FIFO. In such cases, the FIFO enters an error mode it
 674          * cannot recover from by software.
 675          */
 676         if (phydev->state == PHY_NOLINK && phydev->mdio.reset_gpio) {
 677                 struct at803x_context context;
 678
 679                 at803x_context_save(phydev, &context);
 680
 681                 phy_device_reset(phydev, 1);
 682                 msleep(1);
 683                 phy_device_reset(phydev, 0);
 684                 msleep(1);
 685
 686                 at803x_context_restore(phydev, &context);
 687
 688                 phydev_dbg(phydev, "%s(): phy was reset\n", __func__);
 689         }
 690 }
 691
 692 static int at803x_aneg_done(struct phy_device *phydev)
 693 {
 694         int ccr;
 695
 696         int aneg_done = genphy_aneg_done(phydev);
 697         if (aneg_done != BMSR_ANEGCOMPLETE)
 698                 return aneg_done;
 699
 700         /*
 701          * in SGMII mode, if copper side autoneg is successful,
 702          * also check SGMII side autoneg result
 703          */
 704         ccr = phy_read(phydev, AT803X_REG_CHIP_CONFIG);
 705         if ((ccr & AT803X_MODE_CFG_MASK) != AT803X_MODE_CFG_SGMII)
 706                 return aneg_done;
 707
 708         /* switch to SGMII/fiber page */
 709         phy_write(phydev, AT803X_REG_CHIP_CONFIG, ccr & ~AT803X_BT_BX_REG_SEL);
 710
 711         /* check if the SGMII link is OK. */
 712         if (!(phy_read(phydev, AT803X_PSSR) & AT803X_PSSR_MR_AN_COMPLETE)) {
 713                 phydev_warn(phydev, "803x_aneg_done: SGMII link is not ok\n");
 714                 aneg_done = 0;
 715         }
 716         /* switch back to copper page */
 717         phy_write(phydev, AT803X_REG_CHIP_CONFIG, ccr | AT803X_BT_BX_REG_SEL);
 718
 719         return aneg_done;
 720 }
 721
 722 static int at803x_read_status(struct phy_device *phydev)
 723 {
 724         int ss, err, old_link = phydev->link;
 725
 726         /* Update the link, but return if there was an error */
 727         err = genphy_update_link(phydev);
 728         if (err)
 729                 return err;
 730
 731         /* why bother the PHY if nothing can have changed */
 732         if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
 733                 return 0;
 734
 735         phydev->speed = SPEED_UNKNOWN;
 736         phydev->duplex = DUPLEX_UNKNOWN;
 737         phydev->pause = 0;
 738         phydev->asym_pause = 0;
 739
 740         err = genphy_read_lpa(phydev);
 741         if (err < 0)
 742                 return err;
 743
 744         /* Read the AT8035 PHY-Specific Status register, which indicates the
 745          * speed and duplex that the PHY is actually using, irrespective of
 746          * whether we are in autoneg mode or not.
 747          */
 748         ss = phy_read(phydev, AT803X_SPECIFIC_STATUS);
 749         if (ss < 0)
 750                 return ss;
 751
 752         if (ss & AT803X_SS_SPEED_DUPLEX_RESOLVED) {
 753                 int sfc;
 754
 755                 sfc = phy_read(phydev, AT803X_SPECIFIC_FUNCTION_CONTROL);
 756                 if (sfc < 0)
 757                         return sfc;
 758
 759                 switch (ss & AT803X_SS_SPEED_MASK) {
 760                 case AT803X_SS_SPEED_10:
 761                         phydev->speed = SPEED_10;
 762                         break;
 763                 case AT803X_SS_SPEED_100:
 764                         phydev->speed = SPEED_100;
 765                         break;
 766                 case AT803X_SS_SPEED_1000:
 767                         phydev->speed = SPEED_1000;
 768                         break;
 769                 }
 770                 if (ss & AT803X_SS_DUPLEX)
 771                         phydev->duplex = DUPLEX_FULL;
 772                 else
 773                         phydev->duplex = DUPLEX_HALF;
 774
 775                 if (ss & AT803X_SS_MDIX)
 776                         phydev->mdix = ETH_TP_MDI_X;
 777                 else
 778                         phydev->mdix = ETH_TP_MDI;
 779
 780                 switch (FIELD_GET(AT803X_SFC_MDI_CROSSOVER_MODE_M, sfc)) {
 781                 case AT803X_SFC_MANUAL_MDI:
 782                         phydev->mdix_ctrl = ETH_TP_MDI;
 783                         break;
 784                 case AT803X_SFC_MANUAL_MDIX:
 785                         phydev->mdix_ctrl = ETH_TP_MDI_X;
 786                         break;
 787                 case AT803X_SFC_AUTOMATIC_CROSSOVER:
 788                         phydev->mdix_ctrl = ETH_TP_MDI_AUTO;
 789                         break;
 790                 }
 791         }
 792
 793         if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete)
 794                 phy_resolve_aneg_pause(phydev);
 795
 796         return 0;
 797 }
 798
 799 static int at803x_config_mdix(struct phy_device *phydev, u8 ctrl)
 800 {
 801         u16 val;
 802
 803         switch (ctrl) {
 804         case ETH_TP_MDI:
 805                 val = AT803X_SFC_MANUAL_MDI;
 806                 break;
 807         case ETH_TP_MDI_X:
 808                 val = AT803X_SFC_MANUAL_MDIX;
 809                 break;
 810         case ETH_TP_MDI_AUTO:
 811                 val = AT803X_SFC_AUTOMATIC_CROSSOVER;
 812                 break;
 813         default:
 814                 return 0;
 815         }
 816
 817         return phy_modify_changed(phydev, AT803X_SPECIFIC_FUNCTION_CONTROL,
 818                           AT803X_SFC_MDI_CROSSOVER_MODE_M,
 819                           FIELD_PREP(AT803X_SFC_MDI_CROSSOVER_MODE_M, val));
 820 }
 821
 822 static int at803x_config_aneg(struct phy_device *phydev)
 823 {
 824         int ret;
 825
 826         ret = at803x_config_mdix(phydev, phydev->mdix_ctrl);
 827         if (ret < 0)
 828                 return ret;
 829
 830         /* Changes of the midx bits are disruptive to the normal operation;
 831          * therefore any changes to these registers must be followed by a
 832          * software reset to take effect.
 833          */
 834         if (ret == 1) {
 835                 ret = genphy_soft_reset(phydev);
 836                 if (ret < 0)
 837                         return ret;
 838         }
 839
 840         return genphy_config_aneg(phydev);
 841 }
 842
 843 static int at803x_get_downshift(struct phy_device *phydev, u8 *d)
 844 {
 845         int val;
 846
 847         val = phy_read(phydev, AT803X_SMART_SPEED);
 848         if (val < 0)
 849                 return val;
 850
 851         if (val & AT803X_SMART_SPEED_ENABLE)
 852                 *d = FIELD_GET(AT803X_SMART_SPEED_RETRY_LIMIT_MASK, val) + 2;
 853         else
 854                 *d = DOWNSHIFT_DEV_DISABLE;
 855
 856         return 0;
 857 }
 858
 859 static int at803x_set_downshift(struct phy_device *phydev, u8 cnt)
 860 {
 861         u16 mask, set;
 862         int ret;
 863
 864         switch (cnt) {
 865         case DOWNSHIFT_DEV_DEFAULT_COUNT:
 866                 cnt = AT803X_DEFAULT_DOWNSHIFT;
 867                 fallthrough;
 868         case AT803X_MIN_DOWNSHIFT ... AT803X_MAX_DOWNSHIFT:
 869                 set = AT803X_SMART_SPEED_ENABLE |
 870                       AT803X_SMART_SPEED_BYPASS_TIMER |
 871                       FIELD_PREP(AT803X_SMART_SPEED_RETRY_LIMIT_MASK, cnt - 2);
 872                 mask = AT803X_SMART_SPEED_RETRY_LIMIT_MASK;
 873                 break;
 874         case DOWNSHIFT_DEV_DISABLE:
 875                 set = 0;
 876                 mask = AT803X_SMART_SPEED_ENABLE |
 877                        AT803X_SMART_SPEED_BYPASS_TIMER;
 878                 break;
 879         default:
 880                 return -EINVAL;
 881         }
 882
 883         ret = phy_modify_changed(phydev, AT803X_SMART_SPEED, mask, set);
 884
 885         /* After changing the smart speed settings, we need to perform a
 886          * software reset, use phy_init_hw() to make sure we set the
 887          * reapply any values which might got lost during software reset.
 888          */
 889         if (ret == 1)
 890                 ret = phy_init_hw(phydev);
 891
 892         return ret;
 893 }
 894
 895 static int at803x_get_tunable(struct phy_device *phydev,
 896                               struct ethtool_tunable *tuna, void *data)
 897 {
 898         switch (tuna->id) {
 899         case ETHTOOL_PHY_DOWNSHIFT:
 900                 return at803x_get_downshift(phydev, data);
 901         default:
 902                 return -EOPNOTSUPP;
 903         }
 904 }
 905
 906 static int at803x_set_tunable(struct phy_device *phydev,
 907                               struct ethtool_tunable *tuna, const void *data)
 908 {
 909         switch (tuna->id) {
 910         case ETHTOOL_PHY_DOWNSHIFT:
 911                 return at803x_set_downshift(phydev, *(const u8 *)data);
 912         default:
 913                 return -EOPNOTSUPP;
 914         }
 915 }
 916
 917 static int at803x_cable_test_result_trans(u16 status)
 918 {
 919         switch (FIELD_GET(AT803X_CDT_STATUS_STAT_MASK, status)) {
 920         case AT803X_CDT_STATUS_STAT_NORMAL:
 921                 return ETHTOOL_A_CABLE_RESULT_CODE_OK;
 922         case AT803X_CDT_STATUS_STAT_SHORT:
 923                 return ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT;
 924         case AT803X_CDT_STATUS_STAT_OPEN:
 925                 return ETHTOOL_A_CABLE_RESULT_CODE_OPEN;
 926         case AT803X_CDT_STATUS_STAT_FAIL:
 927         default:
 928                 return ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC;
 929         }
 930 }
 931
 932 static bool at803x_cdt_test_failed(u16 status)
 933 {
 934         return FIELD_GET(AT803X_CDT_STATUS_STAT_MASK, status) ==
 935                 AT803X_CDT_STATUS_STAT_FAIL;
 936 }
 937
 938 static bool at803x_cdt_fault_length_valid(u16 status)
 939 {
 940         switch (FIELD_GET(AT803X_CDT_STATUS_STAT_MASK, status)) {
 941         case AT803X_CDT_STATUS_STAT_OPEN:
 942         case AT803X_CDT_STATUS_STAT_SHORT:
 943                 return true;
 944         }
 945         return false;
 946 }
 947
 948 static int at803x_cdt_fault_length(u16 status)
 949 {
 950         int dt;
 951
 952         /* According to the datasheet the distance to the fault is
 953          * DELTA_TIME * 0.824 meters.
 954          *
 955          * The author suspect the correct formula is:
 956          *
 957          *   fault_distance = DELTA_TIME * (c * VF) / 125MHz / 2
 958          *
 959          * where c is the speed of light, VF is the velocity factor of
 960          * the twisted pair cable, 125MHz the counter frequency and
 961          * we need to divide by 2 because the hardware will measure the
 962          * round trip time to the fault and back to the PHY.
 963          *
 964          * With a VF of 0.69 we get the factor 0.824 mentioned in the
 965          * datasheet.
 966          */
 967         dt = FIELD_GET(AT803X_CDT_STATUS_DELTA_TIME_MASK, status);
 968
 969         return (dt * 824) / 10;
 970 }
 971
 972 static int at803x_cdt_start(struct phy_device *phydev, int pair)
 973 {
 974         u16 cdt;
 975
 976         cdt = FIELD_PREP(AT803X_CDT_MDI_PAIR_MASK, pair) |
 977               AT803X_CDT_ENABLE_TEST;
 978
 979         return phy_write(phydev, AT803X_CDT, cdt);
 980 }
 981
 982 static int at803x_cdt_wait_for_completion(struct phy_device *phydev)
 983 {
 984         int val, ret;
 985
 986         /* One test run takes about 25ms */
 987         ret = phy_read_poll_timeout(phydev, AT803X_CDT, val,
 988                                     !(val & AT803X_CDT_ENABLE_TEST),
 989                                     30000, 100000, true);
 990
 991         return ret < 0 ? ret : 0;
 992 }
 993
 994 static int at803x_cable_test_one_pair(struct phy_device *phydev, int pair)
 995 {
 996         static const int ethtool_pair[] = {
 997                 ETHTOOL_A_CABLE_PAIR_A,
 998                 ETHTOOL_A_CABLE_PAIR_B,
 999                 ETHTOOL_A_CABLE_PAIR_C,
1000                 ETHTOOL_A_CABLE_PAIR_D,
1001         };
1002         int ret, val;
1003
1004         ret = at803x_cdt_start(phydev, pair);
1005         if (ret)
1006                 return ret;
1007
1008         ret = at803x_cdt_wait_for_completion(phydev);
1009         if (ret)
1010                 return ret;
1011
1012         val = phy_read(phydev, AT803X_CDT_STATUS);
1013         if (val < 0)
1014                 return val;
1015
1016         if (at803x_cdt_test_failed(val))
1017                 return 0;
1018
1019         ethnl_cable_test_result(phydev, ethtool_pair[pair],
1020                                 at803x_cable_test_result_trans(val));
1021
1022         if (at803x_cdt_fault_length_valid(val))
1023                 ethnl_cable_test_fault_length(phydev, ethtool_pair[pair],
1024                                               at803x_cdt_fault_length(val));
1025
1026         return 1;
1027 }
1028
1029 static int at803x_cable_test_get_status(struct phy_device *phydev,
1030                                         bool *finished)
1031 {
1032         unsigned long pair_mask;
1033         int retries = 20;
1034         int pair, ret;
1035
1036         if (phydev->phy_id == ATH9331_PHY_ID ||
1037             phydev->phy_id == ATH8032_PHY_ID)
1038                 pair_mask = 0x3;
1039         else
1040                 pair_mask = 0xf;
1041
1042         *finished = false;
1043
1044         /* According to the datasheet the CDT can be performed when
1045          * there is no link partner or when the link partner is
1046          * auto-negotiating. Starting the test will restart the AN
1047          * automatically. It seems that doing this repeatedly we will
1048          * get a slot where our link partner won't disturb our
1049          * measurement.
1050          */
1051         while (pair_mask && retries--) {
1052                 for_each_set_bit(pair, &pair_mask, 4) {
1053                         ret = at803x_cable_test_one_pair(phydev, pair);
1054                         if (ret < 0)
1055                                 return ret;
1056                         if (ret)
1057                                 clear_bit(pair, &pair_mask);
1058                 }
1059                 if (pair_mask)
1060                         msleep(250);
1061         }
1062
1063         *finished = true;
1064
1065         return 0;
1066 }
1067
1068 static int at803x_cable_test_start(struct phy_device *phydev)
1069 {
1070         /* Enable auto-negotiation, but advertise no capabilities, no link
1071          * will be established. A restart of the auto-negotiation is not
1072          * required, because the cable test will automatically break the link.
1073          */
1074         phy_write(phydev, MII_BMCR, BMCR_ANENABLE);
1075         phy_write(phydev, MII_ADVERTISE, ADVERTISE_CSMA);
1076         if (phydev->phy_id != ATH9331_PHY_ID &&
1077             phydev->phy_id != ATH8032_PHY_ID)
1078                 phy_write(phydev, MII_CTRL1000, 0);
1079
1080         /* we do all the (time consuming) work later */
1081         return 0;
1082 }
1083
1084 static struct phy_driver at803x_driver[] = {
1085 {
1086         /* Qualcomm Atheros AR8035 */
1087         PHY_ID_MATCH_EXACT(ATH8035_PHY_ID),
1088         .name                   = "Qualcomm Atheros AR8035",
1089         .flags                  = PHY_POLL_CABLE_TEST,
1090         .probe                  = at803x_probe,
1091         .remove                 = at803x_remove,
1092         .config_aneg            = at803x_config_aneg,
1093         .config_init            = at803x_config_init,
1094         .soft_reset             = genphy_soft_reset,
1095         .set_wol                = at803x_set_wol,
1096         .get_wol                = at803x_get_wol,
1097         .suspend                = at803x_suspend,
1098         .resume                 = at803x_resume,
1099         /* PHY_GBIT_FEATURES */
1100         .read_status            = at803x_read_status,
1101         .config_intr            = at803x_config_intr,
1102         .handle_interrupt       = at803x_handle_interrupt,
1103         .get_tunable            = at803x_get_tunable,
1104         .set_tunable            = at803x_set_tunable,
1105         .cable_test_start       = at803x_cable_test_start,
1106         .cable_test_get_status  = at803x_cable_test_get_status,
1107 }, {
1108         /* Qualcomm Atheros AR8030 */
1109         .phy_id                 = ATH8030_PHY_ID,
1110         .name                   = "Qualcomm Atheros AR8030",
1111         .phy_id_mask            = AT8030_PHY_ID_MASK,
1112         .probe                  = at803x_probe,
1113         .remove                 = at803x_remove,
1114         .config_init            = at803x_config_init,
1115         .link_change_notify     = at803x_link_change_notify,
1116         .set_wol                = at803x_set_wol,
1117         .get_wol                = at803x_get_wol,
1118         .suspend                = at803x_suspend,
1119         .resume                 = at803x_resume,
1120         /* PHY_BASIC_FEATURES */
1121         .config_intr            = at803x_config_intr,
1122         .handle_interrupt       = at803x_handle_interrupt,
1123 }, {
1124         /* Qualcomm Atheros AR8031/AR8033 */
1125         PHY_ID_MATCH_EXACT(ATH8031_PHY_ID),
1126         .name                   = "Qualcomm Atheros AR8031/AR8033",
1127         .flags                  = PHY_POLL_CABLE_TEST,
1128         .probe                  = at803x_probe,
1129         .remove                 = at803x_remove,
1130         .config_init            = at803x_config_init,
1131         .soft_reset             = genphy_soft_reset,
1132         .set_wol                = at803x_set_wol,
1133         .get_wol                = at803x_get_wol,
1134         .suspend                = at803x_suspend,
1135         .resume                 = at803x_resume,
1136         /* PHY_GBIT_FEATURES */
1137         .read_status            = at803x_read_status,
1138         .aneg_done              = at803x_aneg_done,
1139         .config_intr            = &at803x_config_intr,
1140         .handle_interrupt       = at803x_handle_interrupt,
1141         .get_tunable            = at803x_get_tunable,
1142         .set_tunable            = at803x_set_tunable,
1143         .cable_test_start       = at803x_cable_test_start,
1144         .cable_test_get_status  = at803x_cable_test_get_status,
1145 }, {
1146         /* Qualcomm Atheros AR8032 */
1147         PHY_ID_MATCH_EXACT(ATH8032_PHY_ID),
1148         .name                   = "Qualcomm Atheros AR8032",
1149         .probe                  = at803x_probe,
1150         .remove                 = at803x_remove,
1151         .flags                  = PHY_POLL_CABLE_TEST,
1152         .config_init            = at803x_config_init,
1153         .link_change_notify     = at803x_link_change_notify,
1154         .set_wol                = at803x_set_wol,
1155         .get_wol                = at803x_get_wol,
1156         .suspend                = at803x_suspend,
1157         .resume                 = at803x_resume,
1158         /* PHY_BASIC_FEATURES */
1159         .config_intr            = at803x_config_intr,
1160         .handle_interrupt       = at803x_handle_interrupt,
1161         .cable_test_start       = at803x_cable_test_start,
1162         .cable_test_get_status  = at803x_cable_test_get_status,
1163 }, {
1164         /* ATHEROS AR9331 */
1165         PHY_ID_MATCH_EXACT(ATH9331_PHY_ID),
1166         .name                   = "Qualcomm Atheros AR9331 built-in PHY",
1167         .suspend                = at803x_suspend,
1168         .resume                 = at803x_resume,
1169         .flags                  = PHY_POLL_CABLE_TEST,
1170         /* PHY_BASIC_FEATURES */
1171         .config_intr            = &at803x_config_intr,
1172         .handle_interrupt       = at803x_handle_interrupt,
1173         .cable_test_start       = at803x_cable_test_start,
1174         .cable_test_get_status  = at803x_cable_test_get_status,
1175         .read_status            = at803x_read_status,
1176         .soft_reset             = genphy_soft_reset,
1177         .config_aneg            = at803x_config_aneg,
1178 } };
1179
1180 module_phy_driver(at803x_driver);
1181
1182 static struct mdio_device_id __maybe_unused atheros_tbl[] = {
1183         { ATH8030_PHY_ID, AT8030_PHY_ID_MASK },
1184         { PHY_ID_MATCH_EXACT(ATH8031_PHY_ID) },
1185         { PHY_ID_MATCH_EXACT(ATH8032_PHY_ID) },
1186         { PHY_ID_MATCH_EXACT(ATH8035_PHY_ID) },
1187         { PHY_ID_MATCH_EXACT(ATH9331_PHY_ID) },
1188         { }
1189 };
1190
1191 MODULE_DEVICE_TABLE(mdio, atheros_tbl);