drivers/net/phy/aquantia.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Aquantia PHY drivers
   4  *
   5  * Copyright 2014 Freescale Semiconductor, Inc.
   6  * Copyright 2018 NXP
   7  */
   8 #include <config.h>
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <log.h>
  12 #include <net.h>
  13 #include <phy.h>
  14 #include <linux/delay.h>
  15 #include <u-boot/crc.h>
  16 #include <malloc.h>
  17 #include <asm/byteorder.h>
  18 #include <fs.h>
  19
  20 #define AQUNTIA_10G_CTL         0x20
  21 #define AQUNTIA_VENDOR_P1       0xc400
  22
  23 #define AQUNTIA_SPEED_LSB_MASK  0x2000
  24 #define AQUNTIA_SPEED_MSB_MASK  0x40
  25
  26 #define AQUANTIA_SYSTEM_INTERFACE_SR     0xe812
  27 #define  AQUANTIA_SYSTEM_INTERFACE_SR_READY     BIT(0)
  28 #define AQUANTIA_VENDOR_PROVISIONING_REG 0xC441
  29 #define AQUANTIA_FIRMWARE_ID             0x20
  30 #define AQUANTIA_RESERVED_STATUS         0xc885
  31 #define AQUANTIA_FIRMWARE_MAJOR_MASK     0xff00
  32 #define AQUANTIA_FIRMWARE_MINOR_MASK     0xff
  33 #define AQUANTIA_FIRMWARE_BUILD_MASK     0xf0
  34
  35 #define AQUANTIA_USX_AUTONEG_CONTROL_ENA 0x0008
  36 #define AQUANTIA_SI_IN_USE_MASK          0x0078
  37 #define AQUANTIA_SI_USXGMII              0x0018
  38
  39 /* registers in MDIO_MMD_VEND1 region */
  40 #define AQUANTIA_VND1_GLOBAL_SC                 0x000
  41 #define  AQUANTIA_VND1_GLOBAL_SC_LP             BIT(0xb)
  42
  43 #define GLOBAL_FIRMWARE_ID 0x20
  44 #define GLOBAL_FAULT 0xc850
  45 #define GLOBAL_RSTATUS_1 0xc885
  46
  47 #define GLOBAL_ALARM_1 0xcc00
  48 #define SYSTEM_READY_BIT 0x40
  49
  50 #define GLOBAL_STANDARD_CONTROL 0x0
  51 #define SOFT_RESET BIT(15)
  52 #define LOW_POWER BIT(11)
  53
  54 #define MAILBOX_CONTROL 0x0200
  55 #define MAILBOX_EXECUTE BIT(15)
  56 #define MAILBOX_WRITE BIT(14)
  57 #define MAILBOX_RESET_CRC BIT(12)
  58 #define MAILBOX_BUSY BIT(8)
  59
  60 #define MAILBOX_CRC 0x0201
  61
  62 #define MAILBOX_ADDR_MSW 0x0202
  63 #define MAILBOX_ADDR_LSW 0x0203
  64
  65 #define MAILBOX_DATA_MSW 0x0204
  66 #define MAILBOX_DATA_LSW 0x0205
  67
  68 #define UP_CONTROL 0xc001
  69 #define UP_RESET BIT(15)
  70 #define UP_RUN_STALL_OVERRIDE BIT(6)
  71 #define UP_RUN_STALL BIT(0)
  72
  73 #define AQUANTIA_PMA_RX_VENDOR_P1               0xe400
  74 #define  AQUANTIA_PMA_RX_VENDOR_P1_MDI_MSK      GENMASK(1, 0)
  75 /* MDI reversal configured through registers */
  76 #define  AQUANTIA_PMA_RX_VENDOR_P1_MDI_CFG      BIT(1)
  77 /* MDI reversal enabled */
  78 #define  AQUANTIA_PMA_RX_VENDOR_P1_MDI_REV      BIT(0)
  79
  80 /*
  81  * global start rate, the protocol associated with this speed is used by default
  82  * on SI.
  83  */
  84 #define AQUANTIA_VND1_GSTART_RATE               0x31a
  85 #define  AQUANTIA_VND1_GSTART_RATE_OFF          0
  86 #define  AQUANTIA_VND1_GSTART_RATE_100M         1
  87 #define  AQUANTIA_VND1_GSTART_RATE_1G           2
  88 #define  AQUANTIA_VND1_GSTART_RATE_10G          3
  89 #define  AQUANTIA_VND1_GSTART_RATE_2_5G         4
  90 #define  AQUANTIA_VND1_GSTART_RATE_5G           5
  91
  92 /* SYSCFG registers for 100M, 1G, 2.5G, 5G, 10G */
  93 #define AQUANTIA_VND1_GSYSCFG_BASE              0x31b
  94 #define AQUANTIA_VND1_GSYSCFG_100M              0
  95 #define AQUANTIA_VND1_GSYSCFG_1G                1
  96 #define AQUANTIA_VND1_GSYSCFG_2_5G              2
  97 #define AQUANTIA_VND1_GSYSCFG_5G                3
  98 #define AQUANTIA_VND1_GSYSCFG_10G               4
  99
 100 #define AQUANTIA_VND1_SMBUS0                    0xc485
 101 #define AQUANTIA_VND1_SMBUS1                    0xc495
 102
 103 /* addresses of memory segments in the phy */
 104 #define DRAM_BASE_ADDR 0x3FFE0000
 105 #define IRAM_BASE_ADDR 0x40000000
 106
 107 /* firmware image format constants */
 108 #define VERSION_STRING_SIZE 0x40
 109 #define VERSION_STRING_OFFSET 0x0200
 110 #define HEADER_OFFSET 0x300
 111
 112 /* driver private data */
 113 #define AQUANTIA_NA             0
 114 #define AQUANTIA_GEN1           1
 115 #define AQUANTIA_GEN2           2
 116 #define AQUANTIA_GEN3           3
 117
 118 #pragma pack(1)
 119 struct fw_header {
 120         u8 padding[4];
 121         u8 iram_offset[3];
 122         u8 iram_size[3];
 123         u8 dram_offset[3];
 124         u8 dram_size[3];
 125 };
 126
 127 #pragma pack()
 128
 129 #if defined(CONFIG_PHY_AQUANTIA_UPLOAD_FW)
 130 static int aquantia_read_fw(u8 **fw_addr, size_t *fw_length)
 131 {
 132         loff_t length, read;
 133         int ret;
 134         void *addr = NULL;
 135
 136         *fw_addr = NULL;
 137         *fw_length = 0;
 138         debug("Loading Acquantia microcode from %s %s\n",
 139               CONFIG_PHY_AQUANTIA_FW_PART, CONFIG_PHY_AQUANTIA_FW_NAME);
 140         ret = fs_set_blk_dev("mmc", CONFIG_PHY_AQUANTIA_FW_PART, FS_TYPE_ANY);
 141         if (ret < 0)
 142                 goto cleanup;
 143
 144         ret = fs_size(CONFIG_PHY_AQUANTIA_FW_NAME, &length);
 145         if (ret < 0)
 146                 goto cleanup;
 147
 148         addr = malloc(length);
 149         if (!addr) {
 150                 ret = -ENOMEM;
 151                 goto cleanup;
 152         }
 153
 154         ret = fs_set_blk_dev("mmc", CONFIG_PHY_AQUANTIA_FW_PART, FS_TYPE_ANY);
 155         if (ret < 0)
 156                 goto cleanup;
 157
 158         ret = fs_read(CONFIG_PHY_AQUANTIA_FW_NAME, (ulong)addr, 0, length,
 159                       &read);
 160         if (ret < 0)
 161                 goto cleanup;
 162
 163         *fw_addr = addr;
 164         *fw_length = length;
 165         debug("Found Acquantia microcode.\n");
 166
 167 cleanup:
 168         if (ret < 0) {
 169                 printf("loading firmware file %s %s failed with error %d\n",
 170                        CONFIG_PHY_AQUANTIA_FW_PART,
 171                        CONFIG_PHY_AQUANTIA_FW_NAME, ret);
 172                 free(addr);
 173         }
 174         return ret;
 175 }
 176
 177 /* load data into the phy's memory */
 178 static int aquantia_load_memory(struct phy_device *phydev, u32 addr,
 179                                 const u8 *data, size_t len)
 180 {
 181         size_t pos;
 182         u16 crc = 0, up_crc;
 183
 184         phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_CONTROL, MAILBOX_RESET_CRC);
 185         phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_ADDR_MSW, addr >> 16);
 186         phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_ADDR_LSW, addr & 0xfffc);
 187
 188         for (pos = 0; pos < len; pos += min(sizeof(u32), len - pos)) {
 189                 u32 word = 0;
 190
 191                 memcpy(&word, &data[pos], min(sizeof(u32), len - pos));
 192
 193                 phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_DATA_MSW,
 194                           (word >> 16));
 195                 phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_DATA_LSW,
 196                           word & 0xffff);
 197
 198                 phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_CONTROL,
 199                           MAILBOX_EXECUTE | MAILBOX_WRITE);
 200
 201                 /* keep a big endian CRC to match the phy processor */
 202                 word = cpu_to_be32(word);
 203                 crc = crc16_ccitt(crc, (u8 *)&word, sizeof(word));
 204         }
 205
 206         up_crc = phy_read(phydev, MDIO_MMD_VEND1, MAILBOX_CRC);
 207         if (crc != up_crc) {
 208                 printf("%s crc mismatch: calculated 0x%04hx phy 0x%04hx\n",
 209                        phydev->dev->name, crc, up_crc);
 210                 return -EINVAL;
 211         }
 212         return 0;
 213 }
 214
 215 static u32 unpack_u24(const u8 *data)
 216 {
 217         return (data[2] << 16) + (data[1] << 8) + data[0];
 218 }
 219
 220 static int aquantia_upload_firmware(struct phy_device *phydev)
 221 {
 222         int ret;
 223         u8 *addr = NULL;
 224         size_t fw_length = 0;
 225         u16 calculated_crc, read_crc;
 226         char version[VERSION_STRING_SIZE];
 227         u32 primary_offset, iram_offset, iram_size, dram_offset, dram_size;
 228         const struct fw_header *header;
 229
 230         ret = aquantia_read_fw(&addr, &fw_length);
 231         if (ret != 0)
 232                 return ret;
 233
 234         read_crc = (addr[fw_length - 2] << 8)  | addr[fw_length - 1];
 235         calculated_crc = crc16_ccitt(0, addr, fw_length - 2);
 236         if (read_crc != calculated_crc) {
 237                 printf("%s bad firmware crc: file 0x%04x calculated 0x%04x\n",
 238                        phydev->dev->name, read_crc, calculated_crc);
 239                 ret = -EINVAL;
 240                 goto done;
 241         }
 242
 243         /* Find the DRAM and IRAM sections within the firmware file. */
 244         primary_offset = ((addr[9] & 0xf) << 8 | addr[8]) << 12;
 245
 246         header = (struct fw_header *)&addr[primary_offset + HEADER_OFFSET];
 247
 248         iram_offset = primary_offset + unpack_u24(header->iram_offset);
 249         iram_size = unpack_u24(header->iram_size);
 250
 251         dram_offset = primary_offset + unpack_u24(header->dram_offset);
 252         dram_size = unpack_u24(header->dram_size);
 253
 254         debug("primary %d iram offset=%d size=%d dram offset=%d size=%d\n",
 255               primary_offset, iram_offset, iram_size, dram_offset, dram_size);
 256
 257         strlcpy(version, (char *)&addr[dram_offset + VERSION_STRING_OFFSET],
 258                 VERSION_STRING_SIZE);
 259         printf("%s loading firmare version '%s'\n", phydev->dev->name, version);
 260
 261         /* stall the microcprocessor */
 262         phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL,
 263                   UP_RUN_STALL | UP_RUN_STALL_OVERRIDE);
 264
 265         debug("loading dram 0x%08x from offset=%d size=%d\n",
 266               DRAM_BASE_ADDR, dram_offset, dram_size);
 267         ret = aquantia_load_memory(phydev, DRAM_BASE_ADDR, &addr[dram_offset],
 268                                    dram_size);
 269         if (ret != 0)
 270                 goto done;
 271
 272         debug("loading iram 0x%08x from offset=%d size=%d\n",
 273               IRAM_BASE_ADDR, iram_offset, iram_size);
 274         ret = aquantia_load_memory(phydev, IRAM_BASE_ADDR, &addr[iram_offset],
 275                                    iram_size);
 276         if (ret != 0)
 277                 goto done;
 278
 279         /* make sure soft reset and low power mode are clear */
 280         phy_write(phydev, MDIO_MMD_VEND1, GLOBAL_STANDARD_CONTROL, 0);
 281
 282         /* Release the microprocessor. UP_RESET must be held for 100 usec. */
 283         phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL,
 284                   UP_RUN_STALL | UP_RUN_STALL_OVERRIDE | UP_RESET);
 285
 286         udelay(100);
 287
 288         phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL, UP_RUN_STALL_OVERRIDE);
 289
 290         printf("%s firmare loading done.\n", phydev->dev->name);
 291 done:
 292         free(addr);
 293         return ret;
 294 }
 295 #else
 296 static int aquantia_upload_firmware(struct phy_device *phydev)
 297 {
 298         printf("ERROR %s firmware loading disabled.\n", phydev->dev->name);
 299         return -1;
 300 }
 301 #endif
 302
 303 struct {
 304         u16 syscfg;
 305         int cnt;
 306         u16 start_rate;
 307 } aquantia_syscfg[PHY_INTERFACE_MODE_COUNT] = {
 308         [PHY_INTERFACE_MODE_SGMII] =      {0x04b, AQUANTIA_VND1_GSYSCFG_1G,
 309                                            AQUANTIA_VND1_GSTART_RATE_1G},
 310         [PHY_INTERFACE_MODE_SGMII_2500] = {0x144, AQUANTIA_VND1_GSYSCFG_2_5G,
 311                                            AQUANTIA_VND1_GSTART_RATE_2_5G},
 312         [PHY_INTERFACE_MODE_XFI] =        {0x100, AQUANTIA_VND1_GSYSCFG_10G,
 313                                            AQUANTIA_VND1_GSTART_RATE_10G},
 314         [PHY_INTERFACE_MODE_USXGMII] =    {0x080, AQUANTIA_VND1_GSYSCFG_10G,
 315                                            AQUANTIA_VND1_GSTART_RATE_10G},
 316 };
 317
 318 static int aquantia_set_proto(struct phy_device *phydev,
 319                               phy_interface_t interface)
 320 {
 321         int i;
 322
 323         if (!aquantia_syscfg[interface].cnt)
 324                 return 0;
 325
 326         /* set the default rate to enable the SI link */
 327         phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GSTART_RATE,
 328                   aquantia_syscfg[interface].start_rate);
 329
 330         /* set selected protocol for all relevant line side link speeds */
 331         for (i = 0; i <= aquantia_syscfg[interface].cnt; i++)
 332                 phy_write(phydev, MDIO_MMD_VEND1,
 333                           AQUANTIA_VND1_GSYSCFG_BASE + i,
 334                           aquantia_syscfg[interface].syscfg);
 335         return 0;
 336 }
 337
 338 static int aquantia_dts_config(struct phy_device *phydev)
 339 {
 340 #ifdef CONFIG_DM_ETH
 341         ofnode node = phydev->node;
 342         u32 prop;
 343         u16 reg;
 344
 345         /* this code only works on gen2 and gen3 PHYs */
 346         if (phydev->drv->data != AQUANTIA_GEN2 &&
 347             phydev->drv->data != AQUANTIA_GEN3)
 348                 return -ENOTSUPP;
 349
 350         if (!ofnode_valid(node))
 351                 return 0;
 352
 353         if (!ofnode_read_u32(node, "mdi-reversal", &prop)) {
 354                 debug("mdi-reversal = %d\n", (int)prop);
 355                 reg =  phy_read(phydev, MDIO_MMD_PMAPMD,
 356                                 AQUANTIA_PMA_RX_VENDOR_P1);
 357                 reg &= ~AQUANTIA_PMA_RX_VENDOR_P1_MDI_MSK;
 358                 reg |= AQUANTIA_PMA_RX_VENDOR_P1_MDI_CFG;
 359                 reg |= prop ? AQUANTIA_PMA_RX_VENDOR_P1_MDI_REV : 0;
 360                 phy_write(phydev, MDIO_MMD_PMAPMD, AQUANTIA_PMA_RX_VENDOR_P1,
 361                           reg);
 362         }
 363         if (!ofnode_read_u32(node, "smb-addr", &prop)) {
 364                 debug("smb-addr = %x\n", (int)prop);
 365                 /*
 366                  * there are two addresses here, normally just one bus would
 367                  * be in use so we're setting both regs using the same DT
 368                  * property.
 369                  */
 370                 phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_SMBUS0,
 371                           (u16)(prop << 1));
 372                 phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_SMBUS1,
 373                           (u16)(prop << 1));
 374         }
 375
 376 #endif
 377         return 0;
 378 }
 379
 380 static bool aquantia_link_is_up(struct phy_device *phydev)
 381 {
 382         u16 reg, regmask;
 383         int devad, regnum;
 384
 385         /*
 386          * On Gen 2 and 3 we have a bit that indicates that both system and
 387          * line side are ready for data, use that if possible.
 388          */
 389         if (phydev->drv->data == AQUANTIA_GEN2 ||
 390             phydev->drv->data == AQUANTIA_GEN3) {
 391                 devad = MDIO_MMD_PHYXS;
 392                 regnum = AQUANTIA_SYSTEM_INTERFACE_SR;
 393                 regmask = AQUANTIA_SYSTEM_INTERFACE_SR_READY;
 394         } else {
 395                 devad = MDIO_MMD_AN;
 396                 regnum = MDIO_STAT1;
 397                 regmask = MDIO_AN_STAT1_COMPLETE;
 398         }
 399         /* the register should be latched, do a double read */
 400         phy_read(phydev, devad, regnum);
 401         reg = phy_read(phydev, devad, regnum);
 402
 403         return !!(reg & regmask);
 404 }
 405
 406 int aquantia_config(struct phy_device *phydev)
 407 {
 408         int interface = phydev->interface;
 409         u32 val, id, rstatus, fault;
 410         u32 reg_val1 = 0;
 411         int num_retries = 5;
 412         int usx_an = 0;
 413
 414         /*
 415          * check if the system is out of reset and init sequence completed.
 416          * chip-wide reset for gen1 quad phys takes longer
 417          */
 418         while (--num_retries) {
 419                 rstatus = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_ALARM_1);
 420                 if (rstatus & SYSTEM_READY_BIT)
 421                         break;
 422                 mdelay(10);
 423         }
 424
 425         id = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_FIRMWARE_ID);
 426         rstatus = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_RSTATUS_1);
 427         fault = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_FAULT);
 428
 429         if (id != 0)
 430                 debug("%s running firmware version %X.%X.%X\n",
 431                       phydev->dev->name, (id >> 8), id & 0xff,
 432                       (rstatus >> 4) & 0xf);
 433
 434         if (fault != 0)
 435                 printf("%s fault 0x%04x detected\n", phydev->dev->name, fault);
 436
 437         if (id == 0 || fault != 0) {
 438                 int ret;
 439
 440                 ret = aquantia_upload_firmware(phydev);
 441                 if (ret != 0)
 442                         return ret;
 443         }
 444         /*
 445          * for backward compatibility convert XGMII into either XFI or USX based
 446          * on FW config
 447          */
 448         if (interface == PHY_INTERFACE_MODE_XGMII) {
 449                 debug("use XFI or USXGMII SI protos, XGMII is not valid\n");
 450
 451                 reg_val1 = phy_read(phydev, MDIO_MMD_PHYXS,
 452                                     AQUANTIA_SYSTEM_INTERFACE_SR);
 453                 if ((reg_val1 & AQUANTIA_SI_IN_USE_MASK) == AQUANTIA_SI_USXGMII)
 454                         interface = PHY_INTERFACE_MODE_USXGMII;
 455                 else
 456                         interface = PHY_INTERFACE_MODE_XFI;
 457         }
 458
 459         /*
 460          * if link is up already we can just use it, otherwise configure
 461          * the protocols in the PHY.  If link is down set the system
 462          * interface protocol to use based on phydev->interface
 463          */
 464         if (!aquantia_link_is_up(phydev) &&
 465             (phydev->drv->data == AQUANTIA_GEN2 ||
 466              phydev->drv->data == AQUANTIA_GEN3)) {
 467                 /* set PHY in low power mode so we can configure protocols */
 468                 phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GLOBAL_SC,
 469                           AQUANTIA_VND1_GLOBAL_SC_LP);
 470                 mdelay(10);
 471
 472                 /* configure protocol based on phydev->interface */
 473                 aquantia_set_proto(phydev, interface);
 474                 /* apply custom configuration based on DT */
 475                 aquantia_dts_config(phydev);
 476
 477                 /* wake PHY back up */
 478                 phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GLOBAL_SC, 0);
 479                 mdelay(10);
 480         }
 481
 482         val = phy_read(phydev, MDIO_MMD_PMAPMD, MII_BMCR);
 483
 484         switch (interface) {
 485         case PHY_INTERFACE_MODE_SGMII:
 486                 /* 1000BASE-T mode */
 487                 phydev->advertising = SUPPORTED_1000baseT_Full;
 488                 phydev->supported = phydev->advertising;
 489
 490                 val = (val & ~AQUNTIA_SPEED_LSB_MASK) | AQUNTIA_SPEED_MSB_MASK;
 491                 phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR, val);
 492                 break;
 493         case PHY_INTERFACE_MODE_USXGMII:
 494                 usx_an = 1;
 495                 /* FALLTHROUGH */
 496         case PHY_INTERFACE_MODE_XFI:
 497                 /* 10GBASE-T mode */
 498                 phydev->advertising = SUPPORTED_10000baseT_Full;
 499                 phydev->supported = phydev->advertising;
 500
 501                 if (!(val & AQUNTIA_SPEED_LSB_MASK) ||
 502                     !(val & AQUNTIA_SPEED_MSB_MASK))
 503                         phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR,
 504                                   AQUNTIA_SPEED_LSB_MASK |
 505                                   AQUNTIA_SPEED_MSB_MASK);
 506
 507                 /* If SI is USXGMII then start USXGMII autoneg */
 508                 reg_val1 =  phy_read(phydev, MDIO_MMD_PHYXS,
 509                                      AQUANTIA_VENDOR_PROVISIONING_REG);
 510
 511                 if (usx_an) {
 512                         reg_val1 |= AQUANTIA_USX_AUTONEG_CONTROL_ENA;
 513                         debug("%s: system interface USXGMII\n",
 514                               phydev->dev->name);
 515                 } else {
 516                         reg_val1 &= ~AQUANTIA_USX_AUTONEG_CONTROL_ENA;
 517                         debug("%s: system interface XFI\n",
 518                               phydev->dev->name);
 519                 }
 520
 521                 phy_write(phydev, MDIO_MMD_PHYXS,
 522                           AQUANTIA_VENDOR_PROVISIONING_REG, reg_val1);
 523                 break;
 524         case PHY_INTERFACE_MODE_SGMII_2500:
 525                 /* 2.5GBASE-T mode */
 526                 phydev->advertising = SUPPORTED_1000baseT_Full;
 527                 phydev->supported = phydev->advertising;
 528
 529                 phy_write(phydev, MDIO_MMD_AN, AQUNTIA_10G_CTL, 1);
 530                 phy_write(phydev, MDIO_MMD_AN, AQUNTIA_VENDOR_P1, 0x9440);
 531                 break;
 532         case PHY_INTERFACE_MODE_MII:
 533                 /* 100BASE-TX mode */
 534                 phydev->advertising = SUPPORTED_100baseT_Full;
 535                 phydev->supported = phydev->advertising;
 536
 537                 val = (val & ~AQUNTIA_SPEED_MSB_MASK) | AQUNTIA_SPEED_LSB_MASK;
 538                 phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR, val);
 539                 break;
 540         };
 541
 542         val = phy_read(phydev, MDIO_MMD_VEND1, AQUANTIA_RESERVED_STATUS);
 543         reg_val1 = phy_read(phydev, MDIO_MMD_VEND1, AQUANTIA_FIRMWARE_ID);
 544
 545         debug("%s: %s Firmware Version %x.%x.%x\n", phydev->dev->name,
 546               phydev->drv->name,
 547               (reg_val1 & AQUANTIA_FIRMWARE_MAJOR_MASK) >> 8,
 548               reg_val1 & AQUANTIA_FIRMWARE_MINOR_MASK,
 549               (val & AQUANTIA_FIRMWARE_BUILD_MASK) >> 4);
 550
 551         return 0;
 552 }
 553
 554 int aquantia_startup(struct phy_device *phydev)
 555 {
 556         u32 reg, speed;
 557         int i = 0;
 558
 559         phydev->duplex = DUPLEX_FULL;
 560
 561         /* if the AN is still in progress, wait till timeout. */
 562         if (!aquantia_link_is_up(phydev)) {
 563                 printf("%s Waiting for PHY auto negotiation to complete",
 564                        phydev->dev->name);
 565                 do {
 566                         udelay(1000);
 567                         if ((i++ % 500) == 0)
 568                                 printf(".");
 569                 } while (!aquantia_link_is_up(phydev) &&
 570                          i < (4 * PHY_ANEG_TIMEOUT));
 571
 572                 if (i > PHY_ANEG_TIMEOUT)
 573                         printf(" TIMEOUT !\n");
 574         }
 575
 576         /* Read twice because link state is latched and a
 577          * read moves the current state into the register */
 578         phy_read(phydev, MDIO_MMD_AN, MDIO_STAT1);
 579         reg = phy_read(phydev, MDIO_MMD_AN, MDIO_STAT1);
 580         if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS))
 581                 phydev->link = 0;
 582         else
 583                 phydev->link = 1;
 584
 585         speed = phy_read(phydev, MDIO_MMD_PMAPMD, MII_BMCR);
 586         if (speed & AQUNTIA_SPEED_MSB_MASK) {
 587                 if (speed & AQUNTIA_SPEED_LSB_MASK)
 588                         phydev->speed = SPEED_10000;
 589                 else
 590                         phydev->speed = SPEED_1000;
 591         } else {
 592                 if (speed & AQUNTIA_SPEED_LSB_MASK)
 593                         phydev->speed = SPEED_100;
 594                 else
 595                         phydev->speed = SPEED_10;
 596         }
 597
 598         return 0;
 599 }
 600
 601 struct phy_driver aq1202_driver = {
 602         .name = "Aquantia AQ1202",
 603         .uid = 0x3a1b445,
 604         .mask = 0xfffffff0,
 605         .features = PHY_10G_FEATURES,
 606         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 607                         MDIO_MMD_PHYXS | MDIO_MMD_AN |
 608                         MDIO_MMD_VEND1),
 609         .config = &aquantia_config,
 610         .startup = &aquantia_startup,
 611         .shutdown = &gen10g_shutdown,
 612 };
 613
 614 struct phy_driver aq2104_driver = {
 615         .name = "Aquantia AQ2104",
 616         .uid = 0x3a1b460,
 617         .mask = 0xfffffff0,
 618         .features = PHY_10G_FEATURES,
 619         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 620                         MDIO_MMD_PHYXS | MDIO_MMD_AN |
 621                         MDIO_MMD_VEND1),
 622         .config = &aquantia_config,
 623         .startup = &aquantia_startup,
 624         .shutdown = &gen10g_shutdown,
 625 };
 626
 627 struct phy_driver aqr105_driver = {
 628         .name = "Aquantia AQR105",
 629         .uid = 0x3a1b4a2,
 630         .mask = 0xfffffff0,
 631         .features = PHY_10G_FEATURES,
 632         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 633                         MDIO_MMD_PHYXS | MDIO_MMD_AN |
 634                         MDIO_MMD_VEND1),
 635         .config = &aquantia_config,
 636         .startup = &aquantia_startup,
 637         .shutdown = &gen10g_shutdown,
 638         .data = AQUANTIA_GEN1,
 639 };
 640
 641 struct phy_driver aqr106_driver = {
 642         .name = "Aquantia AQR106",
 643         .uid = 0x3a1b4d0,
 644         .mask = 0xfffffff0,
 645         .features = PHY_10G_FEATURES,
 646         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 647                         MDIO_MMD_PHYXS | MDIO_MMD_AN |
 648                         MDIO_MMD_VEND1),
 649         .config = &aquantia_config,
 650         .startup = &aquantia_startup,
 651         .shutdown = &gen10g_shutdown,
 652 };
 653
 654 struct phy_driver aqr107_driver = {
 655         .name = "Aquantia AQR107",
 656         .uid = 0x3a1b4e0,
 657         .mask = 0xfffffff0,
 658         .features = PHY_10G_FEATURES,
 659         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 660                         MDIO_MMD_PHYXS | MDIO_MMD_AN |
 661                         MDIO_MMD_VEND1),
 662         .config = &aquantia_config,
 663         .startup = &aquantia_startup,
 664         .shutdown = &gen10g_shutdown,
 665         .data = AQUANTIA_GEN2,
 666 };
 667
 668 struct phy_driver aqr112_driver = {
 669         .name = "Aquantia AQR112",
 670         .uid = 0x3a1b660,
 671         .mask = 0xfffffff0,
 672         .features = PHY_10G_FEATURES,
 673         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS |
 674                  MDIO_MMD_PHYXS | MDIO_MMD_AN |
 675                  MDIO_MMD_VEND1),
 676         .config = &aquantia_config,
 677         .startup = &aquantia_startup,
 678         .shutdown = &gen10g_shutdown,
 679         .data = AQUANTIA_GEN3,
 680 };
 681
 682 struct phy_driver aqr405_driver = {
 683         .name = "Aquantia AQR405",
 684         .uid = 0x3a1b4b2,
 685         .mask = 0xfffffff0,
 686         .features = PHY_10G_FEATURES,
 687         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 688                  MDIO_MMD_PHYXS | MDIO_MMD_AN |
 689                  MDIO_MMD_VEND1),
 690         .config = &aquantia_config,
 691         .startup = &aquantia_startup,
 692         .shutdown = &gen10g_shutdown,
 693         .data = AQUANTIA_GEN1,
 694 };
 695
 696 struct phy_driver aqr412_driver = {
 697         .name = "Aquantia AQR412",
 698         .uid = 0x3a1b710,
 699         .mask = 0xfffffff0,
 700         .features = PHY_10G_FEATURES,
 701         .mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS |
 702                  MDIO_MMD_PHYXS | MDIO_MMD_AN |
 703                  MDIO_MMD_VEND1),
 704         .config = &aquantia_config,
 705         .startup = &aquantia_startup,
 706         .shutdown = &gen10g_shutdown,
 707         .data = AQUANTIA_GEN3,
 708 };
 709
 710 int phy_aquantia_init(void)
 711 {
 712         phy_register(&aq1202_driver);
 713         phy_register(&aq2104_driver);
 714         phy_register(&aqr105_driver);
 715         phy_register(&aqr106_driver);
 716         phy_register(&aqr107_driver);
 717         phy_register(&aqr112_driver);
 718         phy_register(&aqr405_driver);
 719         phy_register(&aqr412_driver);
 720
 721         return 0;
 722 }