drivers/net/phy/mv88e61xx.c

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