1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * drivers/net/phy/smsc.c 4 * 5 * Driver for SMSC PHYs 6 * 7 * Author: Herbert Valerio Riedel 8 * 9 * Copyright (c) 2006 Herbert Valerio Riedel <hvr@gnu.org> 10 * 11 * Support added for SMSC LAN8187 and LAN8700 by steve.glendinning@shawell.net 12 * 13 */ 14 15 #include <linux/clk.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/mii.h> 19 #include <linux/ethtool.h> 20 #include <linux/of.h> 21 #include <linux/phy.h> 22 #include <linux/netdevice.h> 23 #include <linux/crc16.h> 24 #include <linux/etherdevice.h> 25 #include <linux/smscphy.h> 26 27 /* Vendor-specific PHY Definitions */ 28 /* EDPD NLP / crossover time configuration */ 29 #define PHY_EDPD_CONFIG 16 30 #define PHY_EDPD_CONFIG_EXT_CROSSOVER_ 0x0001 31 32 /* Control/Status Indication Register */ 33 #define SPECIAL_CTRL_STS 27 34 #define SPECIAL_CTRL_STS_OVRRD_AMDIX_ 0x8000 35 #define SPECIAL_CTRL_STS_AMDIX_ENABLE_ 0x4000 36 #define SPECIAL_CTRL_STS_AMDIX_STATE_ 0x2000 37 38 #define EDPD_MAX_WAIT_DFLT_MS 640 39 /* interval between phylib state machine runs in ms */ 40 #define PHY_STATE_MACH_MS 1000 41 42 struct smsc_hw_stat { 43 const char *string; 44 u8 reg; 45 u8 bits; 46 }; 47 48 static struct smsc_hw_stat smsc_hw_stats[] = { 49 { "phy_symbol_errors", 26, 16}, 50 }; 51 52 struct smsc_phy_priv { 53 unsigned int edpd_enable:1; 54 unsigned int edpd_mode_set_by_user:1; 55 unsigned int edpd_max_wait_ms; 56 bool wol_arp; 57 }; 58 59 static int smsc_phy_ack_interrupt(struct phy_device *phydev) 60 { 61 int rc = phy_read(phydev, MII_LAN83C185_ISF); 62 63 return rc < 0 ? rc : 0; 64 } 65 66 int smsc_phy_config_intr(struct phy_device *phydev) 67 { 68 int rc; 69 70 if (phydev->interrupts == PHY_INTERRUPT_ENABLED) { 71 rc = smsc_phy_ack_interrupt(phydev); 72 if (rc) 73 return rc; 74 75 rc = phy_write(phydev, MII_LAN83C185_IM, 76 MII_LAN83C185_ISF_INT_PHYLIB_EVENTS); 77 } else { 78 rc = phy_write(phydev, MII_LAN83C185_IM, 0); 79 if (rc) 80 return rc; 81 82 rc = smsc_phy_ack_interrupt(phydev); 83 } 84 85 return rc < 0 ? rc : 0; 86 } 87 EXPORT_SYMBOL_GPL(smsc_phy_config_intr); 88 89 static int smsc_phy_config_edpd(struct phy_device *phydev) 90 { 91 struct smsc_phy_priv *priv = phydev->priv; 92 93 if (priv->edpd_enable) 94 return phy_set_bits(phydev, MII_LAN83C185_CTRL_STATUS, 95 MII_LAN83C185_EDPWRDOWN); 96 else 97 return phy_clear_bits(phydev, MII_LAN83C185_CTRL_STATUS, 98 MII_LAN83C185_EDPWRDOWN); 99 } 100 101 irqreturn_t smsc_phy_handle_interrupt(struct phy_device *phydev) 102 { 103 int irq_status; 104 105 irq_status = phy_read(phydev, MII_LAN83C185_ISF); 106 if (irq_status < 0) { 107 if (irq_status != -ENODEV) 108 phy_error(phydev); 109 110 return IRQ_NONE; 111 } 112 113 if (!(irq_status & MII_LAN83C185_ISF_INT_PHYLIB_EVENTS)) 114 return IRQ_NONE; 115 116 phy_trigger_machine(phydev); 117 118 return IRQ_HANDLED; 119 } 120 EXPORT_SYMBOL_GPL(smsc_phy_handle_interrupt); 121 122 int smsc_phy_config_init(struct phy_device *phydev) 123 { 124 struct smsc_phy_priv *priv = phydev->priv; 125 126 if (!priv) 127 return 0; 128 129 /* don't use EDPD in irq mode except overridden by user */ 130 if (!priv->edpd_mode_set_by_user && phydev->irq != PHY_POLL) 131 priv->edpd_enable = false; 132 133 return smsc_phy_config_edpd(phydev); 134 } 135 EXPORT_SYMBOL_GPL(smsc_phy_config_init); 136 137 static int smsc_phy_reset(struct phy_device *phydev) 138 { 139 int rc = phy_read(phydev, MII_LAN83C185_SPECIAL_MODES); 140 if (rc < 0) 141 return rc; 142 143 /* If the SMSC PHY is in power down mode, then set it 144 * in all capable mode before using it. 145 */ 146 if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) { 147 /* set "all capable" mode */ 148 rc |= MII_LAN83C185_MODE_ALL; 149 phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc); 150 } 151 152 /* reset the phy */ 153 return genphy_soft_reset(phydev); 154 } 155 156 static int lan87xx_config_aneg(struct phy_device *phydev) 157 { 158 int rc; 159 int val; 160 161 switch (phydev->mdix_ctrl) { 162 case ETH_TP_MDI: 163 val = SPECIAL_CTRL_STS_OVRRD_AMDIX_; 164 break; 165 case ETH_TP_MDI_X: 166 val = SPECIAL_CTRL_STS_OVRRD_AMDIX_ | 167 SPECIAL_CTRL_STS_AMDIX_STATE_; 168 break; 169 case ETH_TP_MDI_AUTO: 170 val = SPECIAL_CTRL_STS_AMDIX_ENABLE_; 171 break; 172 default: 173 return genphy_config_aneg(phydev); 174 } 175 176 rc = phy_read(phydev, SPECIAL_CTRL_STS); 177 if (rc < 0) 178 return rc; 179 180 rc &= ~(SPECIAL_CTRL_STS_OVRRD_AMDIX_ | 181 SPECIAL_CTRL_STS_AMDIX_ENABLE_ | 182 SPECIAL_CTRL_STS_AMDIX_STATE_); 183 rc |= val; 184 phy_write(phydev, SPECIAL_CTRL_STS, rc); 185 186 phydev->mdix = phydev->mdix_ctrl; 187 return genphy_config_aneg(phydev); 188 } 189 190 static int lan95xx_config_aneg_ext(struct phy_device *phydev) 191 { 192 if (phydev->phy_id == 0x0007c0f0) { /* LAN9500A or LAN9505A */ 193 /* Extend Manual AutoMDIX timer */ 194 int rc = phy_set_bits(phydev, PHY_EDPD_CONFIG, 195 PHY_EDPD_CONFIG_EXT_CROSSOVER_); 196 197 if (rc < 0) 198 return rc; 199 } 200 201 return lan87xx_config_aneg(phydev); 202 } 203 204 /* 205 * The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable 206 * plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to 207 * unstable detection of plugging in Ethernet cable. 208 * This workaround disables Energy Detect Power-Down mode and waiting for 209 * response on link pulses to detect presence of plugged Ethernet cable. 210 * The Energy Detect Power-Down mode is enabled again in the end of procedure to 211 * save approximately 220 mW of power if cable is unplugged. 212 * The workaround is only applicable to poll mode. Energy Detect Power-Down may 213 * not be used in interrupt mode lest link change detection becomes unreliable. 214 */ 215 int lan87xx_read_status(struct phy_device *phydev) 216 { 217 struct smsc_phy_priv *priv = phydev->priv; 218 int err; 219 220 err = genphy_read_status(phydev); 221 if (err) 222 return err; 223 224 if (!phydev->link && priv && priv->edpd_enable && 225 priv->edpd_max_wait_ms) { 226 unsigned int max_wait = priv->edpd_max_wait_ms * 1000; 227 int rc; 228 229 /* Disable EDPD to wake up PHY */ 230 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 231 if (rc < 0) 232 return rc; 233 234 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 235 rc & ~MII_LAN83C185_EDPWRDOWN); 236 if (rc < 0) 237 return rc; 238 239 /* Wait max 640 ms to detect energy and the timeout is not 240 * an actual error. 241 */ 242 read_poll_timeout(phy_read, rc, 243 rc & MII_LAN83C185_ENERGYON || rc < 0, 244 10000, max_wait, true, phydev, 245 MII_LAN83C185_CTRL_STATUS); 246 if (rc < 0) 247 return rc; 248 249 /* Re-enable EDPD */ 250 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 251 if (rc < 0) 252 return rc; 253 254 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 255 rc | MII_LAN83C185_EDPWRDOWN); 256 if (rc < 0) 257 return rc; 258 } 259 260 return err; 261 } 262 EXPORT_SYMBOL_GPL(lan87xx_read_status); 263 264 static int lan874x_phy_config_init(struct phy_device *phydev) 265 { 266 u16 val; 267 int rc; 268 269 /* Setup LED2/nINT/nPME pin to function as nPME. May need user option 270 * to use LED1/nINT/nPME. 271 */ 272 val = MII_LAN874X_PHY_PME2_SET; 273 274 /* The bits MII_LAN874X_PHY_WOL_PFDA_FR, MII_LAN874X_PHY_WOL_WUFR, 275 * MII_LAN874X_PHY_WOL_MPR, and MII_LAN874X_PHY_WOL_BCAST_FR need to 276 * be cleared to de-assert PME signal after a WoL event happens, but 277 * using PME auto clear gets around that. 278 */ 279 val |= MII_LAN874X_PHY_PME_SELF_CLEAR; 280 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, MII_LAN874X_PHY_MMD_WOL_WUCSR, 281 val); 282 if (rc < 0) 283 return rc; 284 285 /* set nPME self clear delay time */ 286 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, MII_LAN874X_PHY_MMD_MCFGR, 287 MII_LAN874X_PHY_PME_SELF_CLEAR_DELAY); 288 if (rc < 0) 289 return rc; 290 291 return smsc_phy_config_init(phydev); 292 } 293 294 static void lan874x_get_wol(struct phy_device *phydev, 295 struct ethtool_wolinfo *wol) 296 { 297 struct smsc_phy_priv *priv = phydev->priv; 298 int rc; 299 300 wol->supported = (WAKE_UCAST | WAKE_BCAST | WAKE_MAGIC | 301 WAKE_ARP | WAKE_MCAST); 302 wol->wolopts = 0; 303 304 rc = phy_read_mmd(phydev, MDIO_MMD_PCS, MII_LAN874X_PHY_MMD_WOL_WUCSR); 305 if (rc < 0) 306 return; 307 308 if (rc & MII_LAN874X_PHY_WOL_PFDAEN) 309 wol->wolopts |= WAKE_UCAST; 310 311 if (rc & MII_LAN874X_PHY_WOL_BCSTEN) 312 wol->wolopts |= WAKE_BCAST; 313 314 if (rc & MII_LAN874X_PHY_WOL_MPEN) 315 wol->wolopts |= WAKE_MAGIC; 316 317 if (rc & MII_LAN874X_PHY_WOL_WUEN) { 318 if (priv->wol_arp) 319 wol->wolopts |= WAKE_ARP; 320 else 321 wol->wolopts |= WAKE_MCAST; 322 } 323 } 324 325 static u16 smsc_crc16(const u8 *buffer, size_t len) 326 { 327 return bitrev16(crc16(0xFFFF, buffer, len)); 328 } 329 330 static int lan874x_chk_wol_pattern(const u8 pattern[], const u16 *mask, 331 u8 len, u8 *data, u8 *datalen) 332 { 333 size_t i, j, k; 334 int ret = 0; 335 u16 bits; 336 337 /* Pattern filtering can match up to 128 bytes of frame data. There 338 * are 8 registers to program the 16-bit masks, where each bit means 339 * the byte will be compared. The frame data will then go through a 340 * CRC16 calculation for hardware comparison. This helper function 341 * makes sure only relevant frame data are included in this 342 * calculation. It provides a warning when the masks and expected 343 * data size do not match. 344 */ 345 i = 0; 346 k = 0; 347 while (len > 0) { 348 bits = *mask; 349 for (j = 0; j < 16; j++, i++, len--) { 350 /* No more pattern. */ 351 if (!len) { 352 /* The rest of bitmap is not empty. */ 353 if (bits) 354 ret = i + 1; 355 break; 356 } 357 if (bits & 1) 358 data[k++] = pattern[i]; 359 bits >>= 1; 360 } 361 mask++; 362 } 363 *datalen = k; 364 return ret; 365 } 366 367 static int lan874x_set_wol_pattern(struct phy_device *phydev, u16 val, 368 const u8 data[], u8 datalen, 369 const u16 *mask, u8 masklen) 370 { 371 u16 crc, reg; 372 int rc; 373 374 /* Starting pattern offset is set before calling this function. */ 375 val |= MII_LAN874X_PHY_WOL_FILTER_EN; 376 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, 377 MII_LAN874X_PHY_MMD_WOL_WUF_CFGA, val); 378 if (rc < 0) 379 return rc; 380 381 crc = smsc_crc16(data, datalen); 382 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, 383 MII_LAN874X_PHY_MMD_WOL_WUF_CFGB, crc); 384 if (rc < 0) 385 return rc; 386 387 masklen = (masklen + 15) & ~0xf; 388 reg = MII_LAN874X_PHY_MMD_WOL_WUF_MASK7; 389 while (masklen >= 16) { 390 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, reg, *mask); 391 if (rc < 0) 392 return rc; 393 reg--; 394 mask++; 395 masklen -= 16; 396 } 397 398 /* Clear out the rest of mask registers. */ 399 while (reg != MII_LAN874X_PHY_MMD_WOL_WUF_MASK0) { 400 phy_write_mmd(phydev, MDIO_MMD_PCS, reg, 0); 401 reg--; 402 } 403 return rc; 404 } 405 406 static int lan874x_set_wol(struct phy_device *phydev, 407 struct ethtool_wolinfo *wol) 408 { 409 struct net_device *ndev = phydev->attached_dev; 410 struct smsc_phy_priv *priv = phydev->priv; 411 u16 val, val_wucsr; 412 u8 data[128]; 413 u8 datalen; 414 int rc; 415 416 /* lan874x has only one WoL filter pattern */ 417 if ((wol->wolopts & (WAKE_ARP | WAKE_MCAST)) == 418 (WAKE_ARP | WAKE_MCAST)) { 419 phydev_info(phydev, 420 "lan874x WoL supports one of ARP|MCAST at a time\n"); 421 return -EOPNOTSUPP; 422 } 423 424 rc = phy_read_mmd(phydev, MDIO_MMD_PCS, MII_LAN874X_PHY_MMD_WOL_WUCSR); 425 if (rc < 0) 426 return rc; 427 428 val_wucsr = rc; 429 430 if (wol->wolopts & WAKE_UCAST) 431 val_wucsr |= MII_LAN874X_PHY_WOL_PFDAEN; 432 else 433 val_wucsr &= ~MII_LAN874X_PHY_WOL_PFDAEN; 434 435 if (wol->wolopts & WAKE_BCAST) 436 val_wucsr |= MII_LAN874X_PHY_WOL_BCSTEN; 437 else 438 val_wucsr &= ~MII_LAN874X_PHY_WOL_BCSTEN; 439 440 if (wol->wolopts & WAKE_MAGIC) 441 val_wucsr |= MII_LAN874X_PHY_WOL_MPEN; 442 else 443 val_wucsr &= ~MII_LAN874X_PHY_WOL_MPEN; 444 445 /* Need to use pattern matching */ 446 if (wol->wolopts & (WAKE_ARP | WAKE_MCAST)) 447 val_wucsr |= MII_LAN874X_PHY_WOL_WUEN; 448 else 449 val_wucsr &= ~MII_LAN874X_PHY_WOL_WUEN; 450 451 if (wol->wolopts & WAKE_ARP) { 452 const u8 pattern[2] = { 0x08, 0x06 }; 453 const u16 mask[1] = { 0x0003 }; 454 455 rc = lan874x_chk_wol_pattern(pattern, mask, 2, data, 456 &datalen); 457 if (rc) 458 phydev_dbg(phydev, "pattern not valid at %d\n", rc); 459 460 /* Need to match broadcast destination address and provided 461 * data pattern at offset 12. 462 */ 463 val = 12 | MII_LAN874X_PHY_WOL_FILTER_BCSTEN; 464 rc = lan874x_set_wol_pattern(phydev, val, data, datalen, mask, 465 2); 466 if (rc < 0) 467 return rc; 468 priv->wol_arp = true; 469 } 470 471 if (wol->wolopts & WAKE_MCAST) { 472 /* Need to match multicast destination address. */ 473 val = MII_LAN874X_PHY_WOL_FILTER_MCASTTEN; 474 rc = lan874x_set_wol_pattern(phydev, val, data, 0, NULL, 0); 475 if (rc < 0) 476 return rc; 477 priv->wol_arp = false; 478 } 479 480 if (wol->wolopts & (WAKE_MAGIC | WAKE_UCAST)) { 481 const u8 *mac = (const u8 *)ndev->dev_addr; 482 int i, reg; 483 484 reg = MII_LAN874X_PHY_MMD_WOL_RX_ADDRC; 485 for (i = 0; i < 6; i += 2, reg--) { 486 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, reg, 487 ((mac[i + 1] << 8) | mac[i])); 488 if (rc < 0) 489 return rc; 490 } 491 } 492 493 rc = phy_write_mmd(phydev, MDIO_MMD_PCS, MII_LAN874X_PHY_MMD_WOL_WUCSR, 494 val_wucsr); 495 if (rc < 0) 496 return rc; 497 498 return 0; 499 } 500 501 static int smsc_get_sset_count(struct phy_device *phydev) 502 { 503 return ARRAY_SIZE(smsc_hw_stats); 504 } 505 506 static void smsc_get_strings(struct phy_device *phydev, u8 *data) 507 { 508 int i; 509 510 for (i = 0; i < ARRAY_SIZE(smsc_hw_stats); i++) 511 ethtool_puts(&data, smsc_hw_stats[i].string); 512 } 513 514 static u64 smsc_get_stat(struct phy_device *phydev, int i) 515 { 516 struct smsc_hw_stat stat = smsc_hw_stats[i]; 517 int val; 518 u64 ret; 519 520 val = phy_read(phydev, stat.reg); 521 if (val < 0) 522 ret = U64_MAX; 523 else 524 ret = val; 525 526 return ret; 527 } 528 529 static void smsc_get_stats(struct phy_device *phydev, 530 struct ethtool_stats *stats, u64 *data) 531 { 532 int i; 533 534 for (i = 0; i < ARRAY_SIZE(smsc_hw_stats); i++) 535 data[i] = smsc_get_stat(phydev, i); 536 } 537 538 static int smsc_phy_get_edpd(struct phy_device *phydev, u16 *edpd) 539 { 540 struct smsc_phy_priv *priv = phydev->priv; 541 542 if (!priv) 543 return -EOPNOTSUPP; 544 545 if (!priv->edpd_enable) 546 *edpd = ETHTOOL_PHY_EDPD_DISABLE; 547 else if (!priv->edpd_max_wait_ms) 548 *edpd = ETHTOOL_PHY_EDPD_NO_TX; 549 else 550 *edpd = PHY_STATE_MACH_MS + priv->edpd_max_wait_ms; 551 552 return 0; 553 } 554 555 static int smsc_phy_set_edpd(struct phy_device *phydev, u16 edpd) 556 { 557 struct smsc_phy_priv *priv = phydev->priv; 558 559 if (!priv) 560 return -EOPNOTSUPP; 561 562 switch (edpd) { 563 case ETHTOOL_PHY_EDPD_DISABLE: 564 priv->edpd_enable = false; 565 break; 566 case ETHTOOL_PHY_EDPD_NO_TX: 567 priv->edpd_enable = true; 568 priv->edpd_max_wait_ms = 0; 569 break; 570 case ETHTOOL_PHY_EDPD_DFLT_TX_MSECS: 571 edpd = PHY_STATE_MACH_MS + EDPD_MAX_WAIT_DFLT_MS; 572 fallthrough; 573 default: 574 if (phydev->irq != PHY_POLL) 575 return -EOPNOTSUPP; 576 if (edpd < PHY_STATE_MACH_MS || edpd > PHY_STATE_MACH_MS + 1000) 577 return -EINVAL; 578 priv->edpd_enable = true; 579 priv->edpd_max_wait_ms = edpd - PHY_STATE_MACH_MS; 580 } 581 582 priv->edpd_mode_set_by_user = true; 583 584 return smsc_phy_config_edpd(phydev); 585 } 586 587 int smsc_phy_get_tunable(struct phy_device *phydev, 588 struct ethtool_tunable *tuna, void *data) 589 { 590 switch (tuna->id) { 591 case ETHTOOL_PHY_EDPD: 592 return smsc_phy_get_edpd(phydev, data); 593 default: 594 return -EOPNOTSUPP; 595 } 596 } 597 EXPORT_SYMBOL_GPL(smsc_phy_get_tunable); 598 599 int smsc_phy_set_tunable(struct phy_device *phydev, 600 struct ethtool_tunable *tuna, const void *data) 601 { 602 switch (tuna->id) { 603 case ETHTOOL_PHY_EDPD: 604 return smsc_phy_set_edpd(phydev, *(u16 *)data); 605 default: 606 return -EOPNOTSUPP; 607 } 608 } 609 EXPORT_SYMBOL_GPL(smsc_phy_set_tunable); 610 611 int smsc_phy_probe(struct phy_device *phydev) 612 { 613 struct device *dev = &phydev->mdio.dev; 614 struct smsc_phy_priv *priv; 615 struct clk *refclk; 616 617 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 618 if (!priv) 619 return -ENOMEM; 620 621 priv->edpd_enable = true; 622 priv->edpd_max_wait_ms = EDPD_MAX_WAIT_DFLT_MS; 623 624 if (device_property_present(dev, "smsc,disable-energy-detect")) 625 priv->edpd_enable = false; 626 627 phydev->priv = priv; 628 629 /* Make clk optional to keep DTB backward compatibility. */ 630 refclk = devm_clk_get_optional_enabled_with_rate(dev, NULL, 631 50 * 1000 * 1000); 632 if (IS_ERR(refclk)) 633 return dev_err_probe(dev, PTR_ERR(refclk), 634 "Failed to request clock\n"); 635 636 return 0; 637 } 638 EXPORT_SYMBOL_GPL(smsc_phy_probe); 639 640 static struct phy_driver smsc_phy_driver[] = { 641 { 642 .phy_id = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */ 643 .phy_id_mask = 0xfffffff0, 644 .name = "SMSC LAN83C185", 645 646 /* PHY_BASIC_FEATURES */ 647 648 .probe = smsc_phy_probe, 649 650 /* basic functions */ 651 .config_init = smsc_phy_config_init, 652 .soft_reset = smsc_phy_reset, 653 654 /* IRQ related */ 655 .config_intr = smsc_phy_config_intr, 656 .handle_interrupt = smsc_phy_handle_interrupt, 657 658 .suspend = genphy_suspend, 659 .resume = genphy_resume, 660 }, { 661 .phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */ 662 .phy_id_mask = 0xfffffff0, 663 .name = "SMSC LAN8187", 664 665 /* PHY_BASIC_FEATURES */ 666 667 .probe = smsc_phy_probe, 668 669 /* basic functions */ 670 .config_init = smsc_phy_config_init, 671 .soft_reset = smsc_phy_reset, 672 673 /* IRQ related */ 674 .config_intr = smsc_phy_config_intr, 675 .handle_interrupt = smsc_phy_handle_interrupt, 676 677 /* Statistics */ 678 .get_sset_count = smsc_get_sset_count, 679 .get_strings = smsc_get_strings, 680 .get_stats = smsc_get_stats, 681 682 .suspend = genphy_suspend, 683 .resume = genphy_resume, 684 }, { 685 /* This covers internal PHY (phy_id: 0x0007C0C3) for 686 * LAN9500 (PID: 0x9500), LAN9514 (PID: 0xec00), LAN9505 (PID: 0x9505) 687 */ 688 .phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */ 689 .phy_id_mask = 0xfffffff0, 690 .name = "SMSC LAN8700", 691 692 /* PHY_BASIC_FEATURES */ 693 694 .probe = smsc_phy_probe, 695 696 /* basic functions */ 697 .read_status = lan87xx_read_status, 698 .config_init = smsc_phy_config_init, 699 .soft_reset = smsc_phy_reset, 700 .config_aneg = lan87xx_config_aneg, 701 702 /* IRQ related */ 703 .config_intr = smsc_phy_config_intr, 704 .handle_interrupt = smsc_phy_handle_interrupt, 705 706 /* Statistics */ 707 .get_sset_count = smsc_get_sset_count, 708 .get_strings = smsc_get_strings, 709 .get_stats = smsc_get_stats, 710 711 .get_tunable = smsc_phy_get_tunable, 712 .set_tunable = smsc_phy_set_tunable, 713 714 .suspend = genphy_suspend, 715 .resume = genphy_resume, 716 }, { 717 .phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */ 718 .phy_id_mask = 0xfffffff0, 719 .name = "SMSC LAN911x Internal PHY", 720 721 /* PHY_BASIC_FEATURES */ 722 723 .probe = smsc_phy_probe, 724 725 /* IRQ related */ 726 .config_intr = smsc_phy_config_intr, 727 .handle_interrupt = smsc_phy_handle_interrupt, 728 729 .suspend = genphy_suspend, 730 .resume = genphy_resume, 731 }, { 732 /* This covers internal PHY (phy_id: 0x0007C0F0) for 733 * LAN9500A (PID: 0x9E00), LAN9505A (PID: 0x9E01) 734 */ 735 .phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */ 736 .phy_id_mask = 0xfffffff0, 737 .name = "SMSC LAN8710/LAN8720", 738 739 /* PHY_BASIC_FEATURES */ 740 741 .probe = smsc_phy_probe, 742 743 /* basic functions */ 744 .read_status = lan87xx_read_status, 745 .config_init = smsc_phy_config_init, 746 .soft_reset = smsc_phy_reset, 747 .config_aneg = lan95xx_config_aneg_ext, 748 749 /* IRQ related */ 750 .config_intr = smsc_phy_config_intr, 751 .handle_interrupt = smsc_phy_handle_interrupt, 752 753 /* Statistics */ 754 .get_sset_count = smsc_get_sset_count, 755 .get_strings = smsc_get_strings, 756 .get_stats = smsc_get_stats, 757 758 .get_tunable = smsc_phy_get_tunable, 759 .set_tunable = smsc_phy_set_tunable, 760 761 .suspend = genphy_suspend, 762 .resume = genphy_resume, 763 }, { 764 .phy_id = 0x0007c110, 765 .phy_id_mask = 0xfffffff0, 766 .name = "SMSC LAN8740", 767 768 /* PHY_BASIC_FEATURES */ 769 .flags = PHY_RST_AFTER_CLK_EN, 770 771 .probe = smsc_phy_probe, 772 773 /* basic functions */ 774 .read_status = lan87xx_read_status, 775 .config_init = lan874x_phy_config_init, 776 .soft_reset = smsc_phy_reset, 777 778 /* IRQ related */ 779 .config_intr = smsc_phy_config_intr, 780 .handle_interrupt = smsc_phy_handle_interrupt, 781 782 /* Statistics */ 783 .get_sset_count = smsc_get_sset_count, 784 .get_strings = smsc_get_strings, 785 .get_stats = smsc_get_stats, 786 787 .get_tunable = smsc_phy_get_tunable, 788 .set_tunable = smsc_phy_set_tunable, 789 790 /* WoL */ 791 .set_wol = lan874x_set_wol, 792 .get_wol = lan874x_get_wol, 793 794 .suspend = genphy_suspend, 795 .resume = genphy_resume, 796 }, { 797 .phy_id = 0x0007c130, /* 0x0007c130 and 0x0007c131 */ 798 /* This mask (0xfffffff2) is to differentiate from 799 * LAN88xx (phy_id 0x0007c132) 800 * and allows future phy_id revisions. 801 */ 802 .phy_id_mask = 0xfffffff2, 803 .name = "Microchip LAN8742", 804 805 /* PHY_BASIC_FEATURES */ 806 .flags = PHY_RST_AFTER_CLK_EN, 807 808 .probe = smsc_phy_probe, 809 810 /* basic functions */ 811 .read_status = lan87xx_read_status, 812 .config_init = lan874x_phy_config_init, 813 .soft_reset = smsc_phy_reset, 814 815 /* IRQ related */ 816 .config_intr = smsc_phy_config_intr, 817 .handle_interrupt = smsc_phy_handle_interrupt, 818 819 /* Statistics */ 820 .get_sset_count = smsc_get_sset_count, 821 .get_strings = smsc_get_strings, 822 .get_stats = smsc_get_stats, 823 824 .get_tunable = smsc_phy_get_tunable, 825 .set_tunable = smsc_phy_set_tunable, 826 827 /* WoL */ 828 .set_wol = lan874x_set_wol, 829 .get_wol = lan874x_get_wol, 830 831 .suspend = genphy_suspend, 832 .resume = genphy_resume, 833 } }; 834 835 module_phy_driver(smsc_phy_driver); 836 837 MODULE_DESCRIPTION("SMSC PHY driver"); 838 MODULE_AUTHOR("Herbert Valerio Riedel"); 839 MODULE_LICENSE("GPL"); 840 841 static struct mdio_device_id __maybe_unused smsc_tbl[] = { 842 { 0x0007c0a0, 0xfffffff0 }, 843 { 0x0007c0b0, 0xfffffff0 }, 844 { 0x0007c0c0, 0xfffffff0 }, 845 { 0x0007c0d0, 0xfffffff0 }, 846 { 0x0007c0f0, 0xfffffff0 }, 847 { 0x0007c110, 0xfffffff0 }, 848 { 0x0007c130, 0xfffffff2 }, 849 { } 850 }; 851 852 MODULE_DEVICE_TABLE(mdio, smsc_tbl); 853