drivers/qe/uec_phy.c

   1 /*
   2  * Copyright (C) 2005,2010-2011 Freescale Semiconductor, Inc.
   3  *
   4  * Author: Shlomi Gridish
   5  *
   6  * Description: UCC GETH Driver -- PHY handling
   7  *              Driver for UEC on QE
   8  *              Based on 8260_io/fcc_enet.c
   9  *
  10  * This program is free software; you can redistribute  it and/or modify it
  11  * under  the terms of  the GNU General  Public License as published by the
  12  * Free Software Foundation;  either version 2 of the  License, or (at your
  13  * option) any later version.
  14  *
  15  */
  16
  17 #include "common.h"
  18 #include "net.h"
  19 #include "malloc.h"
  20 #include "asm/errno.h"
  21 #include "asm/immap_qe.h"
  22 #include "asm/io.h"
  23 #include "qe.h"
  24 #include "uccf.h"
  25 #include "uec.h"
  26 #include "uec_phy.h"
  27 #include "miiphy.h"
  28 #include <phy.h>
  29
  30 #define ugphy_printk(format, arg...)  \
  31         printf(format "\n", ## arg)
  32
  33 #define ugphy_dbg(format, arg...)            \
  34         ugphy_printk(format , ## arg)
  35 #define ugphy_err(format, arg...)            \
  36         ugphy_printk(format , ## arg)
  37 #define ugphy_info(format, arg...)           \
  38         ugphy_printk(format , ## arg)
  39 #define ugphy_warn(format, arg...)           \
  40         ugphy_printk(format , ## arg)
  41
  42 #ifdef UEC_VERBOSE_DEBUG
  43 #define ugphy_vdbg ugphy_dbg
  44 #else
  45 #define ugphy_vdbg(ugeth, fmt, args...) do { } while (0)
  46 #endif /* UEC_VERBOSE_DEBUG */
  47
  48 /*--------------------------------------------------------------------+
  49  * Fixed PHY (PHY-less) support for Ethernet Ports.
  50  *
  51  * Copied from arch/powerpc/cpu/ppc4xx/4xx_enet.c
  52  *--------------------------------------------------------------------*/
  53
  54 /*
  55  * Some boards do not have a PHY for each ethernet port. These ports are known
  56  * as Fixed PHY (or PHY-less) ports. For such ports, set the appropriate
  57  * CONFIG_SYS_UECx_PHY_ADDR equal to CONFIG_FIXED_PHY_ADDR (an unused address)
  58  * When the drver tries to identify the PHYs, CONFIG_FIXED_PHY will be returned
  59  * and the driver will search CONFIG_SYS_FIXED_PHY_PORTS to find what network
  60  * speed and duplex should be for the port.
  61  *
  62  * Example board header configuration file:
  63  *     #define CONFIG_FIXED_PHY   0xFFFFFFFF
  64  *     #define CONFIG_SYS_FIXED_PHY_ADDR 0x1E (pick an unused phy address)
  65  *
  66  *     #define CONFIG_SYS_UEC1_PHY_ADDR CONFIG_SYS_FIXED_PHY_ADDR
  67  *     #define CONFIG_SYS_UEC2_PHY_ADDR 0x02
  68  *     #define CONFIG_SYS_UEC3_PHY_ADDR CONFIG_SYS_FIXED_PHY_ADDR
  69  *     #define CONFIG_SYS_UEC4_PHY_ADDR 0x04
  70  *
  71  *     #define CONFIG_SYS_FIXED_PHY_PORT(name,speed,duplex) \
  72  *                 {name, speed, duplex},
  73  *
  74  *     #define CONFIG_SYS_FIXED_PHY_PORTS \
  75  *                 CONFIG_SYS_FIXED_PHY_PORT("UEC0",SPEED_100,DUPLEX_FULL) \
  76  *                 CONFIG_SYS_FIXED_PHY_PORT("UEC2",SPEED_100,DUPLEX_HALF)
  77  */
  78
  79 #ifndef CONFIG_FIXED_PHY
  80 #define CONFIG_FIXED_PHY        0xFFFFFFFF /* Fixed PHY (PHY-less) */
  81 #endif
  82
  83 #ifndef CONFIG_SYS_FIXED_PHY_PORTS
  84 #define CONFIG_SYS_FIXED_PHY_PORTS      /* default is an empty array */
  85 #endif
  86
  87 struct fixed_phy_port {
  88         char name[16];  /* ethernet port name */
  89         unsigned int speed;     /* specified speed 10,100 or 1000 */
  90         unsigned int duplex;    /* specified duplex FULL or HALF */
  91 };
  92
  93 static const struct fixed_phy_port fixed_phy_port[] = {
  94         CONFIG_SYS_FIXED_PHY_PORTS /* defined in board configuration file */
  95 };
  96
  97 /*--------------------------------------------------------------------+
  98  * BitBang MII support for ethernet ports
  99  *
 100  * Based from MPC8560ADS implementation
 101  *--------------------------------------------------------------------*/
 102 /*
 103  * Example board header file to define bitbang ethernet ports:
 104  *
 105  * #define CONFIG_SYS_BITBANG_PHY_PORT(name) name,
 106  * #define CONFIG_SYS_BITBANG_PHY_PORTS CONFIG_SYS_BITBANG_PHY_PORT("UEC0")
 107 */
 108 #ifndef CONFIG_SYS_BITBANG_PHY_PORTS
 109 #define CONFIG_SYS_BITBANG_PHY_PORTS    /* default is an empty array */
 110 #endif
 111
 112 #if defined(CONFIG_BITBANGMII)
 113 static const char *bitbang_phy_port[] = {
 114         CONFIG_SYS_BITBANG_PHY_PORTS /* defined in board configuration file */
 115 };
 116 #endif /* CONFIG_BITBANGMII */
 117
 118 static void config_genmii_advert (struct uec_mii_info *mii_info);
 119 static void genmii_setup_forced (struct uec_mii_info *mii_info);
 120 static void genmii_restart_aneg (struct uec_mii_info *mii_info);
 121 static int gbit_config_aneg (struct uec_mii_info *mii_info);
 122 static int genmii_config_aneg (struct uec_mii_info *mii_info);
 123 static int genmii_update_link (struct uec_mii_info *mii_info);
 124 static int genmii_read_status (struct uec_mii_info *mii_info);
 125 u16 uec_phy_read(struct uec_mii_info *mii_info, u16 regnum);
 126 void uec_phy_write(struct uec_mii_info *mii_info, u16 regnum, u16 val);
 127
 128 /* Write value to the PHY for this device to the register at regnum, */
 129 /* waiting until the write is done before it returns.  All PHY */
 130 /* configuration has to be done through the TSEC1 MIIM regs */
 131 void uec_write_phy_reg (struct eth_device *dev, int mii_id, int regnum, int value)
 132 {
 133         uec_private_t *ugeth = (uec_private_t *) dev->priv;
 134         uec_mii_t *ug_regs;
 135         enet_tbi_mii_reg_e mii_reg = (enet_tbi_mii_reg_e) regnum;
 136         u32 tmp_reg;
 137
 138
 139 #if defined(CONFIG_BITBANGMII)
 140         u32 i = 0;
 141
 142         for (i = 0; i < ARRAY_SIZE(bitbang_phy_port); i++) {
 143                 if (strncmp(dev->name, bitbang_phy_port[i],
 144                         sizeof(dev->name)) == 0) {
 145                         (void)bb_miiphy_write(NULL, mii_id, regnum, value);
 146                         return;
 147                 }
 148         }
 149 #endif /* CONFIG_BITBANGMII */
 150
 151         ug_regs = ugeth->uec_mii_regs;
 152
 153         /* Stop the MII management read cycle */
 154         out_be32 (&ug_regs->miimcom, 0);
 155         /* Setting up the MII Mangement Address Register */
 156         tmp_reg = ((u32) mii_id << MIIMADD_PHY_ADDRESS_SHIFT) | mii_reg;
 157         out_be32 (&ug_regs->miimadd, tmp_reg);
 158
 159         /* Setting up the MII Mangement Control Register with the value */
 160         out_be32 (&ug_regs->miimcon, (u32) value);
 161         sync();
 162
 163         /* Wait till MII management write is complete */
 164         while ((in_be32 (&ug_regs->miimind)) & MIIMIND_BUSY);
 165 }
 166
 167 /* Reads from register regnum in the PHY for device dev, */
 168 /* returning the value.  Clears miimcom first.  All PHY */
 169 /* configuration has to be done through the TSEC1 MIIM regs */
 170 int uec_read_phy_reg (struct eth_device *dev, int mii_id, int regnum)
 171 {
 172         uec_private_t *ugeth = (uec_private_t *) dev->priv;
 173         uec_mii_t *ug_regs;
 174         enet_tbi_mii_reg_e mii_reg = (enet_tbi_mii_reg_e) regnum;
 175         u32 tmp_reg;
 176         u16 value;
 177
 178
 179 #if defined(CONFIG_BITBANGMII)
 180         u32 i = 0;
 181
 182         for (i = 0; i < ARRAY_SIZE(bitbang_phy_port); i++) {
 183                 if (strncmp(dev->name, bitbang_phy_port[i],
 184                         sizeof(dev->name)) == 0) {
 185                         (void)bb_miiphy_read(NULL, mii_id, regnum, &value);
 186                         return (value);
 187                 }
 188         }
 189 #endif /* CONFIG_BITBANGMII */
 190
 191         ug_regs = ugeth->uec_mii_regs;
 192
 193         /* Setting up the MII Mangement Address Register */
 194         tmp_reg = ((u32) mii_id << MIIMADD_PHY_ADDRESS_SHIFT) | mii_reg;
 195         out_be32 (&ug_regs->miimadd, tmp_reg);
 196
 197         /* clear MII management command cycle */
 198         out_be32 (&ug_regs->miimcom, 0);
 199         sync();
 200
 201         /* Perform an MII management read cycle */
 202         out_be32 (&ug_regs->miimcom, MIIMCOM_READ_CYCLE);
 203
 204         /* Wait till MII management write is complete */
 205         while ((in_be32 (&ug_regs->miimind)) &
 206                (MIIMIND_NOT_VALID | MIIMIND_BUSY));
 207
 208         /* Read MII management status  */
 209         value = (u16) in_be32 (&ug_regs->miimstat);
 210         if (value == 0xffff)
 211                 ugphy_vdbg
 212                         ("read wrong value : mii_id %d,mii_reg %d, base %08x",
 213                          mii_id, mii_reg, (u32) & (ug_regs->miimcfg));
 214
 215         return (value);
 216 }
 217
 218 void mii_clear_phy_interrupt (struct uec_mii_info *mii_info)
 219 {
 220         if (mii_info->phyinfo->ack_interrupt)
 221                 mii_info->phyinfo->ack_interrupt (mii_info);
 222 }
 223
 224 void mii_configure_phy_interrupt (struct uec_mii_info *mii_info,
 225                                   u32 interrupts)
 226 {
 227         mii_info->interrupts = interrupts;
 228         if (mii_info->phyinfo->config_intr)
 229                 mii_info->phyinfo->config_intr (mii_info);
 230 }
 231
 232 /* Writes MII_ADVERTISE with the appropriate values, after
 233  * sanitizing advertise to make sure only supported features
 234  * are advertised
 235  */
 236 static void config_genmii_advert (struct uec_mii_info *mii_info)
 237 {
 238         u32 advertise;
 239         u16 adv;
 240
 241         /* Only allow advertising what this PHY supports */
 242         mii_info->advertising &= mii_info->phyinfo->features;
 243         advertise = mii_info->advertising;
 244
 245         /* Setup standard advertisement */
 246         adv = uec_phy_read(mii_info, MII_ADVERTISE);
 247         adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
 248         if (advertise & ADVERTISED_10baseT_Half)
 249                 adv |= ADVERTISE_10HALF;
 250         if (advertise & ADVERTISED_10baseT_Full)
 251                 adv |= ADVERTISE_10FULL;
 252         if (advertise & ADVERTISED_100baseT_Half)
 253                 adv |= ADVERTISE_100HALF;
 254         if (advertise & ADVERTISED_100baseT_Full)
 255                 adv |= ADVERTISE_100FULL;
 256         uec_phy_write(mii_info, MII_ADVERTISE, adv);
 257 }
 258
 259 static void genmii_setup_forced (struct uec_mii_info *mii_info)
 260 {
 261         u16 ctrl;
 262         u32 features = mii_info->phyinfo->features;
 263
 264         ctrl = uec_phy_read(mii_info, MII_BMCR);
 265
 266         ctrl &= ~(BMCR_FULLDPLX | BMCR_SPEED100 |
 267                   BMCR_SPEED1000 | BMCR_ANENABLE);
 268         ctrl |= BMCR_RESET;
 269
 270         switch (mii_info->speed) {
 271         case SPEED_1000:
 272                 if (features & (SUPPORTED_1000baseT_Half
 273                                 | SUPPORTED_1000baseT_Full)) {
 274                         ctrl |= BMCR_SPEED1000;
 275                         break;
 276                 }
 277                 mii_info->speed = SPEED_100;
 278         case SPEED_100:
 279                 if (features & (SUPPORTED_100baseT_Half
 280                                 | SUPPORTED_100baseT_Full)) {
 281                         ctrl |= BMCR_SPEED100;
 282                         break;
 283                 }
 284                 mii_info->speed = SPEED_10;
 285         case SPEED_10:
 286                 if (features & (SUPPORTED_10baseT_Half
 287                                 | SUPPORTED_10baseT_Full))
 288                         break;
 289         default:                /* Unsupported speed! */
 290                 ugphy_err ("%s: Bad speed!", mii_info->dev->name);
 291                 break;
 292         }
 293
 294         uec_phy_write(mii_info, MII_BMCR, ctrl);
 295 }
 296
 297 /* Enable and Restart Autonegotiation */
 298 static void genmii_restart_aneg (struct uec_mii_info *mii_info)
 299 {
 300         u16 ctl;
 301
 302         ctl = uec_phy_read(mii_info, MII_BMCR);
 303         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
 304         uec_phy_write(mii_info, MII_BMCR, ctl);
 305 }
 306
 307 static int gbit_config_aneg (struct uec_mii_info *mii_info)
 308 {
 309         u16 adv;
 310         u32 advertise;
 311
 312         if (mii_info->autoneg) {
 313                 /* Configure the ADVERTISE register */
 314                 config_genmii_advert (mii_info);
 315                 advertise = mii_info->advertising;
 316
 317                 adv = uec_phy_read(mii_info, MII_CTRL1000);
 318                 adv &= ~(ADVERTISE_1000FULL |
 319                          ADVERTISE_1000HALF);
 320                 if (advertise & SUPPORTED_1000baseT_Half)
 321                         adv |= ADVERTISE_1000HALF;
 322                 if (advertise & SUPPORTED_1000baseT_Full)
 323                         adv |= ADVERTISE_1000FULL;
 324                 uec_phy_write(mii_info, MII_CTRL1000, adv);
 325
 326                 /* Start/Restart aneg */
 327                 genmii_restart_aneg (mii_info);
 328         } else
 329                 genmii_setup_forced (mii_info);
 330
 331         return 0;
 332 }
 333
 334 static int marvell_config_aneg (struct uec_mii_info *mii_info)
 335 {
 336         /* The Marvell PHY has an errata which requires
 337          * that certain registers get written in order
 338          * to restart autonegotiation */
 339         uec_phy_write(mii_info, MII_BMCR, BMCR_RESET);
 340
 341         uec_phy_write(mii_info, 0x1d, 0x1f);
 342         uec_phy_write(mii_info, 0x1e, 0x200c);
 343         uec_phy_write(mii_info, 0x1d, 0x5);
 344         uec_phy_write(mii_info, 0x1e, 0);
 345         uec_phy_write(mii_info, 0x1e, 0x100);
 346
 347         gbit_config_aneg (mii_info);
 348
 349         return 0;
 350 }
 351
 352 static int genmii_config_aneg (struct uec_mii_info *mii_info)
 353 {
 354         if (mii_info->autoneg) {
 355                 /* Speed up the common case, if link is already up, speed and
 356                    duplex match, skip auto neg as it already matches */
 357                 if (!genmii_read_status(mii_info) && mii_info->link)
 358                         if (mii_info->duplex == DUPLEX_FULL &&
 359                             mii_info->speed == SPEED_100)
 360                                 if (mii_info->advertising &
 361                                     ADVERTISED_100baseT_Full)
 362                                         return 0;
 363
 364                 config_genmii_advert (mii_info);
 365                 genmii_restart_aneg (mii_info);
 366         } else
 367                 genmii_setup_forced (mii_info);
 368
 369         return 0;
 370 }
 371
 372 static int genmii_update_link (struct uec_mii_info *mii_info)
 373 {
 374         u16 status;
 375
 376         /* Status is read once to clear old link state */
 377         uec_phy_read(mii_info, MII_BMSR);
 378
 379         /*
 380          * Wait if the link is up, and autonegotiation is in progress
 381          * (ie - we're capable and it's not done)
 382          */
 383         status = uec_phy_read(mii_info, MII_BMSR);
 384         if ((status & BMSR_LSTATUS) && (status & BMSR_ANEGCAPABLE)
 385             && !(status & BMSR_ANEGCOMPLETE)) {
 386                 int i = 0;
 387
 388                 while (!(status & BMSR_ANEGCOMPLETE)) {
 389                         /*
 390                          * Timeout reached ?
 391                          */
 392                         if (i > UGETH_AN_TIMEOUT) {
 393                                 mii_info->link = 0;
 394                                 return 0;
 395                         }
 396
 397                         i++;
 398                         udelay(1000);   /* 1 ms */
 399                         status = uec_phy_read(mii_info, MII_BMSR);
 400                 }
 401                 mii_info->link = 1;
 402         } else {
 403                 if (status & BMSR_LSTATUS)
 404                         mii_info->link = 1;
 405                 else
 406                         mii_info->link = 0;
 407         }
 408
 409         return 0;
 410 }
 411
 412 static int genmii_read_status (struct uec_mii_info *mii_info)
 413 {
 414         u16 status;
 415         int err;
 416
 417         /* Update the link, but return if there
 418          * was an error */
 419         err = genmii_update_link (mii_info);
 420         if (err)
 421                 return err;
 422
 423         if (mii_info->autoneg) {
 424                 status = uec_phy_read(mii_info, MII_STAT1000);
 425
 426                 if (status & (LPA_1000FULL | LPA_1000HALF)) {
 427                         mii_info->speed = SPEED_1000;
 428                         if (status & LPA_1000FULL)
 429                                 mii_info->duplex = DUPLEX_FULL;
 430                         else
 431                                 mii_info->duplex = DUPLEX_HALF;
 432                 } else {
 433                         status = uec_phy_read(mii_info, MII_LPA);
 434
 435                         if (status & (LPA_10FULL | LPA_100FULL))
 436                                 mii_info->duplex = DUPLEX_FULL;
 437                         else
 438                                 mii_info->duplex = DUPLEX_HALF;
 439                         if (status & (LPA_100FULL | LPA_100HALF))
 440                                 mii_info->speed = SPEED_100;
 441                         else
 442                                 mii_info->speed = SPEED_10;
 443                 }
 444                 mii_info->pause = 0;
 445         }
 446         /* On non-aneg, we assume what we put in BMCR is the speed,
 447          * though magic-aneg shouldn't prevent this case from occurring
 448          */
 449
 450         return 0;
 451 }
 452
 453 static int bcm_init(struct uec_mii_info *mii_info)
 454 {
 455         struct eth_device *edev = mii_info->dev;
 456         uec_private_t *uec = edev->priv;
 457
 458         gbit_config_aneg(mii_info);
 459
 460         if ((uec->uec_info->enet_interface_type ==
 461                                 PHY_INTERFACE_MODE_RGMII_RXID) &&
 462                         (uec->uec_info->speed == SPEED_1000)) {
 463                 u16 val;
 464                 int cnt = 50;
 465
 466                 /* Wait for aneg to complete. */
 467                 do
 468                         val = uec_phy_read(mii_info, MII_BMSR);
 469                 while (--cnt && !(val & BMSR_ANEGCOMPLETE));
 470
 471                 /* Set RDX clk delay. */
 472                 uec_phy_write(mii_info, 0x18, 0x7 | (7 << 12));
 473
 474                 val = uec_phy_read(mii_info, 0x18);
 475                 /* Set RDX-RXC skew. */
 476                 val |= (1 << 8);
 477                 val |= (7 | (7 << 12));
 478                 /* Write bits 14:0. */
 479                 val |= (1 << 15);
 480                 uec_phy_write(mii_info, 0x18, val);
 481         }
 482
 483          return 0;
 484 }
 485
 486 static int uec_marvell_init(struct uec_mii_info *mii_info)
 487 {
 488         struct eth_device *edev = mii_info->dev;
 489         uec_private_t *uec = edev->priv;
 490         phy_interface_t iface = uec->uec_info->enet_interface_type;
 491         int     speed = uec->uec_info->speed;
 492
 493         if ((speed == SPEED_1000) &&
 494            (iface == PHY_INTERFACE_MODE_RGMII_ID ||
 495             iface == PHY_INTERFACE_MODE_RGMII_RXID ||
 496             iface == PHY_INTERFACE_MODE_RGMII_TXID)) {
 497                 int temp;
 498
 499                 temp = uec_phy_read(mii_info, MII_M1111_PHY_EXT_CR);
 500                 if (iface == PHY_INTERFACE_MODE_RGMII_ID) {
 501                         temp |= MII_M1111_RX_DELAY | MII_M1111_TX_DELAY;
 502                 } else if (iface == PHY_INTERFACE_MODE_RGMII_RXID) {
 503                         temp &= ~MII_M1111_TX_DELAY;
 504                         temp |= MII_M1111_RX_DELAY;
 505                 } else if (iface == PHY_INTERFACE_MODE_RGMII_TXID) {
 506                         temp &= ~MII_M1111_RX_DELAY;
 507                         temp |= MII_M1111_TX_DELAY;
 508                 }
 509                 uec_phy_write(mii_info, MII_M1111_PHY_EXT_CR, temp);
 510
 511                 temp = uec_phy_read(mii_info, MII_M1111_PHY_EXT_SR);
 512                 temp &= ~MII_M1111_HWCFG_MODE_MASK;
 513                 temp |= MII_M1111_HWCFG_MODE_RGMII;
 514                 uec_phy_write(mii_info, MII_M1111_PHY_EXT_SR, temp);
 515
 516                 uec_phy_write(mii_info, MII_BMCR, BMCR_RESET);
 517         }
 518
 519         return 0;
 520 }
 521
 522 static int marvell_read_status (struct uec_mii_info *mii_info)
 523 {
 524         u16 status;
 525         int err;
 526
 527         /* Update the link, but return if there
 528          * was an error */
 529         err = genmii_update_link (mii_info);
 530         if (err)
 531                 return err;
 532
 533         /* If the link is up, read the speed and duplex */
 534         /* If we aren't autonegotiating, assume speeds
 535          * are as set */
 536         if (mii_info->autoneg && mii_info->link) {
 537                 int speed;
 538
 539                 status = uec_phy_read(mii_info, MII_M1011_PHY_SPEC_STATUS);
 540
 541                 /* Get the duplexity */
 542                 if (status & MII_M1011_PHY_SPEC_STATUS_FULLDUPLEX)
 543                         mii_info->duplex = DUPLEX_FULL;
 544                 else
 545                         mii_info->duplex = DUPLEX_HALF;
 546
 547                 /* Get the speed */
 548                 speed = status & MII_M1011_PHY_SPEC_STATUS_SPD_MASK;
 549                 switch (speed) {
 550                 case MII_M1011_PHY_SPEC_STATUS_1000:
 551                         mii_info->speed = SPEED_1000;
 552                         break;
 553                 case MII_M1011_PHY_SPEC_STATUS_100:
 554                         mii_info->speed = SPEED_100;
 555                         break;
 556                 default:
 557                         mii_info->speed = SPEED_10;
 558                         break;
 559                 }
 560                 mii_info->pause = 0;
 561         }
 562
 563         return 0;
 564 }
 565
 566 static int marvell_ack_interrupt (struct uec_mii_info *mii_info)
 567 {
 568         /* Clear the interrupts by reading the reg */
 569         uec_phy_read(mii_info, MII_M1011_IEVENT);
 570
 571         return 0;
 572 }
 573
 574 static int marvell_config_intr (struct uec_mii_info *mii_info)
 575 {
 576         if (mii_info->interrupts == MII_INTERRUPT_ENABLED)
 577                 uec_phy_write(mii_info, MII_M1011_IMASK, MII_M1011_IMASK_INIT);
 578         else
 579                 uec_phy_write(mii_info, MII_M1011_IMASK,
 580                                 MII_M1011_IMASK_CLEAR);
 581
 582         return 0;
 583 }
 584
 585 static int dm9161_init (struct uec_mii_info *mii_info)
 586 {
 587         /* Reset the PHY */
 588         uec_phy_write(mii_info, MII_BMCR, uec_phy_read(mii_info, MII_BMCR) |
 589                    BMCR_RESET);
 590         /* PHY and MAC connect */
 591         uec_phy_write(mii_info, MII_BMCR, uec_phy_read(mii_info, MII_BMCR) &
 592                    ~BMCR_ISOLATE);
 593
 594         uec_phy_write(mii_info, MII_DM9161_SCR, MII_DM9161_SCR_INIT);
 595
 596         config_genmii_advert (mii_info);
 597         /* Start/restart aneg */
 598         genmii_config_aneg (mii_info);
 599
 600         return 0;
 601 }
 602
 603 static int dm9161_config_aneg (struct uec_mii_info *mii_info)
 604 {
 605         return 0;
 606 }
 607
 608 static int dm9161_read_status (struct uec_mii_info *mii_info)
 609 {
 610         u16 status;
 611         int err;
 612
 613         /* Update the link, but return if there was an error */
 614         err = genmii_update_link (mii_info);
 615         if (err)
 616                 return err;
 617         /* If the link is up, read the speed and duplex
 618            If we aren't autonegotiating assume speeds are as set */
 619         if (mii_info->autoneg && mii_info->link) {
 620                 status = uec_phy_read(mii_info, MII_DM9161_SCSR);
 621                 if (status & (MII_DM9161_SCSR_100F | MII_DM9161_SCSR_100H))
 622                         mii_info->speed = SPEED_100;
 623                 else
 624                         mii_info->speed = SPEED_10;
 625
 626                 if (status & (MII_DM9161_SCSR_100F | MII_DM9161_SCSR_10F))
 627                         mii_info->duplex = DUPLEX_FULL;
 628                 else
 629                         mii_info->duplex = DUPLEX_HALF;
 630         }
 631
 632         return 0;
 633 }
 634
 635 static int dm9161_ack_interrupt (struct uec_mii_info *mii_info)
 636 {
 637         /* Clear the interrupt by reading the reg */
 638         uec_phy_read(mii_info, MII_DM9161_INTR);
 639
 640         return 0;
 641 }
 642
 643 static int dm9161_config_intr (struct uec_mii_info *mii_info)
 644 {
 645         if (mii_info->interrupts == MII_INTERRUPT_ENABLED)
 646                 uec_phy_write(mii_info, MII_DM9161_INTR, MII_DM9161_INTR_INIT);
 647         else
 648                 uec_phy_write(mii_info, MII_DM9161_INTR, MII_DM9161_INTR_STOP);
 649
 650         return 0;
 651 }
 652
 653 static void dm9161_close (struct uec_mii_info *mii_info)
 654 {
 655 }
 656
 657 static int fixed_phy_aneg (struct uec_mii_info *mii_info)
 658 {
 659         mii_info->autoneg = 0; /* Turn off auto negotiation for fixed phy */
 660         return 0;
 661 }
 662
 663 static int fixed_phy_read_status (struct uec_mii_info *mii_info)
 664 {
 665         int i = 0;
 666
 667         for (i = 0; i < ARRAY_SIZE(fixed_phy_port); i++) {
 668                 if (strncmp(mii_info->dev->name, fixed_phy_port[i].name,
 669                                 strlen(mii_info->dev->name)) == 0) {
 670                         mii_info->speed = fixed_phy_port[i].speed;
 671                         mii_info->duplex = fixed_phy_port[i].duplex;
 672                         mii_info->link = 1; /* Link is always UP */
 673                         mii_info->pause = 0;
 674                         break;
 675                 }
 676         }
 677         return 0;
 678 }
 679
 680 static int smsc_config_aneg (struct uec_mii_info *mii_info)
 681 {
 682         return 0;
 683 }
 684
 685 static int smsc_read_status (struct uec_mii_info *mii_info)
 686 {
 687         u16 status;
 688         int err;
 689
 690         /* Update the link, but return if there
 691          * was an error */
 692         err = genmii_update_link (mii_info);
 693         if (err)
 694                 return err;
 695
 696         /* If the link is up, read the speed and duplex */
 697         /* If we aren't autonegotiating, assume speeds
 698          * are as set */
 699         if (mii_info->autoneg && mii_info->link) {
 700                 int     val;
 701
 702                 status = uec_phy_read(mii_info, 0x1f);
 703                 val = (status & 0x1c) >> 2;
 704
 705                 switch (val) {
 706                         case 1:
 707                                 mii_info->duplex = DUPLEX_HALF;
 708                                 mii_info->speed = SPEED_10;
 709                                 break;
 710                         case 5:
 711                                 mii_info->duplex = DUPLEX_FULL;
 712                                 mii_info->speed = SPEED_10;
 713                                 break;
 714                         case 2:
 715                                 mii_info->duplex = DUPLEX_HALF;
 716                                 mii_info->speed = SPEED_100;
 717                                 break;
 718                         case 6:
 719                                 mii_info->duplex = DUPLEX_FULL;
 720                                 mii_info->speed = SPEED_100;
 721                                 break;
 722                 }
 723                 mii_info->pause = 0;
 724         }
 725
 726         return 0;
 727 }
 728
 729 static struct phy_info phy_info_dm9161 = {
 730         .phy_id = 0x0181b880,
 731         .phy_id_mask = 0x0ffffff0,
 732         .name = "Davicom DM9161E",
 733         .init = dm9161_init,
 734         .config_aneg = dm9161_config_aneg,
 735         .read_status = dm9161_read_status,
 736         .close = dm9161_close,
 737 };
 738
 739 static struct phy_info phy_info_dm9161a = {
 740         .phy_id = 0x0181b8a0,
 741         .phy_id_mask = 0x0ffffff0,
 742         .name = "Davicom DM9161A",
 743         .features = MII_BASIC_FEATURES,
 744         .init = dm9161_init,
 745         .config_aneg = dm9161_config_aneg,
 746         .read_status = dm9161_read_status,
 747         .ack_interrupt = dm9161_ack_interrupt,
 748         .config_intr = dm9161_config_intr,
 749         .close = dm9161_close,
 750 };
 751
 752 static struct phy_info phy_info_marvell = {
 753         .phy_id = 0x01410c00,
 754         .phy_id_mask = 0xffffff00,
 755         .name = "Marvell 88E11x1",
 756         .features = MII_GBIT_FEATURES,
 757         .init = &uec_marvell_init,
 758         .config_aneg = &marvell_config_aneg,
 759         .read_status = &marvell_read_status,
 760         .ack_interrupt = &marvell_ack_interrupt,
 761         .config_intr = &marvell_config_intr,
 762 };
 763
 764 static struct phy_info phy_info_bcm5481 = {
 765         .phy_id = 0x0143bca0,
 766         .phy_id_mask = 0xffffff0,
 767         .name = "Broadcom 5481",
 768         .features = MII_GBIT_FEATURES,
 769         .read_status = genmii_read_status,
 770         .init = bcm_init,
 771 };
 772
 773 static struct phy_info phy_info_fixedphy = {
 774         .phy_id = CONFIG_FIXED_PHY,
 775         .phy_id_mask = CONFIG_FIXED_PHY,
 776         .name = "Fixed PHY",
 777         .config_aneg = fixed_phy_aneg,
 778         .read_status = fixed_phy_read_status,
 779 };
 780
 781 static struct phy_info phy_info_smsclan8700 = {
 782         .phy_id = 0x0007c0c0,
 783         .phy_id_mask = 0xfffffff0,
 784         .name = "SMSC LAN8700",
 785         .features = MII_BASIC_FEATURES,
 786         .config_aneg = smsc_config_aneg,
 787         .read_status = smsc_read_status,
 788 };
 789
 790 static struct phy_info phy_info_genmii = {
 791         .phy_id = 0x00000000,
 792         .phy_id_mask = 0x00000000,
 793         .name = "Generic MII",
 794         .features = MII_BASIC_FEATURES,
 795         .config_aneg = genmii_config_aneg,
 796         .read_status = genmii_read_status,
 797 };
 798
 799 static struct phy_info *phy_info[] = {
 800         &phy_info_dm9161,
 801         &phy_info_dm9161a,
 802         &phy_info_marvell,
 803         &phy_info_bcm5481,
 804         &phy_info_smsclan8700,
 805         &phy_info_fixedphy,
 806         &phy_info_genmii,
 807         NULL
 808 };
 809
 810 u16 uec_phy_read(struct uec_mii_info *mii_info, u16 regnum)
 811 {
 812         return mii_info->mdio_read (mii_info->dev, mii_info->mii_id, regnum);
 813 }
 814
 815 void uec_phy_write(struct uec_mii_info *mii_info, u16 regnum, u16 val)
 816 {
 817         mii_info->mdio_write (mii_info->dev, mii_info->mii_id, regnum, val);
 818 }
 819
 820 /* Use the PHY ID registers to determine what type of PHY is attached
 821  * to device dev.  return a struct phy_info structure describing that PHY
 822  */
 823 struct phy_info *uec_get_phy_info (struct uec_mii_info *mii_info)
 824 {
 825         u16 phy_reg;
 826         u32 phy_ID;
 827         int i;
 828         struct phy_info *theInfo = NULL;
 829
 830         /* Grab the bits from PHYIR1, and put them in the upper half */
 831         phy_reg = uec_phy_read(mii_info, MII_PHYSID1);
 832         phy_ID = (phy_reg & 0xffff) << 16;
 833
 834         /* Grab the bits from PHYIR2, and put them in the lower half */
 835         phy_reg = uec_phy_read(mii_info, MII_PHYSID2);
 836         phy_ID |= (phy_reg & 0xffff);
 837
 838         /* loop through all the known PHY types, and find one that */
 839         /* matches the ID we read from the PHY. */
 840         for (i = 0; phy_info[i]; i++)
 841                 if (phy_info[i]->phy_id ==
 842                     (phy_ID & phy_info[i]->phy_id_mask)) {
 843                         theInfo = phy_info[i];
 844                         break;
 845                 }
 846
 847         /* This shouldn't happen, as we have generic PHY support */
 848         if (theInfo == NULL) {
 849                 ugphy_info ("UEC: PHY id %x is not supported!", phy_ID);
 850                 return NULL;
 851         } else {
 852                 ugphy_info ("UEC: PHY is %s (%x)", theInfo->name, phy_ID);
 853         }
 854
 855         return theInfo;
 856 }
 857
 858 void marvell_phy_interface_mode(struct eth_device *dev, phy_interface_t type,
 859                 int speed)
 860 {
 861         uec_private_t *uec = (uec_private_t *) dev->priv;
 862         struct uec_mii_info *mii_info;
 863         u16 status;
 864
 865         if (!uec->mii_info) {
 866                 printf ("%s: the PHY not initialized\n", __FUNCTION__);
 867                 return;
 868         }
 869         mii_info = uec->mii_info;
 870
 871         if (type == PHY_INTERFACE_MODE_RGMII) {
 872                 if (speed == SPEED_100) {
 873                         uec_phy_write(mii_info, 0x00, 0x9140);
 874                         uec_phy_write(mii_info, 0x1d, 0x001f);
 875                         uec_phy_write(mii_info, 0x1e, 0x200c);
 876                         uec_phy_write(mii_info, 0x1d, 0x0005);
 877                         uec_phy_write(mii_info, 0x1e, 0x0000);
 878                         uec_phy_write(mii_info, 0x1e, 0x0100);
 879                         uec_phy_write(mii_info, 0x09, 0x0e00);
 880                         uec_phy_write(mii_info, 0x04, 0x01e1);
 881                         uec_phy_write(mii_info, 0x00, 0x9140);
 882                         uec_phy_write(mii_info, 0x00, 0x1000);
 883                         udelay (100000);
 884                         uec_phy_write(mii_info, 0x00, 0x2900);
 885                         uec_phy_write(mii_info, 0x14, 0x0cd2);
 886                         uec_phy_write(mii_info, 0x00, 0xa100);
 887                         uec_phy_write(mii_info, 0x09, 0x0000);
 888                         uec_phy_write(mii_info, 0x1b, 0x800b);
 889                         uec_phy_write(mii_info, 0x04, 0x05e1);
 890                         uec_phy_write(mii_info, 0x00, 0xa100);
 891                         uec_phy_write(mii_info, 0x00, 0x2100);
 892                         udelay (1000000);
 893                 } else if (speed == SPEED_10) {
 894                         uec_phy_write(mii_info, 0x14, 0x8e40);
 895                         uec_phy_write(mii_info, 0x1b, 0x800b);
 896                         uec_phy_write(mii_info, 0x14, 0x0c82);
 897                         uec_phy_write(mii_info, 0x00, 0x8100);
 898                         udelay (1000000);
 899                 }
 900         }
 901
 902         /* handle 88e1111 rev.B2 erratum 5.6 */
 903         if (mii_info->autoneg) {
 904                 status = uec_phy_read(mii_info, MII_BMCR);
 905                 uec_phy_write(mii_info, MII_BMCR, status | BMCR_ANENABLE);
 906         }
 907         /* now the B2 will correctly report autoneg completion status */
 908 }
 909
 910 void change_phy_interface_mode (struct eth_device *dev,
 911                                 phy_interface_t type, int speed)
 912 {
 913 #ifdef CONFIG_PHY_MODE_NEED_CHANGE
 914         marvell_phy_interface_mode (dev, type, speed);
 915 #endif
 916 }