git.sur5r.net Git - u-boot/blob - drivers/net/tsec.c

   1 /*
   2  * Freescale Three Speed Ethernet Controller driver
   3  *
   4  * Copyright 2004-2011, 2013 Freescale Semiconductor, Inc.
   5  * (C) Copyright 2003, Motorola, Inc.
   6  * author Andy Fleming
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <config.h>
  12 #include <common.h>
  13 #include <malloc.h>
  14 #include <net.h>
  15 #include <command.h>
  16 #include <tsec.h>
  17 #include <fsl_mdio.h>
  18 #include <asm/errno.h>
  19 #include <asm/processor.h>
  20 #include <asm/io.h>
  21
  22 DECLARE_GLOBAL_DATA_PTR;
  23
  24 #define TX_BUF_CNT              2
  25
  26 #ifdef __GNUC__
  27 static struct txbd8 __iomem txbd[TX_BUF_CNT] __aligned(8);
  28 static struct rxbd8 __iomem rxbd[PKTBUFSRX] __aligned(8);
  29
  30 #else
  31 #error "rtx must be 64-bit aligned"
  32 #endif
  33
  34 static int tsec_send(struct eth_device *dev, void *packet, int length);
  35
  36 /* Default initializations for TSEC controllers. */
  37
  38 static struct tsec_info_struct tsec_info[] = {
  39 #ifdef CONFIG_TSEC1
  40         STD_TSEC_INFO(1),       /* TSEC1 */
  41 #endif
  42 #ifdef CONFIG_TSEC2
  43         STD_TSEC_INFO(2),       /* TSEC2 */
  44 #endif
  45 #ifdef CONFIG_MPC85XX_FEC
  46         {
  47                 .regs = TSEC_GET_REGS(2, 0x2000),
  48                 .devname = CONFIG_MPC85XX_FEC_NAME,
  49                 .phyaddr = FEC_PHY_ADDR,
  50                 .flags = FEC_FLAGS,
  51                 .mii_devname = DEFAULT_MII_NAME
  52         },                      /* FEC */
  53 #endif
  54 #ifdef CONFIG_TSEC3
  55         STD_TSEC_INFO(3),       /* TSEC3 */
  56 #endif
  57 #ifdef CONFIG_TSEC4
  58         STD_TSEC_INFO(4),       /* TSEC4 */
  59 #endif
  60 };
  61
  62 #define TBIANA_SETTINGS ( \
  63                 TBIANA_ASYMMETRIC_PAUSE \
  64                 | TBIANA_SYMMETRIC_PAUSE \
  65                 | TBIANA_FULL_DUPLEX \
  66                 )
  67
  68 /* By default force the TBI PHY into 1000Mbps full duplex when in SGMII mode */
  69 #ifndef CONFIG_TSEC_TBICR_SETTINGS
  70 #define CONFIG_TSEC_TBICR_SETTINGS ( \
  71                 TBICR_PHY_RESET \
  72                 | TBICR_ANEG_ENABLE \
  73                 | TBICR_FULL_DUPLEX \
  74                 | TBICR_SPEED1_SET \
  75                 )
  76 #endif /* CONFIG_TSEC_TBICR_SETTINGS */
  77
  78 /* Configure the TBI for SGMII operation */
  79 static void tsec_configure_serdes(struct tsec_private *priv)
  80 {
  81         /*
  82          * Access TBI PHY registers at given TSEC register offset as opposed
  83          * to the register offset used for external PHY accesses
  84          */
  85         tsec_local_mdio_write(priv->phyregs_sgmii, in_be32(&priv->regs->tbipa),
  86                         0, TBI_ANA, TBIANA_SETTINGS);
  87         tsec_local_mdio_write(priv->phyregs_sgmii, in_be32(&priv->regs->tbipa),
  88                         0, TBI_TBICON, TBICON_CLK_SELECT);
  89         tsec_local_mdio_write(priv->phyregs_sgmii, in_be32(&priv->regs->tbipa),
  90                         0, TBI_CR, CONFIG_TSEC_TBICR_SETTINGS);
  91 }
  92
  93 #ifdef CONFIG_MCAST_TFTP
  94
  95 /* CREDITS: linux gianfar driver, slightly adjusted... thanx. */
  96
  97 /* Set the appropriate hash bit for the given addr */
  98
  99 /*
 100  * The algorithm works like so:
 101  * 1) Take the Destination Address (ie the multicast address), and
 102  * do a CRC on it (little endian), and reverse the bits of the
 103  * result.
 104  * 2) Use the 8 most significant bits as a hash into a 256-entry
 105  * table.  The table is controlled through 8 32-bit registers:
 106  * gaddr0-7.  gaddr0's MSB is entry 0, and gaddr7's LSB is entry
 107  * 255.  This means that the 3 most significant bits in the
 108  * hash index which gaddr register to use, and the 5 other bits
 109  * indicate which bit (assuming an IBM numbering scheme, which
 110  * for PowerPC (tm) is usually the case) in the register holds
 111  * the entry.
 112  */
 113 static int tsec_mcast_addr(struct eth_device *dev, const u8 *mcast_mac, u8 set)
 114 {
 115         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 116         struct tsec __iomem *regs = priv->regs;
 117         u32 result, value;
 118         u8 whichbit, whichreg;
 119
 120         result = ether_crc(MAC_ADDR_LEN, mcast_mac);
 121         whichbit = (result >> 24) & 0x1f; /* the 5 LSB = which bit to set */
 122         whichreg = result >> 29; /* the 3 MSB = which reg to set it in */
 123
 124         value = 1 << (31-whichbit);
 125
 126         if (set)
 127                 setbits_be32(&regs->hash.gaddr0 + whichreg, value);
 128         else
 129                 clrbits_be32(&regs->hash.gaddr0 + whichreg, value);
 130
 131         return 0;
 132 }
 133 #endif /* Multicast TFTP ? */
 134
 135 /*
 136  * Initialized required registers to appropriate values, zeroing
 137  * those we don't care about (unless zero is bad, in which case,
 138  * choose a more appropriate value)
 139  */
 140 static void init_registers(struct tsec __iomem *regs)
 141 {
 142         /* Clear IEVENT */
 143         out_be32(&regs->ievent, IEVENT_INIT_CLEAR);
 144
 145         out_be32(&regs->imask, IMASK_INIT_CLEAR);
 146
 147         out_be32(&regs->hash.iaddr0, 0);
 148         out_be32(&regs->hash.iaddr1, 0);
 149         out_be32(&regs->hash.iaddr2, 0);
 150         out_be32(&regs->hash.iaddr3, 0);
 151         out_be32(&regs->hash.iaddr4, 0);
 152         out_be32(&regs->hash.iaddr5, 0);
 153         out_be32(&regs->hash.iaddr6, 0);
 154         out_be32(&regs->hash.iaddr7, 0);
 155
 156         out_be32(&regs->hash.gaddr0, 0);
 157         out_be32(&regs->hash.gaddr1, 0);
 158         out_be32(&regs->hash.gaddr2, 0);
 159         out_be32(&regs->hash.gaddr3, 0);
 160         out_be32(&regs->hash.gaddr4, 0);
 161         out_be32(&regs->hash.gaddr5, 0);
 162         out_be32(&regs->hash.gaddr6, 0);
 163         out_be32(&regs->hash.gaddr7, 0);
 164
 165         out_be32(&regs->rctrl, 0x00000000);
 166
 167         /* Init RMON mib registers */
 168         memset((void *)&regs->rmon, 0, sizeof(regs->rmon));
 169
 170         out_be32(&regs->rmon.cam1, 0xffffffff);
 171         out_be32(&regs->rmon.cam2, 0xffffffff);
 172
 173         out_be32(&regs->mrblr, MRBLR_INIT_SETTINGS);
 174
 175         out_be32(&regs->minflr, MINFLR_INIT_SETTINGS);
 176
 177         out_be32(&regs->attr, ATTR_INIT_SETTINGS);
 178         out_be32(&regs->attreli, ATTRELI_INIT_SETTINGS);
 179
 180 }
 181
 182 /*
 183  * Configure maccfg2 based on negotiated speed and duplex
 184  * reported by PHY handling code
 185  */
 186 static void adjust_link(struct tsec_private *priv, struct phy_device *phydev)
 187 {
 188         struct tsec __iomem *regs = priv->regs;
 189         u32 ecntrl, maccfg2;
 190
 191         if (!phydev->link) {
 192                 printf("%s: No link.\n", phydev->dev->name);
 193                 return;
 194         }
 195
 196         /* clear all bits relative with interface mode */
 197         ecntrl = in_be32(&regs->ecntrl);
 198         ecntrl &= ~ECNTRL_R100;
 199
 200         maccfg2 = in_be32(&regs->maccfg2);
 201         maccfg2 &= ~(MACCFG2_IF | MACCFG2_FULL_DUPLEX);
 202
 203         if (phydev->duplex)
 204                 maccfg2 |= MACCFG2_FULL_DUPLEX;
 205
 206         switch (phydev->speed) {
 207         case 1000:
 208                 maccfg2 |= MACCFG2_GMII;
 209                 break;
 210         case 100:
 211         case 10:
 212                 maccfg2 |= MACCFG2_MII;
 213
 214                 /*
 215                  * Set R100 bit in all modes although
 216                  * it is only used in RGMII mode
 217                  */
 218                 if (phydev->speed == 100)
 219                         ecntrl |= ECNTRL_R100;
 220                 break;
 221         default:
 222                 printf("%s: Speed was bad\n", phydev->dev->name);
 223                 break;
 224         }
 225
 226         out_be32(&regs->ecntrl, ecntrl);
 227         out_be32(&regs->maccfg2, maccfg2);
 228
 229         printf("Speed: %d, %s duplex%s\n", phydev->speed,
 230                         (phydev->duplex) ? "full" : "half",
 231                         (phydev->port == PORT_FIBRE) ? ", fiber mode" : "");
 232 }
 233
 234 #ifdef CONFIG_SYS_FSL_ERRATUM_NMG_ETSEC129
 235 /*
 236  * When MACCFG1[Rx_EN] is enabled during system boot as part
 237  * of the eTSEC port initialization sequence,
 238  * the eTSEC Rx logic may not be properly initialized.
 239  */
 240 void redundant_init(struct eth_device *dev)
 241 {
 242         struct tsec_private *priv = dev->priv;
 243         struct tsec __iomem *regs = priv->regs;
 244         uint t, count = 0;
 245         int fail = 1;
 246         static const u8 pkt[] = {
 247                 0x00, 0x1e, 0x4f, 0x12, 0xcb, 0x2c, 0x00, 0x25,
 248                 0x64, 0xbb, 0xd1, 0xab, 0x08, 0x00, 0x45, 0x00,
 249                 0x00, 0x5c, 0xdd, 0x22, 0x00, 0x00, 0x80, 0x01,
 250                 0x1f, 0x71, 0x0a, 0xc1, 0x14, 0x22, 0x0a, 0xc1,
 251                 0x14, 0x6a, 0x08, 0x00, 0xef, 0x7e, 0x02, 0x00,
 252                 0x94, 0x05, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
 253                 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
 254                 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
 255                 0x77, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 256                 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 257                 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 258                 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 259                 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
 260                 0x71, 0x72};
 261
 262         /* Enable promiscuous mode */
 263         setbits_be32(&regs->rctrl, 0x8);
 264         /* Enable loopback mode */
 265         setbits_be32(&regs->maccfg1, MACCFG1_LOOPBACK);
 266         /* Enable transmit and receive */
 267         setbits_be32(&regs->maccfg1, MACCFG1_RX_EN | MACCFG1_TX_EN);
 268
 269         /* Tell the DMA it is clear to go */
 270         setbits_be32(&regs->dmactrl, DMACTRL_INIT_SETTINGS);
 271         out_be32(&regs->tstat, TSTAT_CLEAR_THALT);
 272         out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 273         clrbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 274
 275         do {
 276                 uint16_t status;
 277                 tsec_send(dev, (void *)pkt, sizeof(pkt));
 278
 279                 /* Wait for buffer to be received */
 280                 for (t = 0; in_be16(&rxbd[priv->rx_idx].status) & RXBD_EMPTY;
 281                      t++) {
 282                         if (t >= 10 * TOUT_LOOP) {
 283                                 printf("%s: tsec: rx error\n", dev->name);
 284                                 break;
 285                         }
 286                 }
 287
 288                 if (!memcmp(pkt, net_rx_packets[priv->rx_idx], sizeof(pkt)))
 289                         fail = 0;
 290
 291                 out_be16(&rxbd[priv->rx_idx].length, 0);
 292                 status = RXBD_EMPTY;
 293                 if ((priv->rx_idx + 1) == PKTBUFSRX)
 294                         status |= RXBD_WRAP;
 295                 out_be16(&rxbd[priv->rx_idx].status, status);
 296                 priv->rx_idx = (priv->rx_idx + 1) % PKTBUFSRX;
 297
 298                 if (in_be32(&regs->ievent) & IEVENT_BSY) {
 299                         out_be32(&regs->ievent, IEVENT_BSY);
 300                         out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 301                 }
 302                 if (fail) {
 303                         printf("loopback recv packet error!\n");
 304                         clrbits_be32(&regs->maccfg1, MACCFG1_RX_EN);
 305                         udelay(1000);
 306                         setbits_be32(&regs->maccfg1, MACCFG1_RX_EN);
 307                 }
 308         } while ((count++ < 4) && (fail == 1));
 309
 310         if (fail)
 311                 panic("eTSEC init fail!\n");
 312         /* Disable promiscuous mode */
 313         clrbits_be32(&regs->rctrl, 0x8);
 314         /* Disable loopback mode */
 315         clrbits_be32(&regs->maccfg1, MACCFG1_LOOPBACK);
 316 }
 317 #endif
 318
 319 /*
 320  * Set up the buffers and their descriptors, and bring up the
 321  * interface
 322  */
 323 static void startup_tsec(struct eth_device *dev)
 324 {
 325         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 326         struct tsec __iomem *regs = priv->regs;
 327         uint16_t status;
 328         int i;
 329
 330         /* reset the indices to zero */
 331         priv->rx_idx = 0;
 332         priv->tx_idx = 0;
 333 #ifdef CONFIG_SYS_FSL_ERRATUM_NMG_ETSEC129
 334         uint svr;
 335 #endif
 336
 337         /* Point to the buffer descriptors */
 338         out_be32(&regs->tbase, (u32)&txbd[0]);
 339         out_be32(&regs->rbase, (u32)&rxbd[0]);
 340
 341         /* Initialize the Rx Buffer descriptors */
 342         for (i = 0; i < PKTBUFSRX; i++) {
 343                 out_be16(&rxbd[i].status, RXBD_EMPTY);
 344                 out_be16(&rxbd[i].length, 0);
 345                 out_be32(&rxbd[i].bufptr, (u32)net_rx_packets[i]);
 346         }
 347         status = in_be16(&rxbd[PKTBUFSRX - 1].status);
 348         out_be16(&rxbd[PKTBUFSRX - 1].status, status | RXBD_WRAP);
 349
 350         /* Initialize the TX Buffer Descriptors */
 351         for (i = 0; i < TX_BUF_CNT; i++) {
 352                 out_be16(&txbd[i].status, 0);
 353                 out_be16(&txbd[i].length, 0);
 354                 out_be32(&txbd[i].bufptr, 0);
 355         }
 356         status = in_be16(&txbd[TX_BUF_CNT - 1].status);
 357         out_be16(&txbd[TX_BUF_CNT - 1].status, status | TXBD_WRAP);
 358
 359 #ifdef CONFIG_SYS_FSL_ERRATUM_NMG_ETSEC129
 360         svr = get_svr();
 361         if ((SVR_MAJ(svr) == 1) || IS_SVR_REV(svr, 2, 0))
 362                 redundant_init(dev);
 363 #endif
 364         /* Enable Transmit and Receive */
 365         setbits_be32(&regs->maccfg1, MACCFG1_RX_EN | MACCFG1_TX_EN);
 366
 367         /* Tell the DMA it is clear to go */
 368         setbits_be32(&regs->dmactrl, DMACTRL_INIT_SETTINGS);
 369         out_be32(&regs->tstat, TSTAT_CLEAR_THALT);
 370         out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 371         clrbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 372 }
 373
 374 /*
 375  * This returns the status bits of the device. The return value
 376  * is never checked, and this is what the 8260 driver did, so we
 377  * do the same. Presumably, this would be zero if there were no
 378  * errors
 379  */
 380 static int tsec_send(struct eth_device *dev, void *packet, int length)
 381 {
 382         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 383         struct tsec __iomem *regs = priv->regs;
 384         uint16_t status;
 385         int result = 0;
 386         int i;
 387
 388         /* Find an empty buffer descriptor */
 389         for (i = 0; in_be16(&txbd[priv->tx_idx].status) & TXBD_READY; i++) {
 390                 if (i >= TOUT_LOOP) {
 391                         debug("%s: tsec: tx buffers full\n", dev->name);
 392                         return result;
 393                 }
 394         }
 395
 396         out_be32(&txbd[priv->tx_idx].bufptr, (u32)packet);
 397         out_be16(&txbd[priv->tx_idx].length, length);
 398         status = in_be16(&txbd[priv->tx_idx].status);
 399         out_be16(&txbd[priv->tx_idx].status, status |
 400                 (TXBD_READY | TXBD_LAST | TXBD_CRC | TXBD_INTERRUPT));
 401
 402         /* Tell the DMA to go */
 403         out_be32(&regs->tstat, TSTAT_CLEAR_THALT);
 404
 405         /* Wait for buffer to be transmitted */
 406         for (i = 0; in_be16(&txbd[priv->tx_idx].status) & TXBD_READY; i++) {
 407                 if (i >= TOUT_LOOP) {
 408                         debug("%s: tsec: tx error\n", dev->name);
 409                         return result;
 410                 }
 411         }
 412
 413         priv->tx_idx = (priv->tx_idx + 1) % TX_BUF_CNT;
 414         result = in_be16(&txbd[priv->tx_idx].status) & TXBD_STATS;
 415
 416         return result;
 417 }
 418
 419 static int tsec_recv(struct eth_device *dev)
 420 {
 421         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 422         struct tsec __iomem *regs = priv->regs;
 423
 424         while (!(in_be16(&rxbd[priv->rx_idx].status) & RXBD_EMPTY)) {
 425                 int length = in_be16(&rxbd[priv->rx_idx].length);
 426                 uint16_t status = in_be16(&rxbd[priv->rx_idx].status);
 427                 uchar *packet = net_rx_packets[priv->rx_idx];
 428
 429                 /* Send the packet up if there were no errors */
 430                 if (!(status & RXBD_STATS))
 431                         net_process_received_packet(packet, length - 4);
 432                 else
 433                         printf("Got error %x\n", (status & RXBD_STATS));
 434
 435                 out_be16(&rxbd[priv->rx_idx].length, 0);
 436
 437                 status = RXBD_EMPTY;
 438                 /* Set the wrap bit if this is the last element in the list */
 439                 if ((priv->rx_idx + 1) == PKTBUFSRX)
 440                         status |= RXBD_WRAP;
 441                 out_be16(&rxbd[priv->rx_idx].status, status);
 442
 443                 priv->rx_idx = (priv->rx_idx + 1) % PKTBUFSRX;
 444         }
 445
 446         if (in_be32(&regs->ievent) & IEVENT_BSY) {
 447                 out_be32(&regs->ievent, IEVENT_BSY);
 448                 out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 449         }
 450
 451         return -1;
 452 }
 453
 454 /* Stop the interface */
 455 static void tsec_halt(struct eth_device *dev)
 456 {
 457         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 458         struct tsec __iomem *regs = priv->regs;
 459
 460         clrbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 461         setbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 462
 463         while ((in_be32(&regs->ievent) & (IEVENT_GRSC | IEVENT_GTSC))
 464                         != (IEVENT_GRSC | IEVENT_GTSC))
 465                 ;
 466
 467         clrbits_be32(&regs->maccfg1, MACCFG1_TX_EN | MACCFG1_RX_EN);
 468
 469         /* Shut down the PHY, as needed */
 470         phy_shutdown(priv->phydev);
 471 }
 472
 473 /*
 474  * Initializes data structures and registers for the controller,
 475  * and brings the interface up. Returns the link status, meaning
 476  * that it returns success if the link is up, failure otherwise.
 477  * This allows U-Boot to find the first active controller.
 478  */
 479 static int tsec_init(struct eth_device *dev, bd_t * bd)
 480 {
 481         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 482         struct tsec __iomem *regs = priv->regs;
 483         u32 tempval;
 484         int ret;
 485
 486         /* Make sure the controller is stopped */
 487         tsec_halt(dev);
 488
 489         /* Init MACCFG2.  Defaults to GMII */
 490         out_be32(&regs->maccfg2, MACCFG2_INIT_SETTINGS);
 491
 492         /* Init ECNTRL */
 493         out_be32(&regs->ecntrl, ECNTRL_INIT_SETTINGS);
 494
 495         /*
 496          * Copy the station address into the address registers.
 497          * For a station address of 0x12345678ABCD in transmission
 498          * order (BE), MACnADDR1 is set to 0xCDAB7856 and
 499          * MACnADDR2 is set to 0x34120000.
 500          */
 501         tempval = (dev->enetaddr[5] << 24) | (dev->enetaddr[4] << 16) |
 502                   (dev->enetaddr[3] << 8)  |  dev->enetaddr[2];
 503
 504         out_be32(&regs->macstnaddr1, tempval);
 505
 506         tempval = (dev->enetaddr[1] << 24) | (dev->enetaddr[0] << 16);
 507
 508         out_be32(&regs->macstnaddr2, tempval);
 509
 510         /* Clear out (for the most part) the other registers */
 511         init_registers(regs);
 512
 513         /* Ready the device for tx/rx */
 514         startup_tsec(dev);
 515
 516         /* Start up the PHY */
 517         ret = phy_startup(priv->phydev);
 518         if (ret) {
 519                 printf("Could not initialize PHY %s\n",
 520                        priv->phydev->dev->name);
 521                 return ret;
 522         }
 523
 524         adjust_link(priv, priv->phydev);
 525
 526         /* If there's no link, fail */
 527         return priv->phydev->link ? 0 : -1;
 528 }
 529
 530 static phy_interface_t tsec_get_interface(struct tsec_private *priv)
 531 {
 532         struct tsec __iomem *regs = priv->regs;
 533         u32 ecntrl;
 534
 535         ecntrl = in_be32(&regs->ecntrl);
 536
 537         if (ecntrl & ECNTRL_SGMII_MODE)
 538                 return PHY_INTERFACE_MODE_SGMII;
 539
 540         if (ecntrl & ECNTRL_TBI_MODE) {
 541                 if (ecntrl & ECNTRL_REDUCED_MODE)
 542                         return PHY_INTERFACE_MODE_RTBI;
 543                 else
 544                         return PHY_INTERFACE_MODE_TBI;
 545         }
 546
 547         if (ecntrl & ECNTRL_REDUCED_MODE) {
 548                 if (ecntrl & ECNTRL_REDUCED_MII_MODE)
 549                         return PHY_INTERFACE_MODE_RMII;
 550                 else {
 551                         phy_interface_t interface = priv->interface;
 552
 553                         /*
 554                          * This isn't autodetected, so it must
 555                          * be set by the platform code.
 556                          */
 557                         if ((interface == PHY_INTERFACE_MODE_RGMII_ID) ||
 558                             (interface == PHY_INTERFACE_MODE_RGMII_TXID) ||
 559                             (interface == PHY_INTERFACE_MODE_RGMII_RXID))
 560                                 return interface;
 561
 562                         return PHY_INTERFACE_MODE_RGMII;
 563                 }
 564         }
 565
 566         if (priv->flags & TSEC_GIGABIT)
 567                 return PHY_INTERFACE_MODE_GMII;
 568
 569         return PHY_INTERFACE_MODE_MII;
 570 }
 571
 572 /*
 573  * Discover which PHY is attached to the device, and configure it
 574  * properly.  If the PHY is not recognized, then return 0
 575  * (failure).  Otherwise, return 1
 576  */
 577 static int init_phy(struct eth_device *dev)
 578 {
 579         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 580         struct phy_device *phydev;
 581         struct tsec __iomem *regs = priv->regs;
 582         u32 supported = (SUPPORTED_10baseT_Half |
 583                         SUPPORTED_10baseT_Full |
 584                         SUPPORTED_100baseT_Half |
 585                         SUPPORTED_100baseT_Full);
 586
 587         if (priv->flags & TSEC_GIGABIT)
 588                 supported |= SUPPORTED_1000baseT_Full;
 589
 590         /* Assign a Physical address to the TBI */
 591         out_be32(&regs->tbipa, CONFIG_SYS_TBIPA_VALUE);
 592
 593         priv->interface = tsec_get_interface(priv);
 594
 595         if (priv->interface == PHY_INTERFACE_MODE_SGMII)
 596                 tsec_configure_serdes(priv);
 597
 598         phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface);
 599         if (!phydev)
 600                 return 0;
 601
 602         phydev->supported &= supported;
 603         phydev->advertising = phydev->supported;
 604
 605         priv->phydev = phydev;
 606
 607         phy_config(phydev);
 608
 609         return 1;
 610 }
 611
 612 /*
 613  * Initialize device structure. Returns success if PHY
 614  * initialization succeeded (i.e. if it recognizes the PHY)
 615  */
 616 static int tsec_initialize(bd_t *bis, struct tsec_info_struct *tsec_info)
 617 {
 618         struct eth_device *dev;
 619         int i;
 620         struct tsec_private *priv;
 621
 622         dev = (struct eth_device *)malloc(sizeof *dev);
 623
 624         if (NULL == dev)
 625                 return 0;
 626
 627         memset(dev, 0, sizeof *dev);
 628
 629         priv = (struct tsec_private *)malloc(sizeof(*priv));
 630
 631         if (NULL == priv)
 632                 return 0;
 633
 634         priv->regs = tsec_info->regs;
 635         priv->phyregs_sgmii = tsec_info->miiregs_sgmii;
 636
 637         priv->phyaddr = tsec_info->phyaddr;
 638         priv->flags = tsec_info->flags;
 639
 640         sprintf(dev->name, tsec_info->devname);
 641         priv->interface = tsec_info->interface;
 642         priv->bus = miiphy_get_dev_by_name(tsec_info->mii_devname);
 643         dev->iobase = 0;
 644         dev->priv = priv;
 645         dev->init = tsec_init;
 646         dev->halt = tsec_halt;
 647         dev->send = tsec_send;
 648         dev->recv = tsec_recv;
 649 #ifdef CONFIG_MCAST_TFTP
 650         dev->mcast = tsec_mcast_addr;
 651 #endif
 652
 653         /* Tell U-Boot to get the addr from the env */
 654         for (i = 0; i < 6; i++)
 655                 dev->enetaddr[i] = 0;
 656
 657         eth_register(dev);
 658
 659         /* Reset the MAC */
 660         setbits_be32(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
 661         udelay(2);  /* Soft Reset must be asserted for 3 TX clocks */
 662         clrbits_be32(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
 663
 664         /* Try to initialize PHY here, and return */
 665         return init_phy(dev);
 666 }
 667
 668 /*
 669  * Initialize all the TSEC devices
 670  *
 671  * Returns the number of TSEC devices that were initialized
 672  */
 673 int tsec_eth_init(bd_t *bis, struct tsec_info_struct *tsecs, int num)
 674 {
 675         int i;
 676         int ret, count = 0;
 677
 678         for (i = 0; i < num; i++) {
 679                 ret = tsec_initialize(bis, &tsecs[i]);
 680                 if (ret > 0)
 681                         count += ret;
 682         }
 683
 684         return count;
 685 }
 686
 687 int tsec_standard_init(bd_t *bis)
 688 {
 689         struct fsl_pq_mdio_info info;
 690
 691         info.regs = TSEC_GET_MDIO_REGS_BASE(1);
 692         info.name = DEFAULT_MII_NAME;
 693
 694         fsl_pq_mdio_init(bis, &info);
 695
 696         return tsec_eth_init(bis, tsec_info, ARRAY_SIZE(tsec_info));
 697 }