1 /* 2 * drivers/net/phy/broadcom.c 3 * 4 * Broadcom BCM5411, BCM5421 and BCM5461 Gigabit Ethernet 5 * transceivers. 6 * 7 * Copyright (c) 2006 Maciej W. Rozycki 8 * 9 * Inspired by code written by Amy Fong. 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 */ 16 17 #include "bcm-phy-lib.h" 18 #include <linux/module.h> 19 #include <linux/phy.h> 20 #include <linux/brcmphy.h> 21 22 23 #define BRCM_PHY_MODEL(phydev) \ 24 ((phydev)->drv->phy_id & (phydev)->drv->phy_id_mask) 25 26 #define BRCM_PHY_REV(phydev) \ 27 ((phydev)->drv->phy_id & ~((phydev)->drv->phy_id_mask)) 28 29 MODULE_DESCRIPTION("Broadcom PHY driver"); 30 MODULE_AUTHOR("Maciej W. Rozycki"); 31 MODULE_LICENSE("GPL"); 32 33 static int bcm54xx_auxctl_write(struct phy_device *phydev, u16 regnum, u16 val) 34 { 35 return phy_write(phydev, MII_BCM54XX_AUX_CTL, regnum | val); 36 } 37 38 /* Needs SMDSP clock enabled via bcm54xx_phydsp_config() */ 39 static int bcm50610_a0_workaround(struct phy_device *phydev) 40 { 41 int err; 42 43 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_AADJ1CH0, 44 MII_BCM54XX_EXP_AADJ1CH0_SWP_ABCD_OEN | 45 MII_BCM54XX_EXP_AADJ1CH0_SWSEL_THPF); 46 if (err < 0) 47 return err; 48 49 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_AADJ1CH3, 50 MII_BCM54XX_EXP_AADJ1CH3_ADCCKADJ); 51 if (err < 0) 52 return err; 53 54 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_EXP75, 55 MII_BCM54XX_EXP_EXP75_VDACCTRL); 56 if (err < 0) 57 return err; 58 59 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_EXP96, 60 MII_BCM54XX_EXP_EXP96_MYST); 61 if (err < 0) 62 return err; 63 64 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_EXP97, 65 MII_BCM54XX_EXP_EXP97_MYST); 66 67 return err; 68 } 69 70 static int bcm54xx_phydsp_config(struct phy_device *phydev) 71 { 72 int err, err2; 73 74 /* Enable the SMDSP clock */ 75 err = bcm54xx_auxctl_write(phydev, 76 MII_BCM54XX_AUXCTL_SHDWSEL_AUXCTL, 77 MII_BCM54XX_AUXCTL_ACTL_SMDSP_ENA | 78 MII_BCM54XX_AUXCTL_ACTL_TX_6DB); 79 if (err < 0) 80 return err; 81 82 if (BRCM_PHY_MODEL(phydev) == PHY_ID_BCM50610 || 83 BRCM_PHY_MODEL(phydev) == PHY_ID_BCM50610M) { 84 /* Clear bit 9 to fix a phy interop issue. */ 85 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_EXP08, 86 MII_BCM54XX_EXP_EXP08_RJCT_2MHZ); 87 if (err < 0) 88 goto error; 89 90 if (phydev->drv->phy_id == PHY_ID_BCM50610) { 91 err = bcm50610_a0_workaround(phydev); 92 if (err < 0) 93 goto error; 94 } 95 } 96 97 if (BRCM_PHY_MODEL(phydev) == PHY_ID_BCM57780) { 98 int val; 99 100 val = bcm_phy_read_exp(phydev, MII_BCM54XX_EXP_EXP75); 101 if (val < 0) 102 goto error; 103 104 val |= MII_BCM54XX_EXP_EXP75_CM_OSC; 105 err = bcm_phy_write_exp(phydev, MII_BCM54XX_EXP_EXP75, val); 106 } 107 108 error: 109 /* Disable the SMDSP clock */ 110 err2 = bcm54xx_auxctl_write(phydev, 111 MII_BCM54XX_AUXCTL_SHDWSEL_AUXCTL, 112 MII_BCM54XX_AUXCTL_ACTL_TX_6DB); 113 114 /* Return the first error reported. */ 115 return err ? err : err2; 116 } 117 118 static void bcm54xx_adjust_rxrefclk(struct phy_device *phydev) 119 { 120 u32 orig; 121 int val; 122 bool clk125en = true; 123 124 /* Abort if we are using an untested phy. */ 125 if (BRCM_PHY_MODEL(phydev) != PHY_ID_BCM57780 && 126 BRCM_PHY_MODEL(phydev) != PHY_ID_BCM50610 && 127 BRCM_PHY_MODEL(phydev) != PHY_ID_BCM50610M) 128 return; 129 130 val = bcm_phy_read_shadow(phydev, BCM54XX_SHD_SCR3); 131 if (val < 0) 132 return; 133 134 orig = val; 135 136 if ((BRCM_PHY_MODEL(phydev) == PHY_ID_BCM50610 || 137 BRCM_PHY_MODEL(phydev) == PHY_ID_BCM50610M) && 138 BRCM_PHY_REV(phydev) >= 0x3) { 139 /* 140 * Here, bit 0 _disables_ CLK125 when set. 141 * This bit is set by default. 142 */ 143 clk125en = false; 144 } else { 145 if (phydev->dev_flags & PHY_BRCM_RX_REFCLK_UNUSED) { 146 /* Here, bit 0 _enables_ CLK125 when set */ 147 val &= ~BCM54XX_SHD_SCR3_DEF_CLK125; 148 clk125en = false; 149 } 150 } 151 152 if (!clk125en || (phydev->dev_flags & PHY_BRCM_AUTO_PWRDWN_ENABLE)) 153 val &= ~BCM54XX_SHD_SCR3_DLLAPD_DIS; 154 else 155 val |= BCM54XX_SHD_SCR3_DLLAPD_DIS; 156 157 if (phydev->dev_flags & PHY_BRCM_DIS_TXCRXC_NOENRGY) 158 val |= BCM54XX_SHD_SCR3_TRDDAPD; 159 160 if (orig != val) 161 bcm_phy_write_shadow(phydev, BCM54XX_SHD_SCR3, val); 162 163 val = bcm_phy_read_shadow(phydev, BCM54XX_SHD_APD); 164 if (val < 0) 165 return; 166 167 orig = val; 168 169 if (!clk125en || (phydev->dev_flags & PHY_BRCM_AUTO_PWRDWN_ENABLE)) 170 val |= BCM54XX_SHD_APD_EN; 171 else 172 val &= ~BCM54XX_SHD_APD_EN; 173 174 if (orig != val) 175 bcm_phy_write_shadow(phydev, BCM54XX_SHD_APD, val); 176 } 177 178 static int bcm54xx_config_init(struct phy_device *phydev) 179 { 180 int reg, err; 181 182 reg = phy_read(phydev, MII_BCM54XX_ECR); 183 if (reg < 0) 184 return reg; 185 186 /* Mask interrupts globally. */ 187 reg |= MII_BCM54XX_ECR_IM; 188 err = phy_write(phydev, MII_BCM54XX_ECR, reg); 189 if (err < 0) 190 return err; 191 192 /* Unmask events we are interested in. */ 193 reg = ~(MII_BCM54XX_INT_DUPLEX | 194 MII_BCM54XX_INT_SPEED | 195 MII_BCM54XX_INT_LINK); 196 err = phy_write(phydev, MII_BCM54XX_IMR, reg); 197 if (err < 0) 198 return err; 199 200 if ((BRCM_PHY_MODEL(phydev) == PHY_ID_BCM50610 || 201 BRCM_PHY_MODEL(phydev) == PHY_ID_BCM50610M) && 202 (phydev->dev_flags & PHY_BRCM_CLEAR_RGMII_MODE)) 203 bcm_phy_write_shadow(phydev, BCM54XX_SHD_RGMII_MODE, 0); 204 205 if ((phydev->dev_flags & PHY_BRCM_RX_REFCLK_UNUSED) || 206 (phydev->dev_flags & PHY_BRCM_DIS_TXCRXC_NOENRGY) || 207 (phydev->dev_flags & PHY_BRCM_AUTO_PWRDWN_ENABLE)) 208 bcm54xx_adjust_rxrefclk(phydev); 209 210 bcm54xx_phydsp_config(phydev); 211 212 return 0; 213 } 214 215 static int bcm5482_config_init(struct phy_device *phydev) 216 { 217 int err, reg; 218 219 err = bcm54xx_config_init(phydev); 220 221 if (phydev->dev_flags & PHY_BCM_FLAGS_MODE_1000BX) { 222 /* 223 * Enable secondary SerDes and its use as an LED source 224 */ 225 reg = bcm_phy_read_shadow(phydev, BCM5482_SHD_SSD); 226 bcm_phy_write_shadow(phydev, BCM5482_SHD_SSD, 227 reg | 228 BCM5482_SHD_SSD_LEDM | 229 BCM5482_SHD_SSD_EN); 230 231 /* 232 * Enable SGMII slave mode and auto-detection 233 */ 234 reg = BCM5482_SSD_SGMII_SLAVE | MII_BCM54XX_EXP_SEL_SSD; 235 err = bcm_phy_read_exp(phydev, reg); 236 if (err < 0) 237 return err; 238 err = bcm_phy_write_exp(phydev, reg, err | 239 BCM5482_SSD_SGMII_SLAVE_EN | 240 BCM5482_SSD_SGMII_SLAVE_AD); 241 if (err < 0) 242 return err; 243 244 /* 245 * Disable secondary SerDes powerdown 246 */ 247 reg = BCM5482_SSD_1000BX_CTL | MII_BCM54XX_EXP_SEL_SSD; 248 err = bcm_phy_read_exp(phydev, reg); 249 if (err < 0) 250 return err; 251 err = bcm_phy_write_exp(phydev, reg, 252 err & ~BCM5482_SSD_1000BX_CTL_PWRDOWN); 253 if (err < 0) 254 return err; 255 256 /* 257 * Select 1000BASE-X register set (primary SerDes) 258 */ 259 reg = bcm_phy_read_shadow(phydev, BCM5482_SHD_MODE); 260 bcm_phy_write_shadow(phydev, BCM5482_SHD_MODE, 261 reg | BCM5482_SHD_MODE_1000BX); 262 263 /* 264 * LED1=ACTIVITYLED, LED3=LINKSPD[2] 265 * (Use LED1 as secondary SerDes ACTIVITY LED) 266 */ 267 bcm_phy_write_shadow(phydev, BCM5482_SHD_LEDS1, 268 BCM5482_SHD_LEDS1_LED1(BCM_LED_SRC_ACTIVITYLED) | 269 BCM5482_SHD_LEDS1_LED3(BCM_LED_SRC_LINKSPD2)); 270 271 /* 272 * Auto-negotiation doesn't seem to work quite right 273 * in this mode, so we disable it and force it to the 274 * right speed/duplex setting. Only 'link status' 275 * is important. 276 */ 277 phydev->autoneg = AUTONEG_DISABLE; 278 phydev->speed = SPEED_1000; 279 phydev->duplex = DUPLEX_FULL; 280 } 281 282 return err; 283 } 284 285 static int bcm5482_read_status(struct phy_device *phydev) 286 { 287 int err; 288 289 err = genphy_read_status(phydev); 290 291 if (phydev->dev_flags & PHY_BCM_FLAGS_MODE_1000BX) { 292 /* 293 * Only link status matters for 1000Base-X mode, so force 294 * 1000 Mbit/s full-duplex status 295 */ 296 if (phydev->link) { 297 phydev->speed = SPEED_1000; 298 phydev->duplex = DUPLEX_FULL; 299 } 300 } 301 302 return err; 303 } 304 305 static int bcm5481_config_aneg(struct phy_device *phydev) 306 { 307 int ret; 308 309 /* Aneg firsly. */ 310 ret = genphy_config_aneg(phydev); 311 312 /* Then we can set up the delay. */ 313 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) { 314 u16 reg; 315 316 /* 317 * There is no BCM5481 specification available, so down 318 * here is everything we know about "register 0x18". This 319 * at least helps BCM5481 to successfully receive packets 320 * on MPC8360E-RDK board. Peter Barada <peterb@logicpd.com> 321 * says: "This sets delay between the RXD and RXC signals 322 * instead of using trace lengths to achieve timing". 323 */ 324 325 /* Set RDX clk delay. */ 326 reg = 0x7 | (0x7 << 12); 327 phy_write(phydev, 0x18, reg); 328 329 reg = phy_read(phydev, 0x18); 330 /* Set RDX-RXC skew. */ 331 reg |= (1 << 8); 332 /* Write bits 14:0. */ 333 reg |= (1 << 15); 334 phy_write(phydev, 0x18, reg); 335 } 336 337 return ret; 338 } 339 340 static int brcm_phy_setbits(struct phy_device *phydev, int reg, int set) 341 { 342 int val; 343 344 val = phy_read(phydev, reg); 345 if (val < 0) 346 return val; 347 348 return phy_write(phydev, reg, val | set); 349 } 350 351 static int brcm_fet_config_init(struct phy_device *phydev) 352 { 353 int reg, err, err2, brcmtest; 354 355 /* Reset the PHY to bring it to a known state. */ 356 err = phy_write(phydev, MII_BMCR, BMCR_RESET); 357 if (err < 0) 358 return err; 359 360 reg = phy_read(phydev, MII_BRCM_FET_INTREG); 361 if (reg < 0) 362 return reg; 363 364 /* Unmask events we are interested in and mask interrupts globally. */ 365 reg = MII_BRCM_FET_IR_DUPLEX_EN | 366 MII_BRCM_FET_IR_SPEED_EN | 367 MII_BRCM_FET_IR_LINK_EN | 368 MII_BRCM_FET_IR_ENABLE | 369 MII_BRCM_FET_IR_MASK; 370 371 err = phy_write(phydev, MII_BRCM_FET_INTREG, reg); 372 if (err < 0) 373 return err; 374 375 /* Enable shadow register access */ 376 brcmtest = phy_read(phydev, MII_BRCM_FET_BRCMTEST); 377 if (brcmtest < 0) 378 return brcmtest; 379 380 reg = brcmtest | MII_BRCM_FET_BT_SRE; 381 382 err = phy_write(phydev, MII_BRCM_FET_BRCMTEST, reg); 383 if (err < 0) 384 return err; 385 386 /* Set the LED mode */ 387 reg = phy_read(phydev, MII_BRCM_FET_SHDW_AUXMODE4); 388 if (reg < 0) { 389 err = reg; 390 goto done; 391 } 392 393 reg &= ~MII_BRCM_FET_SHDW_AM4_LED_MASK; 394 reg |= MII_BRCM_FET_SHDW_AM4_LED_MODE1; 395 396 err = phy_write(phydev, MII_BRCM_FET_SHDW_AUXMODE4, reg); 397 if (err < 0) 398 goto done; 399 400 /* Enable auto MDIX */ 401 err = brcm_phy_setbits(phydev, MII_BRCM_FET_SHDW_MISCCTRL, 402 MII_BRCM_FET_SHDW_MC_FAME); 403 if (err < 0) 404 goto done; 405 406 if (phydev->dev_flags & PHY_BRCM_AUTO_PWRDWN_ENABLE) { 407 /* Enable auto power down */ 408 err = brcm_phy_setbits(phydev, MII_BRCM_FET_SHDW_AUXSTAT2, 409 MII_BRCM_FET_SHDW_AS2_APDE); 410 } 411 412 done: 413 /* Disable shadow register access */ 414 err2 = phy_write(phydev, MII_BRCM_FET_BRCMTEST, brcmtest); 415 if (!err) 416 err = err2; 417 418 return err; 419 } 420 421 static int brcm_fet_ack_interrupt(struct phy_device *phydev) 422 { 423 int reg; 424 425 /* Clear pending interrupts. */ 426 reg = phy_read(phydev, MII_BRCM_FET_INTREG); 427 if (reg < 0) 428 return reg; 429 430 return 0; 431 } 432 433 static int brcm_fet_config_intr(struct phy_device *phydev) 434 { 435 int reg, err; 436 437 reg = phy_read(phydev, MII_BRCM_FET_INTREG); 438 if (reg < 0) 439 return reg; 440 441 if (phydev->interrupts == PHY_INTERRUPT_ENABLED) 442 reg &= ~MII_BRCM_FET_IR_MASK; 443 else 444 reg |= MII_BRCM_FET_IR_MASK; 445 446 err = phy_write(phydev, MII_BRCM_FET_INTREG, reg); 447 return err; 448 } 449 450 static struct phy_driver broadcom_drivers[] = { 451 { 452 .phy_id = PHY_ID_BCM5411, 453 .phy_id_mask = 0xfffffff0, 454 .name = "Broadcom BCM5411", 455 .features = PHY_GBIT_FEATURES | 456 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 457 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 458 .config_init = bcm54xx_config_init, 459 .config_aneg = genphy_config_aneg, 460 .read_status = genphy_read_status, 461 .ack_interrupt = bcm_phy_ack_intr, 462 .config_intr = bcm_phy_config_intr, 463 .driver = { .owner = THIS_MODULE }, 464 }, { 465 .phy_id = PHY_ID_BCM5421, 466 .phy_id_mask = 0xfffffff0, 467 .name = "Broadcom BCM5421", 468 .features = PHY_GBIT_FEATURES | 469 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 470 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 471 .config_init = bcm54xx_config_init, 472 .config_aneg = genphy_config_aneg, 473 .read_status = genphy_read_status, 474 .ack_interrupt = bcm_phy_ack_intr, 475 .config_intr = bcm_phy_config_intr, 476 .driver = { .owner = THIS_MODULE }, 477 }, { 478 .phy_id = PHY_ID_BCM5461, 479 .phy_id_mask = 0xfffffff0, 480 .name = "Broadcom BCM5461", 481 .features = PHY_GBIT_FEATURES | 482 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 483 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 484 .config_init = bcm54xx_config_init, 485 .config_aneg = genphy_config_aneg, 486 .read_status = genphy_read_status, 487 .ack_interrupt = bcm_phy_ack_intr, 488 .config_intr = bcm_phy_config_intr, 489 .driver = { .owner = THIS_MODULE }, 490 }, { 491 .phy_id = PHY_ID_BCM54616S, 492 .phy_id_mask = 0xfffffff0, 493 .name = "Broadcom BCM54616S", 494 .features = PHY_GBIT_FEATURES | 495 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 496 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 497 .config_init = bcm54xx_config_init, 498 .config_aneg = genphy_config_aneg, 499 .read_status = genphy_read_status, 500 .ack_interrupt = bcm_phy_ack_intr, 501 .config_intr = bcm_phy_config_intr, 502 .driver = { .owner = THIS_MODULE }, 503 }, { 504 .phy_id = PHY_ID_BCM5464, 505 .phy_id_mask = 0xfffffff0, 506 .name = "Broadcom BCM5464", 507 .features = PHY_GBIT_FEATURES | 508 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 509 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 510 .config_init = bcm54xx_config_init, 511 .config_aneg = genphy_config_aneg, 512 .read_status = genphy_read_status, 513 .ack_interrupt = bcm_phy_ack_intr, 514 .config_intr = bcm_phy_config_intr, 515 .driver = { .owner = THIS_MODULE }, 516 }, { 517 .phy_id = PHY_ID_BCM5481, 518 .phy_id_mask = 0xfffffff0, 519 .name = "Broadcom BCM5481", 520 .features = PHY_GBIT_FEATURES | 521 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 522 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 523 .config_init = bcm54xx_config_init, 524 .config_aneg = bcm5481_config_aneg, 525 .read_status = genphy_read_status, 526 .ack_interrupt = bcm_phy_ack_intr, 527 .config_intr = bcm_phy_config_intr, 528 .driver = { .owner = THIS_MODULE }, 529 }, { 530 .phy_id = PHY_ID_BCM5482, 531 .phy_id_mask = 0xfffffff0, 532 .name = "Broadcom BCM5482", 533 .features = PHY_GBIT_FEATURES | 534 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 535 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 536 .config_init = bcm5482_config_init, 537 .config_aneg = genphy_config_aneg, 538 .read_status = bcm5482_read_status, 539 .ack_interrupt = bcm_phy_ack_intr, 540 .config_intr = bcm_phy_config_intr, 541 .driver = { .owner = THIS_MODULE }, 542 }, { 543 .phy_id = PHY_ID_BCM50610, 544 .phy_id_mask = 0xfffffff0, 545 .name = "Broadcom BCM50610", 546 .features = PHY_GBIT_FEATURES | 547 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 548 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 549 .config_init = bcm54xx_config_init, 550 .config_aneg = genphy_config_aneg, 551 .read_status = genphy_read_status, 552 .ack_interrupt = bcm_phy_ack_intr, 553 .config_intr = bcm_phy_config_intr, 554 .driver = { .owner = THIS_MODULE }, 555 }, { 556 .phy_id = PHY_ID_BCM50610M, 557 .phy_id_mask = 0xfffffff0, 558 .name = "Broadcom BCM50610M", 559 .features = PHY_GBIT_FEATURES | 560 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 561 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 562 .config_init = bcm54xx_config_init, 563 .config_aneg = genphy_config_aneg, 564 .read_status = genphy_read_status, 565 .ack_interrupt = bcm_phy_ack_intr, 566 .config_intr = bcm_phy_config_intr, 567 .driver = { .owner = THIS_MODULE }, 568 }, { 569 .phy_id = PHY_ID_BCM57780, 570 .phy_id_mask = 0xfffffff0, 571 .name = "Broadcom BCM57780", 572 .features = PHY_GBIT_FEATURES | 573 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 574 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 575 .config_init = bcm54xx_config_init, 576 .config_aneg = genphy_config_aneg, 577 .read_status = genphy_read_status, 578 .ack_interrupt = bcm_phy_ack_intr, 579 .config_intr = bcm_phy_config_intr, 580 .driver = { .owner = THIS_MODULE }, 581 }, { 582 .phy_id = PHY_ID_BCMAC131, 583 .phy_id_mask = 0xfffffff0, 584 .name = "Broadcom BCMAC131", 585 .features = PHY_BASIC_FEATURES | 586 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 587 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 588 .config_init = brcm_fet_config_init, 589 .config_aneg = genphy_config_aneg, 590 .read_status = genphy_read_status, 591 .ack_interrupt = brcm_fet_ack_interrupt, 592 .config_intr = brcm_fet_config_intr, 593 .driver = { .owner = THIS_MODULE }, 594 }, { 595 .phy_id = PHY_ID_BCM5241, 596 .phy_id_mask = 0xfffffff0, 597 .name = "Broadcom BCM5241", 598 .features = PHY_BASIC_FEATURES | 599 SUPPORTED_Pause | SUPPORTED_Asym_Pause, 600 .flags = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT, 601 .config_init = brcm_fet_config_init, 602 .config_aneg = genphy_config_aneg, 603 .read_status = genphy_read_status, 604 .ack_interrupt = brcm_fet_ack_interrupt, 605 .config_intr = brcm_fet_config_intr, 606 .driver = { .owner = THIS_MODULE }, 607 } }; 608 609 module_phy_driver(broadcom_drivers); 610 611 static struct mdio_device_id __maybe_unused broadcom_tbl[] = { 612 { PHY_ID_BCM5411, 0xfffffff0 }, 613 { PHY_ID_BCM5421, 0xfffffff0 }, 614 { PHY_ID_BCM5461, 0xfffffff0 }, 615 { PHY_ID_BCM54616S, 0xfffffff0 }, 616 { PHY_ID_BCM5464, 0xfffffff0 }, 617 { PHY_ID_BCM5481, 0xfffffff0 }, 618 { PHY_ID_BCM5482, 0xfffffff0 }, 619 { PHY_ID_BCM50610, 0xfffffff0 }, 620 { PHY_ID_BCM50610M, 0xfffffff0 }, 621 { PHY_ID_BCM57780, 0xfffffff0 }, 622 { PHY_ID_BCMAC131, 0xfffffff0 }, 623 { PHY_ID_BCM5241, 0xfffffff0 }, 624 { } 625 }; 626 627 MODULE_DEVICE_TABLE(mdio, broadcom_tbl); 628