1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2015 4 * Elecsys Corporation <www.elecsyscorp.com> 5 * Kevin Smith <kevin.smith@elecsyscorp.com> 6 * 7 * Original driver: 8 * (C) Copyright 2009 9 * Marvell Semiconductor <www.marvell.com> 10 * Prafulla Wadaskar <prafulla@marvell.com> 11 */ 12 13 /* 14 * PHY driver for mv88e61xx ethernet switches. 15 * 16 * This driver configures the mv88e61xx for basic use as a PHY. The switch 17 * supports a VLAN configuration that determines how traffic will be routed 18 * between the ports. This driver uses a simple configuration that routes 19 * traffic from each PHY port only to the CPU port, and from the CPU port to 20 * any PHY port. 21 * 22 * The configuration determines which PHY ports to activate using the 23 * CONFIG_MV88E61XX_PHY_PORTS bitmask. Setting bit 0 will activate port 0, bit 24 * 1 activates port 1, etc. Do not set the bit for the port the CPU is 25 * connected to unless it is connected over a PHY interface (not MII). 26 * 27 * This driver was written for and tested on the mv88e6176 with an SGMII 28 * connection. Other configurations should be supported, but some additions or 29 * changes may be required. 30 */ 31 32 #include <common.h> 33 34 #include <bitfield.h> 35 #include <errno.h> 36 #include <malloc.h> 37 #include <miiphy.h> 38 #include <netdev.h> 39 40 #define PHY_AUTONEGOTIATE_TIMEOUT 5000 41 42 #define PORT_COUNT 11 43 #define PORT_MASK ((1 << PORT_COUNT) - 1) 44 45 /* Device addresses */ 46 #define DEVADDR_PHY(p) (p) 47 #define DEVADDR_PORT(p) (0x10 + (p)) 48 #define DEVADDR_SERDES 0x0F 49 #define DEVADDR_GLOBAL_1 0x1B 50 #define DEVADDR_GLOBAL_2 0x1C 51 52 /* SMI indirection registers for multichip addressing mode */ 53 #define SMI_CMD_REG 0x00 54 #define SMI_DATA_REG 0x01 55 56 /* Global registers */ 57 #define GLOBAL1_STATUS 0x00 58 #define GLOBAL1_CTRL 0x04 59 #define GLOBAL1_MON_CTRL 0x1A 60 61 /* Global 2 registers */ 62 #define GLOBAL2_REG_PHY_CMD 0x18 63 #define GLOBAL2_REG_PHY_DATA 0x19 64 65 /* Port registers */ 66 #define PORT_REG_STATUS 0x00 67 #define PORT_REG_PHYS_CTRL 0x01 68 #define PORT_REG_SWITCH_ID 0x03 69 #define PORT_REG_CTRL 0x04 70 #define PORT_REG_VLAN_MAP 0x06 71 #define PORT_REG_VLAN_ID 0x07 72 73 /* Phy registers */ 74 #define PHY_REG_CTRL1 0x10 75 #define PHY_REG_STATUS1 0x11 76 #define PHY_REG_PAGE 0x16 77 78 /* Serdes registers */ 79 #define SERDES_REG_CTRL_1 0x10 80 81 /* Phy page numbers */ 82 #define PHY_PAGE_COPPER 0 83 #define PHY_PAGE_SERDES 1 84 85 /* Register fields */ 86 #define GLOBAL1_CTRL_SWRESET BIT(15) 87 88 #define GLOBAL1_MON_CTRL_CPUDEST_SHIFT 4 89 #define GLOBAL1_MON_CTRL_CPUDEST_WIDTH 4 90 91 #define PORT_REG_STATUS_LINK BIT(11) 92 #define PORT_REG_STATUS_DUPLEX BIT(10) 93 94 #define PORT_REG_STATUS_SPEED_SHIFT 8 95 #define PORT_REG_STATUS_SPEED_WIDTH 2 96 #define PORT_REG_STATUS_SPEED_10 0 97 #define PORT_REG_STATUS_SPEED_100 1 98 #define PORT_REG_STATUS_SPEED_1000 2 99 100 #define PORT_REG_STATUS_CMODE_MASK 0xF 101 #define PORT_REG_STATUS_CMODE_100BASE_X 0x8 102 #define PORT_REG_STATUS_CMODE_1000BASE_X 0x9 103 #define PORT_REG_STATUS_CMODE_SGMII 0xa 104 105 #define PORT_REG_PHYS_CTRL_PCS_AN_EN BIT(10) 106 #define PORT_REG_PHYS_CTRL_PCS_AN_RST BIT(9) 107 #define PORT_REG_PHYS_CTRL_FC_VALUE BIT(7) 108 #define PORT_REG_PHYS_CTRL_FC_FORCE BIT(6) 109 #define PORT_REG_PHYS_CTRL_LINK_VALUE BIT(5) 110 #define PORT_REG_PHYS_CTRL_LINK_FORCE BIT(4) 111 #define PORT_REG_PHYS_CTRL_DUPLEX_VALUE BIT(3) 112 #define PORT_REG_PHYS_CTRL_DUPLEX_FORCE BIT(2) 113 #define PORT_REG_PHYS_CTRL_SPD1000 BIT(1) 114 #define PORT_REG_PHYS_CTRL_SPD_MASK (BIT(1) | BIT(0)) 115 116 #define PORT_REG_CTRL_PSTATE_SHIFT 0 117 #define PORT_REG_CTRL_PSTATE_WIDTH 2 118 119 #define PORT_REG_VLAN_ID_DEF_VID_SHIFT 0 120 #define PORT_REG_VLAN_ID_DEF_VID_WIDTH 12 121 122 #define PORT_REG_VLAN_MAP_TABLE_SHIFT 0 123 #define PORT_REG_VLAN_MAP_TABLE_WIDTH 11 124 125 #define SERDES_REG_CTRL_1_FORCE_LINK BIT(10) 126 127 #define PHY_REG_CTRL1_ENERGY_DET_SHIFT 8 128 #define PHY_REG_CTRL1_ENERGY_DET_WIDTH 2 129 130 /* Field values */ 131 #define PORT_REG_CTRL_PSTATE_DISABLED 0 132 #define PORT_REG_CTRL_PSTATE_FORWARD 3 133 134 #define PHY_REG_CTRL1_ENERGY_DET_OFF 0 135 #define PHY_REG_CTRL1_ENERGY_DET_SENSE_ONLY 2 136 #define PHY_REG_CTRL1_ENERGY_DET_SENSE_XMIT 3 137 138 /* PHY Status Register */ 139 #define PHY_REG_STATUS1_SPEED 0xc000 140 #define PHY_REG_STATUS1_GBIT 0x8000 141 #define PHY_REG_STATUS1_100 0x4000 142 #define PHY_REG_STATUS1_DUPLEX 0x2000 143 #define PHY_REG_STATUS1_SPDDONE 0x0800 144 #define PHY_REG_STATUS1_LINK 0x0400 145 #define PHY_REG_STATUS1_ENERGY 0x0010 146 147 /* 148 * Macros for building commands for indirect addressing modes. These are valid 149 * for both the indirect multichip addressing mode and the PHY indirection 150 * required for the writes to any PHY register. 151 */ 152 #define SMI_BUSY BIT(15) 153 #define SMI_CMD_CLAUSE_22 BIT(12) 154 #define SMI_CMD_CLAUSE_22_OP_READ (2 << 10) 155 #define SMI_CMD_CLAUSE_22_OP_WRITE (1 << 10) 156 157 #define SMI_CMD_READ (SMI_BUSY | SMI_CMD_CLAUSE_22 | \ 158 SMI_CMD_CLAUSE_22_OP_READ) 159 #define SMI_CMD_WRITE (SMI_BUSY | SMI_CMD_CLAUSE_22 | \ 160 SMI_CMD_CLAUSE_22_OP_WRITE) 161 162 #define SMI_CMD_ADDR_SHIFT 5 163 #define SMI_CMD_ADDR_WIDTH 5 164 #define SMI_CMD_REG_SHIFT 0 165 #define SMI_CMD_REG_WIDTH 5 166 167 /* Check for required macros */ 168 #ifndef CONFIG_MV88E61XX_PHY_PORTS 169 #error Define CONFIG_MV88E61XX_PHY_PORTS to indicate which physical ports \ 170 to activate 171 #endif 172 #ifndef CONFIG_MV88E61XX_CPU_PORT 173 #error Define CONFIG_MV88E61XX_CPU_PORT to the port the CPU is attached to 174 #endif 175 176 /* 177 * These are ports without PHYs that may be wired directly 178 * to other serdes interfaces 179 */ 180 #ifndef CONFIG_MV88E61XX_FIXED_PORTS 181 #define CONFIG_MV88E61XX_FIXED_PORTS 0 182 #endif 183 184 /* ID register values for different switch models */ 185 #define PORT_SWITCH_ID_6096 0x0980 186 #define PORT_SWITCH_ID_6097 0x0990 187 #define PORT_SWITCH_ID_6172 0x1720 188 #define PORT_SWITCH_ID_6176 0x1760 189 #define PORT_SWITCH_ID_6240 0x2400 190 #define PORT_SWITCH_ID_6352 0x3520 191 192 struct mv88e61xx_phy_priv { 193 struct mii_dev *mdio_bus; 194 int smi_addr; 195 int id; 196 }; 197 198 static inline int smi_cmd(int cmd, int addr, int reg) 199 { 200 cmd = bitfield_replace(cmd, SMI_CMD_ADDR_SHIFT, SMI_CMD_ADDR_WIDTH, 201 addr); 202 cmd = bitfield_replace(cmd, SMI_CMD_REG_SHIFT, SMI_CMD_REG_WIDTH, reg); 203 return cmd; 204 } 205 206 static inline int smi_cmd_read(int addr, int reg) 207 { 208 return smi_cmd(SMI_CMD_READ, addr, reg); 209 } 210 211 static inline int smi_cmd_write(int addr, int reg) 212 { 213 return smi_cmd(SMI_CMD_WRITE, addr, reg); 214 } 215 216 __weak int mv88e61xx_hw_reset(struct phy_device *phydev) 217 { 218 return 0; 219 } 220 221 /* Wait for the current SMI indirect command to complete */ 222 static int mv88e61xx_smi_wait(struct mii_dev *bus, int smi_addr) 223 { 224 int val; 225 u32 timeout = 100; 226 227 do { 228 val = bus->read(bus, smi_addr, MDIO_DEVAD_NONE, SMI_CMD_REG); 229 if (val >= 0 && (val & SMI_BUSY) == 0) 230 return 0; 231 232 mdelay(1); 233 } while (--timeout); 234 235 puts("SMI busy timeout\n"); 236 return -ETIMEDOUT; 237 } 238 239 /* 240 * The mv88e61xx has three types of addresses: the smi bus address, the device 241 * address, and the register address. The smi bus address distinguishes it on 242 * the smi bus from other PHYs or switches. The device address determines 243 * which on-chip register set you are reading/writing (the various PHYs, their 244 * associated ports, or global configuration registers). The register address 245 * is the offset of the register you are reading/writing. 246 * 247 * When the mv88e61xx is hardware configured to have address zero, it behaves in 248 * single-chip addressing mode, where it responds to all SMI addresses, using 249 * the smi address as its device address. This obviously only works when this 250 * is the only chip on the SMI bus. This allows the driver to access device 251 * registers without using indirection. When the chip is configured to a 252 * non-zero address, it only responds to that SMI address and requires indirect 253 * writes to access the different device addresses. 254 */ 255 static int mv88e61xx_reg_read(struct phy_device *phydev, int dev, int reg) 256 { 257 struct mv88e61xx_phy_priv *priv = phydev->priv; 258 struct mii_dev *mdio_bus = priv->mdio_bus; 259 int smi_addr = priv->smi_addr; 260 int res; 261 262 /* In single-chip mode, the device can be addressed directly */ 263 if (smi_addr == 0) 264 return mdio_bus->read(mdio_bus, dev, MDIO_DEVAD_NONE, reg); 265 266 /* Wait for the bus to become free */ 267 res = mv88e61xx_smi_wait(mdio_bus, smi_addr); 268 if (res < 0) 269 return res; 270 271 /* Issue the read command */ 272 res = mdio_bus->write(mdio_bus, smi_addr, MDIO_DEVAD_NONE, SMI_CMD_REG, 273 smi_cmd_read(dev, reg)); 274 if (res < 0) 275 return res; 276 277 /* Wait for the read command to complete */ 278 res = mv88e61xx_smi_wait(mdio_bus, smi_addr); 279 if (res < 0) 280 return res; 281 282 /* Read the data */ 283 res = mdio_bus->read(mdio_bus, smi_addr, MDIO_DEVAD_NONE, SMI_DATA_REG); 284 if (res < 0) 285 return res; 286 287 return bitfield_extract(res, 0, 16); 288 } 289 290 /* See the comment above mv88e61xx_reg_read */ 291 static int mv88e61xx_reg_write(struct phy_device *phydev, int dev, int reg, 292 u16 val) 293 { 294 struct mv88e61xx_phy_priv *priv = phydev->priv; 295 struct mii_dev *mdio_bus = priv->mdio_bus; 296 int smi_addr = priv->smi_addr; 297 int res; 298 299 /* In single-chip mode, the device can be addressed directly */ 300 if (smi_addr == 0) { 301 return mdio_bus->write(mdio_bus, dev, MDIO_DEVAD_NONE, reg, 302 val); 303 } 304 305 /* Wait for the bus to become free */ 306 res = mv88e61xx_smi_wait(mdio_bus, smi_addr); 307 if (res < 0) 308 return res; 309 310 /* Set the data to write */ 311 res = mdio_bus->write(mdio_bus, smi_addr, MDIO_DEVAD_NONE, 312 SMI_DATA_REG, val); 313 if (res < 0) 314 return res; 315 316 /* Issue the write command */ 317 res = mdio_bus->write(mdio_bus, smi_addr, MDIO_DEVAD_NONE, SMI_CMD_REG, 318 smi_cmd_write(dev, reg)); 319 if (res < 0) 320 return res; 321 322 /* Wait for the write command to complete */ 323 res = mv88e61xx_smi_wait(mdio_bus, smi_addr); 324 if (res < 0) 325 return res; 326 327 return 0; 328 } 329 330 static int mv88e61xx_phy_wait(struct phy_device *phydev) 331 { 332 int val; 333 u32 timeout = 100; 334 335 do { 336 val = mv88e61xx_reg_read(phydev, DEVADDR_GLOBAL_2, 337 GLOBAL2_REG_PHY_CMD); 338 if (val >= 0 && (val & SMI_BUSY) == 0) 339 return 0; 340 341 mdelay(1); 342 } while (--timeout); 343 344 return -ETIMEDOUT; 345 } 346 347 static int mv88e61xx_phy_read_indirect(struct mii_dev *smi_wrapper, int dev, 348 int devad, int reg) 349 { 350 struct phy_device *phydev; 351 int res; 352 353 phydev = (struct phy_device *)smi_wrapper->priv; 354 355 /* Issue command to read */ 356 res = mv88e61xx_reg_write(phydev, DEVADDR_GLOBAL_2, 357 GLOBAL2_REG_PHY_CMD, 358 smi_cmd_read(dev, reg)); 359 360 /* Wait for data to be read */ 361 res = mv88e61xx_phy_wait(phydev); 362 if (res < 0) 363 return res; 364 365 /* Read retrieved data */ 366 return mv88e61xx_reg_read(phydev, DEVADDR_GLOBAL_2, 367 GLOBAL2_REG_PHY_DATA); 368 } 369 370 static int mv88e61xx_phy_write_indirect(struct mii_dev *smi_wrapper, int dev, 371 int devad, int reg, u16 data) 372 { 373 struct phy_device *phydev; 374 int res; 375 376 phydev = (struct phy_device *)smi_wrapper->priv; 377 378 /* Set the data to write */ 379 res = mv88e61xx_reg_write(phydev, DEVADDR_GLOBAL_2, 380 GLOBAL2_REG_PHY_DATA, data); 381 if (res < 0) 382 return res; 383 /* Issue the write command */ 384 res = mv88e61xx_reg_write(phydev, DEVADDR_GLOBAL_2, 385 GLOBAL2_REG_PHY_CMD, 386 smi_cmd_write(dev, reg)); 387 if (res < 0) 388 return res; 389 390 /* Wait for command to complete */ 391 return mv88e61xx_phy_wait(phydev); 392 } 393 394 /* Wrapper function to make calls to phy_read_indirect simpler */ 395 static int mv88e61xx_phy_read(struct phy_device *phydev, int phy, int reg) 396 { 397 return mv88e61xx_phy_read_indirect(phydev->bus, DEVADDR_PHY(phy), 398 MDIO_DEVAD_NONE, reg); 399 } 400 401 /* Wrapper function to make calls to phy_read_indirect simpler */ 402 static int mv88e61xx_phy_write(struct phy_device *phydev, int phy, 403 int reg, u16 val) 404 { 405 return mv88e61xx_phy_write_indirect(phydev->bus, DEVADDR_PHY(phy), 406 MDIO_DEVAD_NONE, reg, val); 407 } 408 409 static int mv88e61xx_port_read(struct phy_device *phydev, u8 port, u8 reg) 410 { 411 return mv88e61xx_reg_read(phydev, DEVADDR_PORT(port), reg); 412 } 413 414 static int mv88e61xx_port_write(struct phy_device *phydev, u8 port, u8 reg, 415 u16 val) 416 { 417 return mv88e61xx_reg_write(phydev, DEVADDR_PORT(port), reg, val); 418 } 419 420 static int mv88e61xx_set_page(struct phy_device *phydev, u8 phy, u8 page) 421 { 422 return mv88e61xx_phy_write(phydev, phy, PHY_REG_PAGE, page); 423 } 424 425 static int mv88e61xx_get_switch_id(struct phy_device *phydev) 426 { 427 int res; 428 429 res = mv88e61xx_port_read(phydev, 0, PORT_REG_SWITCH_ID); 430 if (res < 0) 431 return res; 432 return res & 0xfff0; 433 } 434 435 static bool mv88e61xx_6352_family(struct phy_device *phydev) 436 { 437 struct mv88e61xx_phy_priv *priv = phydev->priv; 438 439 switch (priv->id) { 440 case PORT_SWITCH_ID_6172: 441 case PORT_SWITCH_ID_6176: 442 case PORT_SWITCH_ID_6240: 443 case PORT_SWITCH_ID_6352: 444 return true; 445 } 446 return false; 447 } 448 449 static int mv88e61xx_get_cmode(struct phy_device *phydev, u8 port) 450 { 451 int res; 452 453 res = mv88e61xx_port_read(phydev, port, PORT_REG_STATUS); 454 if (res < 0) 455 return res; 456 return res & PORT_REG_STATUS_CMODE_MASK; 457 } 458 459 static int mv88e61xx_parse_status(struct phy_device *phydev) 460 { 461 unsigned int speed; 462 unsigned int mii_reg; 463 464 mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, PHY_REG_STATUS1); 465 466 if ((mii_reg & PHY_REG_STATUS1_LINK) && 467 !(mii_reg & PHY_REG_STATUS1_SPDDONE)) { 468 int i = 0; 469 470 puts("Waiting for PHY realtime link"); 471 while (!(mii_reg & PHY_REG_STATUS1_SPDDONE)) { 472 /* Timeout reached ? */ 473 if (i > PHY_AUTONEGOTIATE_TIMEOUT) { 474 puts(" TIMEOUT !\n"); 475 phydev->link = 0; 476 break; 477 } 478 479 if ((i++ % 1000) == 0) 480 putc('.'); 481 udelay(1000); 482 mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, 483 PHY_REG_STATUS1); 484 } 485 puts(" done\n"); 486 udelay(500000); /* another 500 ms (results in faster booting) */ 487 } else { 488 if (mii_reg & PHY_REG_STATUS1_LINK) 489 phydev->link = 1; 490 else 491 phydev->link = 0; 492 } 493 494 if (mii_reg & PHY_REG_STATUS1_DUPLEX) 495 phydev->duplex = DUPLEX_FULL; 496 else 497 phydev->duplex = DUPLEX_HALF; 498 499 speed = mii_reg & PHY_REG_STATUS1_SPEED; 500 501 switch (speed) { 502 case PHY_REG_STATUS1_GBIT: 503 phydev->speed = SPEED_1000; 504 break; 505 case PHY_REG_STATUS1_100: 506 phydev->speed = SPEED_100; 507 break; 508 default: 509 phydev->speed = SPEED_10; 510 break; 511 } 512 513 return 0; 514 } 515 516 static int mv88e61xx_switch_reset(struct phy_device *phydev) 517 { 518 int time; 519 int val; 520 u8 port; 521 522 /* Disable all ports */ 523 for (port = 0; port < PORT_COUNT; port++) { 524 val = mv88e61xx_port_read(phydev, port, PORT_REG_CTRL); 525 if (val < 0) 526 return val; 527 val = bitfield_replace(val, PORT_REG_CTRL_PSTATE_SHIFT, 528 PORT_REG_CTRL_PSTATE_WIDTH, 529 PORT_REG_CTRL_PSTATE_DISABLED); 530 val = mv88e61xx_port_write(phydev, port, PORT_REG_CTRL, val); 531 if (val < 0) 532 return val; 533 } 534 535 /* Wait 2 ms for queues to drain */ 536 udelay(2000); 537 538 /* Reset switch */ 539 val = mv88e61xx_reg_read(phydev, DEVADDR_GLOBAL_1, GLOBAL1_CTRL); 540 if (val < 0) 541 return val; 542 val |= GLOBAL1_CTRL_SWRESET; 543 val = mv88e61xx_reg_write(phydev, DEVADDR_GLOBAL_1, 544 GLOBAL1_CTRL, val); 545 if (val < 0) 546 return val; 547 548 /* Wait up to 1 second for switch reset complete */ 549 for (time = 1000; time; time--) { 550 val = mv88e61xx_reg_read(phydev, DEVADDR_GLOBAL_1, 551 GLOBAL1_CTRL); 552 if (val >= 0 && ((val & GLOBAL1_CTRL_SWRESET) == 0)) 553 break; 554 udelay(1000); 555 } 556 if (!time) 557 return -ETIMEDOUT; 558 559 return 0; 560 } 561 562 static int mv88e61xx_serdes_init(struct phy_device *phydev) 563 { 564 int val; 565 566 val = mv88e61xx_set_page(phydev, DEVADDR_SERDES, PHY_PAGE_SERDES); 567 if (val < 0) 568 return val; 569 570 /* Power up serdes module */ 571 val = mv88e61xx_phy_read(phydev, DEVADDR_SERDES, MII_BMCR); 572 if (val < 0) 573 return val; 574 val &= ~(BMCR_PDOWN); 575 val = mv88e61xx_phy_write(phydev, DEVADDR_SERDES, MII_BMCR, val); 576 if (val < 0) 577 return val; 578 579 return 0; 580 } 581 582 static int mv88e61xx_port_enable(struct phy_device *phydev, u8 port) 583 { 584 int val; 585 586 val = mv88e61xx_port_read(phydev, port, PORT_REG_CTRL); 587 if (val < 0) 588 return val; 589 val = bitfield_replace(val, PORT_REG_CTRL_PSTATE_SHIFT, 590 PORT_REG_CTRL_PSTATE_WIDTH, 591 PORT_REG_CTRL_PSTATE_FORWARD); 592 val = mv88e61xx_port_write(phydev, port, PORT_REG_CTRL, val); 593 if (val < 0) 594 return val; 595 596 return 0; 597 } 598 599 static int mv88e61xx_port_set_vlan(struct phy_device *phydev, u8 port, 600 u16 mask) 601 { 602 int val; 603 604 /* Set VID to port number plus one */ 605 val = mv88e61xx_port_read(phydev, port, PORT_REG_VLAN_ID); 606 if (val < 0) 607 return val; 608 val = bitfield_replace(val, PORT_REG_VLAN_ID_DEF_VID_SHIFT, 609 PORT_REG_VLAN_ID_DEF_VID_WIDTH, 610 port + 1); 611 val = mv88e61xx_port_write(phydev, port, PORT_REG_VLAN_ID, val); 612 if (val < 0) 613 return val; 614 615 /* Set VID mask */ 616 val = mv88e61xx_port_read(phydev, port, PORT_REG_VLAN_MAP); 617 if (val < 0) 618 return val; 619 val = bitfield_replace(val, PORT_REG_VLAN_MAP_TABLE_SHIFT, 620 PORT_REG_VLAN_MAP_TABLE_WIDTH, 621 mask); 622 val = mv88e61xx_port_write(phydev, port, PORT_REG_VLAN_MAP, val); 623 if (val < 0) 624 return val; 625 626 return 0; 627 } 628 629 static int mv88e61xx_read_port_config(struct phy_device *phydev, u8 port) 630 { 631 int res; 632 int val; 633 bool forced = false; 634 635 val = mv88e61xx_port_read(phydev, port, PORT_REG_STATUS); 636 if (val < 0) 637 return val; 638 if (!(val & PORT_REG_STATUS_LINK)) { 639 /* Temporarily force link to read port configuration */ 640 u32 timeout = 100; 641 forced = true; 642 643 val = mv88e61xx_port_read(phydev, port, PORT_REG_PHYS_CTRL); 644 if (val < 0) 645 return val; 646 val |= (PORT_REG_PHYS_CTRL_LINK_FORCE | 647 PORT_REG_PHYS_CTRL_LINK_VALUE); 648 val = mv88e61xx_port_write(phydev, port, PORT_REG_PHYS_CTRL, 649 val); 650 if (val < 0) 651 return val; 652 653 /* Wait for status register to reflect forced link */ 654 do { 655 val = mv88e61xx_port_read(phydev, port, 656 PORT_REG_STATUS); 657 if (val < 0) { 658 res = -EIO; 659 goto unforce; 660 } 661 if (val & PORT_REG_STATUS_LINK) 662 break; 663 } while (--timeout); 664 665 if (timeout == 0) { 666 res = -ETIMEDOUT; 667 goto unforce; 668 } 669 } 670 671 if (val & PORT_REG_STATUS_DUPLEX) 672 phydev->duplex = DUPLEX_FULL; 673 else 674 phydev->duplex = DUPLEX_HALF; 675 676 val = bitfield_extract(val, PORT_REG_STATUS_SPEED_SHIFT, 677 PORT_REG_STATUS_SPEED_WIDTH); 678 switch (val) { 679 case PORT_REG_STATUS_SPEED_1000: 680 phydev->speed = SPEED_1000; 681 break; 682 case PORT_REG_STATUS_SPEED_100: 683 phydev->speed = SPEED_100; 684 break; 685 default: 686 phydev->speed = SPEED_10; 687 break; 688 } 689 690 res = 0; 691 692 unforce: 693 if (forced) { 694 val = mv88e61xx_port_read(phydev, port, PORT_REG_PHYS_CTRL); 695 if (val < 0) 696 return val; 697 val &= ~(PORT_REG_PHYS_CTRL_LINK_FORCE | 698 PORT_REG_PHYS_CTRL_LINK_VALUE); 699 val = mv88e61xx_port_write(phydev, port, PORT_REG_PHYS_CTRL, 700 val); 701 if (val < 0) 702 return val; 703 } 704 705 return res; 706 } 707 708 static int mv88e61xx_fixed_port_setup(struct phy_device *phydev, u8 port) 709 { 710 int val; 711 712 val = mv88e61xx_port_read(phydev, port, PORT_REG_PHYS_CTRL); 713 if (val < 0) 714 return val; 715 716 val &= ~(PORT_REG_PHYS_CTRL_SPD_MASK | 717 PORT_REG_PHYS_CTRL_FC_VALUE); 718 val |= PORT_REG_PHYS_CTRL_PCS_AN_EN | 719 PORT_REG_PHYS_CTRL_PCS_AN_RST | 720 PORT_REG_PHYS_CTRL_FC_FORCE | 721 PORT_REG_PHYS_CTRL_DUPLEX_VALUE | 722 PORT_REG_PHYS_CTRL_DUPLEX_FORCE | 723 PORT_REG_PHYS_CTRL_SPD1000; 724 725 if (port == CONFIG_MV88E61XX_CPU_PORT) 726 val |= PORT_REG_PHYS_CTRL_LINK_VALUE | 727 PORT_REG_PHYS_CTRL_LINK_FORCE; 728 729 return mv88e61xx_port_write(phydev, port, PORT_REG_PHYS_CTRL, 730 val); 731 } 732 733 static int mv88e61xx_set_cpu_port(struct phy_device *phydev) 734 { 735 int val; 736 737 /* Set CPUDest */ 738 val = mv88e61xx_reg_read(phydev, DEVADDR_GLOBAL_1, GLOBAL1_MON_CTRL); 739 if (val < 0) 740 return val; 741 val = bitfield_replace(val, GLOBAL1_MON_CTRL_CPUDEST_SHIFT, 742 GLOBAL1_MON_CTRL_CPUDEST_WIDTH, 743 CONFIG_MV88E61XX_CPU_PORT); 744 val = mv88e61xx_reg_write(phydev, DEVADDR_GLOBAL_1, 745 GLOBAL1_MON_CTRL, val); 746 if (val < 0) 747 return val; 748 749 /* Allow CPU to route to any port */ 750 val = PORT_MASK & ~(1 << CONFIG_MV88E61XX_CPU_PORT); 751 val = mv88e61xx_port_set_vlan(phydev, CONFIG_MV88E61XX_CPU_PORT, val); 752 if (val < 0) 753 return val; 754 755 /* Enable CPU port */ 756 val = mv88e61xx_port_enable(phydev, CONFIG_MV88E61XX_CPU_PORT); 757 if (val < 0) 758 return val; 759 760 val = mv88e61xx_read_port_config(phydev, CONFIG_MV88E61XX_CPU_PORT); 761 if (val < 0) 762 return val; 763 764 /* If CPU is connected to serdes, initialize serdes */ 765 if (mv88e61xx_6352_family(phydev)) { 766 val = mv88e61xx_get_cmode(phydev, CONFIG_MV88E61XX_CPU_PORT); 767 if (val < 0) 768 return val; 769 if (val == PORT_REG_STATUS_CMODE_100BASE_X || 770 val == PORT_REG_STATUS_CMODE_1000BASE_X || 771 val == PORT_REG_STATUS_CMODE_SGMII) { 772 val = mv88e61xx_serdes_init(phydev); 773 if (val < 0) 774 return val; 775 } 776 } else { 777 val = mv88e61xx_fixed_port_setup(phydev, 778 CONFIG_MV88E61XX_CPU_PORT); 779 if (val < 0) 780 return val; 781 } 782 783 return 0; 784 } 785 786 static int mv88e61xx_switch_init(struct phy_device *phydev) 787 { 788 static int init; 789 int res; 790 791 if (init) 792 return 0; 793 794 res = mv88e61xx_switch_reset(phydev); 795 if (res < 0) 796 return res; 797 798 res = mv88e61xx_set_cpu_port(phydev); 799 if (res < 0) 800 return res; 801 802 init = 1; 803 804 return 0; 805 } 806 807 static int mv88e61xx_phy_enable(struct phy_device *phydev, u8 phy) 808 { 809 int val; 810 811 val = mv88e61xx_phy_read(phydev, phy, MII_BMCR); 812 if (val < 0) 813 return val; 814 val &= ~(BMCR_PDOWN); 815 val = mv88e61xx_phy_write(phydev, phy, MII_BMCR, val); 816 if (val < 0) 817 return val; 818 819 return 0; 820 } 821 822 static int mv88e61xx_phy_setup(struct phy_device *phydev, u8 phy) 823 { 824 int val; 825 826 /* 827 * Enable energy-detect sensing on PHY, used to determine when a PHY 828 * port is physically connected 829 */ 830 val = mv88e61xx_phy_read(phydev, phy, PHY_REG_CTRL1); 831 if (val < 0) 832 return val; 833 val = bitfield_replace(val, PHY_REG_CTRL1_ENERGY_DET_SHIFT, 834 PHY_REG_CTRL1_ENERGY_DET_WIDTH, 835 PHY_REG_CTRL1_ENERGY_DET_SENSE_XMIT); 836 val = mv88e61xx_phy_write(phydev, phy, PHY_REG_CTRL1, val); 837 if (val < 0) 838 return val; 839 840 return 0; 841 } 842 843 static int mv88e61xx_phy_config_port(struct phy_device *phydev, u8 phy) 844 { 845 int val; 846 847 val = mv88e61xx_port_enable(phydev, phy); 848 if (val < 0) 849 return val; 850 851 val = mv88e61xx_port_set_vlan(phydev, phy, 852 1 << CONFIG_MV88E61XX_CPU_PORT); 853 if (val < 0) 854 return val; 855 856 return 0; 857 } 858 859 static int mv88e61xx_probe(struct phy_device *phydev) 860 { 861 struct mii_dev *smi_wrapper; 862 struct mv88e61xx_phy_priv *priv; 863 int res; 864 865 res = mv88e61xx_hw_reset(phydev); 866 if (res < 0) 867 return res; 868 869 priv = malloc(sizeof(*priv)); 870 if (!priv) 871 return -ENOMEM; 872 873 memset(priv, 0, sizeof(*priv)); 874 875 /* 876 * This device requires indirect reads/writes to the PHY registers 877 * which the generic PHY code can't handle. Make a wrapper MII device 878 * to handle reads/writes 879 */ 880 smi_wrapper = mdio_alloc(); 881 if (!smi_wrapper) { 882 free(priv); 883 return -ENOMEM; 884 } 885 886 /* 887 * Store the mdio bus in the private data, as we are going to replace 888 * the bus with the wrapper bus 889 */ 890 priv->mdio_bus = phydev->bus; 891 892 /* 893 * Store the smi bus address in private data. This lets us use the 894 * phydev addr field for device address instead, as the genphy code 895 * expects. 896 */ 897 priv->smi_addr = phydev->addr; 898 899 /* 900 * Store the phy_device in the wrapper mii device. This lets us get it 901 * back when genphy functions call phy_read/phy_write. 902 */ 903 smi_wrapper->priv = phydev; 904 strncpy(smi_wrapper->name, "indirect mii", sizeof(smi_wrapper->name)); 905 smi_wrapper->read = mv88e61xx_phy_read_indirect; 906 smi_wrapper->write = mv88e61xx_phy_write_indirect; 907 908 /* Replace the bus with the wrapper device */ 909 phydev->bus = smi_wrapper; 910 911 phydev->priv = priv; 912 913 priv->id = mv88e61xx_get_switch_id(phydev); 914 915 return 0; 916 } 917 918 static int mv88e61xx_phy_config(struct phy_device *phydev) 919 { 920 int res; 921 int i; 922 int ret = -1; 923 924 res = mv88e61xx_switch_init(phydev); 925 if (res < 0) 926 return res; 927 928 for (i = 0; i < PORT_COUNT; i++) { 929 if ((1 << i) & CONFIG_MV88E61XX_PHY_PORTS) { 930 phydev->addr = i; 931 932 res = mv88e61xx_phy_enable(phydev, i); 933 if (res < 0) { 934 printf("Error enabling PHY %i\n", i); 935 continue; 936 } 937 res = mv88e61xx_phy_setup(phydev, i); 938 if (res < 0) { 939 printf("Error setting up PHY %i\n", i); 940 continue; 941 } 942 res = mv88e61xx_phy_config_port(phydev, i); 943 if (res < 0) { 944 printf("Error configuring PHY %i\n", i); 945 continue; 946 } 947 948 res = phy_reset(phydev); 949 if (res < 0) { 950 printf("Error resetting PHY %i\n", i); 951 continue; 952 } 953 res = genphy_config_aneg(phydev); 954 if (res < 0) { 955 printf("Error setting PHY %i autoneg\n", i); 956 continue; 957 } 958 959 /* Return success if any PHY succeeds */ 960 ret = 0; 961 } else if ((1 << i) & CONFIG_MV88E61XX_FIXED_PORTS) { 962 res = mv88e61xx_fixed_port_setup(phydev, i); 963 if (res < 0) { 964 printf("Error configuring port %i\n", i); 965 continue; 966 } 967 } 968 } 969 970 return ret; 971 } 972 973 static int mv88e61xx_phy_is_connected(struct phy_device *phydev) 974 { 975 int val; 976 977 val = mv88e61xx_phy_read(phydev, phydev->addr, PHY_REG_STATUS1); 978 if (val < 0) 979 return 0; 980 981 /* 982 * After reset, the energy detect signal remains high for a few seconds 983 * regardless of whether a cable is connected. This function will 984 * return false positives during this time. 985 */ 986 return (val & PHY_REG_STATUS1_ENERGY) == 0; 987 } 988 989 static int mv88e61xx_phy_startup(struct phy_device *phydev) 990 { 991 int i; 992 int link = 0; 993 int res; 994 int speed = phydev->speed; 995 int duplex = phydev->duplex; 996 997 for (i = 0; i < PORT_COUNT; i++) { 998 if ((1 << i) & CONFIG_MV88E61XX_PHY_PORTS) { 999 phydev->addr = i; 1000 if (!mv88e61xx_phy_is_connected(phydev)) 1001 continue; 1002 res = genphy_update_link(phydev); 1003 if (res < 0) 1004 continue; 1005 res = mv88e61xx_parse_status(phydev); 1006 if (res < 0) 1007 continue; 1008 link = (link || phydev->link); 1009 } 1010 } 1011 phydev->link = link; 1012 1013 /* Restore CPU interface speed and duplex after it was changed for 1014 * other ports */ 1015 phydev->speed = speed; 1016 phydev->duplex = duplex; 1017 1018 return 0; 1019 } 1020 1021 static struct phy_driver mv88e61xx_driver = { 1022 .name = "Marvell MV88E61xx", 1023 .uid = 0x01410eb1, 1024 .mask = 0xfffffff0, 1025 .features = PHY_GBIT_FEATURES, 1026 .probe = mv88e61xx_probe, 1027 .config = mv88e61xx_phy_config, 1028 .startup = mv88e61xx_phy_startup, 1029 .shutdown = &genphy_shutdown, 1030 }; 1031 1032 static struct phy_driver mv88e609x_driver = { 1033 .name = "Marvell MV88E609x", 1034 .uid = 0x1410c89, 1035 .mask = 0xfffffff0, 1036 .features = PHY_GBIT_FEATURES, 1037 .probe = mv88e61xx_probe, 1038 .config = mv88e61xx_phy_config, 1039 .startup = mv88e61xx_phy_startup, 1040 .shutdown = &genphy_shutdown, 1041 }; 1042 1043 int phy_mv88e61xx_init(void) 1044 { 1045 phy_register(&mv88e61xx_driver); 1046 phy_register(&mv88e609x_driver); 1047 1048 return 0; 1049 } 1050 1051 /* 1052 * Overload weak get_phy_id definition since we need non-standard functions 1053 * to read PHY registers 1054 */ 1055 int get_phy_id(struct mii_dev *bus, int smi_addr, int devad, u32 *phy_id) 1056 { 1057 struct phy_device temp_phy; 1058 struct mv88e61xx_phy_priv temp_priv; 1059 struct mii_dev temp_mii; 1060 int val; 1061 1062 /* 1063 * Buid temporary data structures that the chip reading code needs to 1064 * read the ID 1065 */ 1066 temp_priv.mdio_bus = bus; 1067 temp_priv.smi_addr = smi_addr; 1068 temp_phy.priv = &temp_priv; 1069 temp_mii.priv = &temp_phy; 1070 1071 val = mv88e61xx_phy_read_indirect(&temp_mii, 0, devad, MII_PHYSID1); 1072 if (val < 0) 1073 return -EIO; 1074 1075 *phy_id = val << 16; 1076 1077 val = mv88e61xx_phy_read_indirect(&temp_mii, 0, devad, MII_PHYSID2); 1078 if (val < 0) 1079 return -EIO; 1080 1081 *phy_id |= (val & 0xffff); 1082 1083 return 0; 1084 } 1085