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); 1192