drivers/net/tsec.c

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