drivers/net/tsec.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Freescale Three Speed Ethernet Controller driver
   4  *
   5  * Copyright 2004-2011, 2013 Freescale Semiconductor, Inc.
   6  * (C) Copyright 2003, Motorola, Inc.
   7  * author Andy Fleming
   8  */
   9
  10 #include <config.h>
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <malloc.h>
  14 #include <net.h>
  15 #include <command.h>
  16 #include <tsec.h>
  17 #include <fsl_mdio.h>
  18 #include <linux/bitops.h>
  19 #include <linux/delay.h>
  20 #include <linux/errno.h>
  21 #include <miiphy.h>
  22 #include <asm/processor.h>
  23 #include <asm/io.h>
  24
  25 #ifndef CONFIG_DM_ETH
  26 /* Default initializations for TSEC controllers. */
  27
  28 static struct tsec_info_struct tsec_info[] = {
  29 #ifdef CONFIG_TSEC1
  30         STD_TSEC_INFO(1),       /* TSEC1 */
  31 #endif
  32 #ifdef CONFIG_TSEC2
  33         STD_TSEC_INFO(2),       /* TSEC2 */
  34 #endif
  35 #ifdef CONFIG_MPC85XX_FEC
  36         {
  37                 .regs = TSEC_GET_REGS(2, 0x2000),
  38                 .devname = CONFIG_MPC85XX_FEC_NAME,
  39                 .phyaddr = FEC_PHY_ADDR,
  40                 .flags = FEC_FLAGS,
  41                 .mii_devname = DEFAULT_MII_NAME
  42         },                      /* FEC */
  43 #endif
  44 #ifdef CONFIG_TSEC3
  45         STD_TSEC_INFO(3),       /* TSEC3 */
  46 #endif
  47 #ifdef CONFIG_TSEC4
  48         STD_TSEC_INFO(4),       /* TSEC4 */
  49 #endif
  50 };
  51 #endif /* CONFIG_DM_ETH */
  52
  53 #define TBIANA_SETTINGS ( \
  54                 TBIANA_ASYMMETRIC_PAUSE \
  55                 | TBIANA_SYMMETRIC_PAUSE \
  56                 | TBIANA_FULL_DUPLEX \
  57                 )
  58
  59 /* By default force the TBI PHY into 1000Mbps full duplex when in SGMII mode */
  60 #ifndef CONFIG_TSEC_TBICR_SETTINGS
  61 #define CONFIG_TSEC_TBICR_SETTINGS ( \
  62                 TBICR_PHY_RESET \
  63                 | TBICR_ANEG_ENABLE \
  64                 | TBICR_FULL_DUPLEX \
  65                 | TBICR_SPEED1_SET \
  66                 )
  67 #endif /* CONFIG_TSEC_TBICR_SETTINGS */
  68
  69 /* Configure the TBI for SGMII operation */
  70 static void tsec_configure_serdes(struct tsec_private *priv)
  71 {
  72         /*
  73          * Access TBI PHY registers at given TSEC register offset as opposed
  74          * to the register offset used for external PHY accesses
  75          */
  76         tsec_local_mdio_write(priv->phyregs_sgmii, in_be32(&priv->regs->tbipa),
  77                               0, TBI_ANA, TBIANA_SETTINGS);
  78         tsec_local_mdio_write(priv->phyregs_sgmii, in_be32(&priv->regs->tbipa),
  79                               0, TBI_TBICON, TBICON_CLK_SELECT);
  80         tsec_local_mdio_write(priv->phyregs_sgmii, in_be32(&priv->regs->tbipa),
  81                               0, TBI_CR, CONFIG_TSEC_TBICR_SETTINGS);
  82 }
  83
  84 /* the 'way' for ethernet-CRC-32. Spliced in from Linux lib/crc32.c
  85  * and this is the ethernet-crc method needed for TSEC -- and perhaps
  86  * some other adapter -- hash tables
  87  */
  88 #define CRCPOLY_LE 0xedb88320
  89 static u32 ether_crc(size_t len, unsigned char const *p)
  90 {
  91         int i;
  92         u32 crc;
  93
  94         crc = ~0;
  95         while (len--) {
  96                 crc ^= *p++;
  97                 for (i = 0; i < 8; i++)
  98                         crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
  99         }
 100         /* an reverse the bits, cuz of way they arrive -- last-first */
 101         crc = (crc >> 16) | (crc << 16);
 102         crc = (crc >> 8 & 0x00ff00ff) | (crc << 8 & 0xff00ff00);
 103         crc = (crc >> 4 & 0x0f0f0f0f) | (crc << 4 & 0xf0f0f0f0);
 104         crc = (crc >> 2 & 0x33333333) | (crc << 2 & 0xcccccccc);
 105         crc = (crc >> 1 & 0x55555555) | (crc << 1 & 0xaaaaaaaa);
 106         return crc;
 107 }
 108
 109 /* CREDITS: linux gianfar driver, slightly adjusted... thanx. */
 110
 111 /* Set the appropriate hash bit for the given addr */
 112
 113 /*
 114  * The algorithm works like so:
 115  * 1) Take the Destination Address (ie the multicast address), and
 116  * do a CRC on it (little endian), and reverse the bits of the
 117  * result.
 118  * 2) Use the 8 most significant bits as a hash into a 256-entry
 119  * table.  The table is controlled through 8 32-bit registers:
 120  * gaddr0-7.  gaddr0's MSB is entry 0, and gaddr7's LSB is entry
 121  * 255.  This means that the 3 most significant bits in the
 122  * hash index which gaddr register to use, and the 5 other bits
 123  * indicate which bit (assuming an IBM numbering scheme, which
 124  * for PowerPC (tm) is usually the case) in the register holds
 125  * the entry.
 126  */
 127 #ifndef CONFIG_DM_ETH
 128 static int tsec_mcast_addr(struct eth_device *dev, const u8 *mcast_mac,
 129                            int join)
 130 #else
 131 static int tsec_mcast_addr(struct udevice *dev, const u8 *mcast_mac, int join)
 132 #endif
 133 {
 134         struct tsec_private *priv;
 135         struct tsec __iomem *regs;
 136         u32 result, value;
 137         u8 whichbit, whichreg;
 138
 139 #ifndef CONFIG_DM_ETH
 140         priv = (struct tsec_private *)dev->priv;
 141 #else
 142         priv = dev_get_priv(dev);
 143 #endif
 144         regs = priv->regs;
 145         result = ether_crc(MAC_ADDR_LEN, mcast_mac);
 146         whichbit = (result >> 24) & 0x1f; /* the 5 LSB = which bit to set */
 147         whichreg = result >> 29; /* the 3 MSB = which reg to set it in */
 148
 149         value = BIT(31 - whichbit);
 150
 151         if (join)
 152                 setbits_be32(&regs->hash.gaddr0 + whichreg, value);
 153         else
 154                 clrbits_be32(&regs->hash.gaddr0 + whichreg, value);
 155
 156         return 0;
 157 }
 158
 159 static int __maybe_unused tsec_set_promisc(struct udevice *dev, bool enable)
 160 {
 161         struct tsec_private *priv = dev_get_priv(dev);
 162         struct tsec __iomem *regs = priv->regs;
 163
 164         if (enable)
 165                 setbits_be32(&regs->rctrl, RCTRL_PROM);
 166         else
 167                 clrbits_be32(&regs->rctrl, RCTRL_PROM);
 168
 169         return 0;
 170 }
 171
 172 /*
 173  * Initialized required registers to appropriate values, zeroing
 174  * those we don't care about (unless zero is bad, in which case,
 175  * choose a more appropriate value)
 176  */
 177 static void init_registers(struct tsec __iomem *regs)
 178 {
 179         /* Clear IEVENT */
 180         out_be32(&regs->ievent, IEVENT_INIT_CLEAR);
 181
 182         out_be32(&regs->imask, IMASK_INIT_CLEAR);
 183
 184         out_be32(&regs->hash.iaddr0, 0);
 185         out_be32(&regs->hash.iaddr1, 0);
 186         out_be32(&regs->hash.iaddr2, 0);
 187         out_be32(&regs->hash.iaddr3, 0);
 188         out_be32(&regs->hash.iaddr4, 0);
 189         out_be32(&regs->hash.iaddr5, 0);
 190         out_be32(&regs->hash.iaddr6, 0);
 191         out_be32(&regs->hash.iaddr7, 0);
 192
 193         out_be32(&regs->hash.gaddr0, 0);
 194         out_be32(&regs->hash.gaddr1, 0);
 195         out_be32(&regs->hash.gaddr2, 0);
 196         out_be32(&regs->hash.gaddr3, 0);
 197         out_be32(&regs->hash.gaddr4, 0);
 198         out_be32(&regs->hash.gaddr5, 0);
 199         out_be32(&regs->hash.gaddr6, 0);
 200         out_be32(&regs->hash.gaddr7, 0);
 201
 202         /* Init RMON mib registers */
 203         memset((void *)&regs->rmon, 0, sizeof(regs->rmon));
 204
 205         out_be32(&regs->rmon.cam1, 0xffffffff);
 206         out_be32(&regs->rmon.cam2, 0xffffffff);
 207
 208         out_be32(&regs->mrblr, MRBLR_INIT_SETTINGS);
 209
 210         out_be32(&regs->minflr, MINFLR_INIT_SETTINGS);
 211
 212         out_be32(&regs->attr, ATTR_INIT_SETTINGS);
 213         out_be32(&regs->attreli, ATTRELI_INIT_SETTINGS);
 214 }
 215
 216 /*
 217  * Configure maccfg2 based on negotiated speed and duplex
 218  * reported by PHY handling code
 219  */
 220 static void adjust_link(struct tsec_private *priv, struct phy_device *phydev)
 221 {
 222         struct tsec __iomem *regs = priv->regs;
 223         u32 ecntrl, maccfg2;
 224
 225         if (!phydev->link) {
 226                 printf("%s: No link.\n", phydev->dev->name);
 227                 return;
 228         }
 229
 230         /* clear all bits relative with interface mode */
 231         ecntrl = in_be32(&regs->ecntrl);
 232         ecntrl &= ~ECNTRL_R100;
 233
 234         maccfg2 = in_be32(&regs->maccfg2);
 235         maccfg2 &= ~(MACCFG2_IF | MACCFG2_FULL_DUPLEX);
 236
 237         if (phydev->duplex)
 238                 maccfg2 |= MACCFG2_FULL_DUPLEX;
 239
 240         switch (phydev->speed) {
 241         case 1000:
 242                 maccfg2 |= MACCFG2_GMII;
 243                 break;
 244         case 100:
 245         case 10:
 246                 maccfg2 |= MACCFG2_MII;
 247
 248                 /*
 249                  * Set R100 bit in all modes although
 250                  * it is only used in RGMII mode
 251                  */
 252                 if (phydev->speed == 100)
 253                         ecntrl |= ECNTRL_R100;
 254                 break;
 255         default:
 256                 printf("%s: Speed was bad\n", phydev->dev->name);
 257                 break;
 258         }
 259
 260         out_be32(&regs->ecntrl, ecntrl);
 261         out_be32(&regs->maccfg2, maccfg2);
 262
 263         printf("Speed: %d, %s duplex%s\n", phydev->speed,
 264                (phydev->duplex) ? "full" : "half",
 265                (phydev->port == PORT_FIBRE) ? ", fiber mode" : "");
 266 }
 267
 268 /*
 269  * This returns the status bits of the device. The return value
 270  * is never checked, and this is what the 8260 driver did, so we
 271  * do the same. Presumably, this would be zero if there were no
 272  * errors
 273  */
 274 #ifndef CONFIG_DM_ETH
 275 static int tsec_send(struct eth_device *dev, void *packet, int length)
 276 #else
 277 static int tsec_send(struct udevice *dev, void *packet, int length)
 278 #endif
 279 {
 280         struct tsec_private *priv;
 281         struct tsec __iomem *regs;
 282         int result = 0;
 283         u16 status;
 284         int i;
 285
 286 #ifndef CONFIG_DM_ETH
 287         priv = (struct tsec_private *)dev->priv;
 288 #else
 289         priv = dev_get_priv(dev);
 290 #endif
 291         regs = priv->regs;
 292         /* Find an empty buffer descriptor */
 293         for (i = 0;
 294              in_be16(&priv->txbd[priv->tx_idx].status) & TXBD_READY;
 295              i++) {
 296                 if (i >= TOUT_LOOP) {
 297                         printf("%s: tsec: tx buffers full\n", dev->name);
 298                         return result;
 299                 }
 300         }
 301
 302         out_be32(&priv->txbd[priv->tx_idx].bufptr, (u32)packet);
 303         out_be16(&priv->txbd[priv->tx_idx].length, length);
 304         status = in_be16(&priv->txbd[priv->tx_idx].status);
 305         out_be16(&priv->txbd[priv->tx_idx].status, status |
 306                 (TXBD_READY | TXBD_LAST | TXBD_CRC | TXBD_INTERRUPT));
 307
 308         /* Tell the DMA to go */
 309         out_be32(&regs->tstat, TSTAT_CLEAR_THALT);
 310
 311         /* Wait for buffer to be transmitted */
 312         for (i = 0;
 313              in_be16(&priv->txbd[priv->tx_idx].status) & TXBD_READY;
 314              i++) {
 315                 if (i >= TOUT_LOOP) {
 316                         printf("%s: tsec: tx error\n", dev->name);
 317                         return result;
 318                 }
 319         }
 320
 321         priv->tx_idx = (priv->tx_idx + 1) % TX_BUF_CNT;
 322         result = in_be16(&priv->txbd[priv->tx_idx].status) & TXBD_STATS;
 323
 324         return result;
 325 }
 326
 327 #ifndef CONFIG_DM_ETH
 328 static int tsec_recv(struct eth_device *dev)
 329 {
 330         struct tsec_private *priv = (struct tsec_private *)dev->priv;
 331         struct tsec __iomem *regs = priv->regs;
 332
 333         while (!(in_be16(&priv->rxbd[priv->rx_idx].status) & RXBD_EMPTY)) {
 334                 int length = in_be16(&priv->rxbd[priv->rx_idx].length);
 335                 u16 status = in_be16(&priv->rxbd[priv->rx_idx].status);
 336                 uchar *packet = net_rx_packets[priv->rx_idx];
 337
 338                 /* Send the packet up if there were no errors */
 339                 if (!(status & RXBD_STATS))
 340                         net_process_received_packet(packet, length - 4);
 341                 else
 342                         printf("Got error %x\n", (status & RXBD_STATS));
 343
 344                 out_be16(&priv->rxbd[priv->rx_idx].length, 0);
 345
 346                 status = RXBD_EMPTY;
 347                 /* Set the wrap bit if this is the last element in the list */
 348                 if ((priv->rx_idx + 1) == PKTBUFSRX)
 349                         status |= RXBD_WRAP;
 350                 out_be16(&priv->rxbd[priv->rx_idx].status, status);
 351
 352                 priv->rx_idx = (priv->rx_idx + 1) % PKTBUFSRX;
 353         }
 354
 355         if (in_be32(&regs->ievent) & IEVENT_BSY) {
 356                 out_be32(&regs->ievent, IEVENT_BSY);
 357                 out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 358         }
 359
 360         return -1;
 361 }
 362 #else
 363 static int tsec_recv(struct udevice *dev, int flags, uchar **packetp)
 364 {
 365         struct tsec_private *priv = (struct tsec_private *)dev_get_priv(dev);
 366         struct tsec __iomem *regs = priv->regs;
 367         int ret = -1;
 368
 369         if (!(in_be16(&priv->rxbd[priv->rx_idx].status) & RXBD_EMPTY)) {
 370                 int length = in_be16(&priv->rxbd[priv->rx_idx].length);
 371                 u16 status = in_be16(&priv->rxbd[priv->rx_idx].status);
 372                 u32 buf;
 373
 374                 /* Send the packet up if there were no errors */
 375                 if (!(status & RXBD_STATS)) {
 376                         buf = in_be32(&priv->rxbd[priv->rx_idx].bufptr);
 377                         *packetp = (uchar *)buf;
 378                         ret = length - 4;
 379                 } else {
 380                         printf("Got error %x\n", (status & RXBD_STATS));
 381                 }
 382         }
 383
 384         if (in_be32(&regs->ievent) & IEVENT_BSY) {
 385                 out_be32(&regs->ievent, IEVENT_BSY);
 386                 out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 387         }
 388
 389         return ret;
 390 }
 391
 392 static int tsec_free_pkt(struct udevice *dev, uchar *packet, int length)
 393 {
 394         struct tsec_private *priv = (struct tsec_private *)dev_get_priv(dev);
 395         u16 status;
 396
 397         out_be16(&priv->rxbd[priv->rx_idx].length, 0);
 398
 399         status = RXBD_EMPTY;
 400         /* Set the wrap bit if this is the last element in the list */
 401         if ((priv->rx_idx + 1) == PKTBUFSRX)
 402                 status |= RXBD_WRAP;
 403         out_be16(&priv->rxbd[priv->rx_idx].status, status);
 404
 405         priv->rx_idx = (priv->rx_idx + 1) % PKTBUFSRX;
 406
 407         return 0;
 408 }
 409 #endif
 410
 411 /* Stop the interface */
 412 #ifndef CONFIG_DM_ETH
 413 static void tsec_halt(struct eth_device *dev)
 414 #else
 415 static void tsec_halt(struct udevice *dev)
 416 #endif
 417 {
 418         struct tsec_private *priv;
 419         struct tsec __iomem *regs;
 420 #ifndef CONFIG_DM_ETH
 421         priv = (struct tsec_private *)dev->priv;
 422 #else
 423         priv = dev_get_priv(dev);
 424 #endif
 425         regs = priv->regs;
 426
 427         clrbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 428         setbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 429
 430         while ((in_be32(&regs->ievent) & (IEVENT_GRSC | IEVENT_GTSC))
 431                         != (IEVENT_GRSC | IEVENT_GTSC))
 432                 ;
 433
 434         clrbits_be32(&regs->maccfg1, MACCFG1_TX_EN | MACCFG1_RX_EN);
 435
 436         /* Shut down the PHY, as needed */
 437         phy_shutdown(priv->phydev);
 438 }
 439
 440 #ifdef CONFIG_SYS_FSL_ERRATUM_NMG_ETSEC129
 441 /*
 442  * When MACCFG1[Rx_EN] is enabled during system boot as part
 443  * of the eTSEC port initialization sequence,
 444  * the eTSEC Rx logic may not be properly initialized.
 445  */
 446 static void redundant_init(struct tsec_private *priv)
 447 {
 448         struct tsec __iomem *regs = priv->regs;
 449         uint t, count = 0;
 450         int fail = 1;
 451         static const u8 pkt[] = {
 452                 0x00, 0x1e, 0x4f, 0x12, 0xcb, 0x2c, 0x00, 0x25,
 453                 0x64, 0xbb, 0xd1, 0xab, 0x08, 0x00, 0x45, 0x00,
 454                 0x00, 0x5c, 0xdd, 0x22, 0x00, 0x00, 0x80, 0x01,
 455                 0x1f, 0x71, 0x0a, 0xc1, 0x14, 0x22, 0x0a, 0xc1,
 456                 0x14, 0x6a, 0x08, 0x00, 0xef, 0x7e, 0x02, 0x00,
 457                 0x94, 0x05, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
 458                 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
 459                 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
 460                 0x77, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 461                 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 462                 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 463                 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 464                 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
 465                 0x71, 0x72};
 466
 467         /* Enable promiscuous mode */
 468         setbits_be32(&regs->rctrl, RCTRL_PROM);
 469         /* Enable loopback mode */
 470         setbits_be32(&regs->maccfg1, MACCFG1_LOOPBACK);
 471         /* Enable transmit and receive */
 472         setbits_be32(&regs->maccfg1, MACCFG1_RX_EN | MACCFG1_TX_EN);
 473
 474         /* Tell the DMA it is clear to go */
 475         setbits_be32(&regs->dmactrl, DMACTRL_INIT_SETTINGS);
 476         out_be32(&regs->tstat, TSTAT_CLEAR_THALT);
 477         out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 478         clrbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 479
 480         do {
 481                 u16 status;
 482
 483                 tsec_send(priv->dev, (void *)pkt, sizeof(pkt));
 484
 485                 /* Wait for buffer to be received */
 486                 for (t = 0;
 487                      in_be16(&priv->rxbd[priv->rx_idx].status) & RXBD_EMPTY;
 488                      t++) {
 489                         if (t >= 10 * TOUT_LOOP) {
 490                                 printf("%s: tsec: rx error\n", priv->dev->name);
 491                                 break;
 492                         }
 493                 }
 494
 495                 if (!memcmp(pkt, net_rx_packets[priv->rx_idx], sizeof(pkt)))
 496                         fail = 0;
 497
 498                 out_be16(&priv->rxbd[priv->rx_idx].length, 0);
 499                 status = RXBD_EMPTY;
 500                 if ((priv->rx_idx + 1) == PKTBUFSRX)
 501                         status |= RXBD_WRAP;
 502                 out_be16(&priv->rxbd[priv->rx_idx].status, status);
 503                 priv->rx_idx = (priv->rx_idx + 1) % PKTBUFSRX;
 504
 505                 if (in_be32(&regs->ievent) & IEVENT_BSY) {
 506                         out_be32(&regs->ievent, IEVENT_BSY);
 507                         out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 508                 }
 509                 if (fail) {
 510                         printf("loopback recv packet error!\n");
 511                         clrbits_be32(&regs->maccfg1, MACCFG1_RX_EN);
 512                         udelay(1000);
 513                         setbits_be32(&regs->maccfg1, MACCFG1_RX_EN);
 514                 }
 515         } while ((count++ < 4) && (fail == 1));
 516
 517         if (fail)
 518                 panic("eTSEC init fail!\n");
 519         /* Disable promiscuous mode */
 520         clrbits_be32(&regs->rctrl, RCTRL_PROM);
 521         /* Disable loopback mode */
 522         clrbits_be32(&regs->maccfg1, MACCFG1_LOOPBACK);
 523 }
 524 #endif
 525
 526 /*
 527  * Set up the buffers and their descriptors, and bring up the
 528  * interface
 529  */
 530 static void startup_tsec(struct tsec_private *priv)
 531 {
 532         struct tsec __iomem *regs = priv->regs;
 533         u16 status;
 534         int i;
 535
 536         /* reset the indices to zero */
 537         priv->rx_idx = 0;
 538         priv->tx_idx = 0;
 539 #ifdef CONFIG_SYS_FSL_ERRATUM_NMG_ETSEC129
 540         uint svr;
 541 #endif
 542
 543         /* Point to the buffer descriptors */
 544         out_be32(&regs->tbase, (u32)&priv->txbd[0]);
 545         out_be32(&regs->rbase, (u32)&priv->rxbd[0]);
 546
 547         /* Initialize the Rx Buffer descriptors */
 548         for (i = 0; i < PKTBUFSRX; i++) {
 549                 out_be16(&priv->rxbd[i].status, RXBD_EMPTY);
 550                 out_be16(&priv->rxbd[i].length, 0);
 551                 out_be32(&priv->rxbd[i].bufptr, (u32)net_rx_packets[i]);
 552         }
 553         status = in_be16(&priv->rxbd[PKTBUFSRX - 1].status);
 554         out_be16(&priv->rxbd[PKTBUFSRX - 1].status, status | RXBD_WRAP);
 555
 556         /* Initialize the TX Buffer Descriptors */
 557         for (i = 0; i < TX_BUF_CNT; i++) {
 558                 out_be16(&priv->txbd[i].status, 0);
 559                 out_be16(&priv->txbd[i].length, 0);
 560                 out_be32(&priv->txbd[i].bufptr, 0);
 561         }
 562         status = in_be16(&priv->txbd[TX_BUF_CNT - 1].status);
 563         out_be16(&priv->txbd[TX_BUF_CNT - 1].status, status | TXBD_WRAP);
 564
 565 #ifdef CONFIG_SYS_FSL_ERRATUM_NMG_ETSEC129
 566         svr = get_svr();
 567         if ((SVR_MAJ(svr) == 1) || IS_SVR_REV(svr, 2, 0))
 568                 redundant_init(priv);
 569 #endif
 570         /* Enable Transmit and Receive */
 571         setbits_be32(&regs->maccfg1, MACCFG1_RX_EN | MACCFG1_TX_EN);
 572
 573         /* Tell the DMA it is clear to go */
 574         setbits_be32(&regs->dmactrl, DMACTRL_INIT_SETTINGS);
 575         out_be32(&regs->tstat, TSTAT_CLEAR_THALT);
 576         out_be32(&regs->rstat, RSTAT_CLEAR_RHALT);
 577         clrbits_be32(&regs->dmactrl, DMACTRL_GRS | DMACTRL_GTS);
 578 }
 579
 580 /*
 581  * Initializes data structures and registers for the controller,
 582  * and brings the interface up. Returns the link status, meaning
 583  * that it returns success if the link is up, failure otherwise.
 584  * This allows U-Boot to find the first active controller.
 585  */
 586 #ifndef CONFIG_DM_ETH
 587 static int tsec_init(struct eth_device *dev, struct bd_info *bd)
 588 #else
 589 static int tsec_init(struct udevice *dev)
 590 #endif
 591 {
 592         struct tsec_private *priv;
 593         struct tsec __iomem *regs;
 594 #ifdef CONFIG_DM_ETH
 595         struct eth_pdata *pdata = dev_get_plat(dev);
 596 #else
 597         struct eth_device *pdata = dev;
 598 #endif
 599         u32 tempval;
 600         int ret;
 601
 602 #ifndef CONFIG_DM_ETH
 603         priv = (struct tsec_private *)dev->priv;
 604 #else
 605         priv = dev_get_priv(dev);
 606 #endif
 607         regs = priv->regs;
 608         /* Make sure the controller is stopped */
 609         tsec_halt(dev);
 610
 611         /* Init MACCFG2.  Defaults to GMII */
 612         out_be32(&regs->maccfg2, MACCFG2_INIT_SETTINGS);
 613
 614         /* Init ECNTRL */
 615         out_be32(&regs->ecntrl, ECNTRL_INIT_SETTINGS);
 616
 617         /*
 618          * Copy the station address into the address registers.
 619          * For a station address of 0x12345678ABCD in transmission
 620          * order (BE), MACnADDR1 is set to 0xCDAB7856 and
 621          * MACnADDR2 is set to 0x34120000.
 622          */
 623         tempval = (pdata->enetaddr[5] << 24) | (pdata->enetaddr[4] << 16) |
 624                   (pdata->enetaddr[3] << 8)  |  pdata->enetaddr[2];
 625
 626         out_be32(&regs->macstnaddr1, tempval);
 627
 628         tempval = (pdata->enetaddr[1] << 24) | (pdata->enetaddr[0] << 16);
 629
 630         out_be32(&regs->macstnaddr2, tempval);
 631
 632         /* Clear out (for the most part) the other registers */
 633         init_registers(regs);
 634
 635         /* Ready the device for tx/rx */
 636         startup_tsec(priv);
 637
 638         /* Start up the PHY */
 639         ret = phy_startup(priv->phydev);
 640         if (ret) {
 641                 printf("Could not initialize PHY %s\n",
 642                        priv->phydev->dev->name);
 643                 return ret;
 644         }
 645
 646         adjust_link(priv, priv->phydev);
 647
 648         /* If there's no link, fail */
 649         return priv->phydev->link ? 0 : -1;
 650 }
 651
 652 static phy_interface_t __maybe_unused tsec_get_interface(struct tsec_private *priv)
 653 {
 654         struct tsec __iomem *regs = priv->regs;
 655         u32 ecntrl;
 656
 657         ecntrl = in_be32(&regs->ecntrl);
 658
 659         if (ecntrl & ECNTRL_SGMII_MODE)
 660                 return PHY_INTERFACE_MODE_SGMII;
 661
 662         if (ecntrl & ECNTRL_TBI_MODE) {
 663                 if (ecntrl & ECNTRL_REDUCED_MODE)
 664                         return PHY_INTERFACE_MODE_RTBI;
 665                 else
 666                         return PHY_INTERFACE_MODE_TBI;
 667         }
 668
 669         if (ecntrl & ECNTRL_REDUCED_MODE) {
 670                 phy_interface_t interface;
 671
 672                 if (ecntrl & ECNTRL_REDUCED_MII_MODE)
 673                         return PHY_INTERFACE_MODE_RMII;
 674
 675                 interface = priv->interface;
 676
 677                 /*
 678                  * This isn't autodetected, so it must
 679                  * be set by the platform code.
 680                  */
 681                 if (interface == PHY_INTERFACE_MODE_RGMII_ID ||
 682                     interface == PHY_INTERFACE_MODE_RGMII_TXID ||
 683                     interface == PHY_INTERFACE_MODE_RGMII_RXID)
 684                         return interface;
 685
 686                 return PHY_INTERFACE_MODE_RGMII;
 687         }
 688
 689         if (priv->flags & TSEC_GIGABIT)
 690                 return PHY_INTERFACE_MODE_GMII;
 691
 692         return PHY_INTERFACE_MODE_MII;
 693 }
 694
 695 /*
 696  * Discover which PHY is attached to the device, and configure it
 697  * properly.  If the PHY is not recognized, then return 0
 698  * (failure).  Otherwise, return 1
 699  */
 700 static int init_phy(struct tsec_private *priv)
 701 {
 702         struct phy_device *phydev;
 703         struct tsec __iomem *regs = priv->regs;
 704         u32 supported = (SUPPORTED_10baseT_Half |
 705                         SUPPORTED_10baseT_Full |
 706                         SUPPORTED_100baseT_Half |
 707                         SUPPORTED_100baseT_Full);
 708
 709         if (priv->flags & TSEC_GIGABIT)
 710                 supported |= SUPPORTED_1000baseT_Full;
 711
 712         /* Assign a Physical address to the TBI */
 713         out_be32(&regs->tbipa, priv->tbiaddr);
 714
 715         if (priv->interface == PHY_INTERFACE_MODE_SGMII)
 716                 tsec_configure_serdes(priv);
 717
 718 #if defined(CONFIG_DM_ETH) && defined(CONFIG_DM_MDIO)
 719         phydev = dm_eth_phy_connect(priv->dev);
 720 #else
 721         phydev = phy_connect(priv->bus, priv->phyaddr, priv->dev,
 722                              priv->interface);
 723 #endif
 724         if (!phydev)
 725                 return 0;
 726
 727         phydev->supported &= supported;
 728         phydev->advertising = phydev->supported;
 729
 730         priv->phydev = phydev;
 731
 732         phy_config(phydev);
 733
 734         return 1;
 735 }
 736
 737 #ifndef CONFIG_DM_ETH
 738 /*
 739  * Initialize device structure. Returns success if PHY
 740  * initialization succeeded (i.e. if it recognizes the PHY)
 741  */
 742 static int tsec_initialize(struct bd_info *bis,
 743                            struct tsec_info_struct *tsec_info)
 744 {
 745         struct tsec_private *priv;
 746         struct eth_device *dev;
 747         int i;
 748
 749         dev = (struct eth_device *)malloc(sizeof(*dev));
 750
 751         if (!dev)
 752                 return 0;
 753
 754         memset(dev, 0, sizeof(*dev));
 755
 756         priv = (struct tsec_private *)malloc(sizeof(*priv));
 757
 758         if (!priv) {
 759                 free(dev);
 760                 return 0;
 761         }
 762
 763         priv->regs = tsec_info->regs;
 764         priv->phyregs_sgmii = tsec_info->miiregs_sgmii;
 765
 766         priv->phyaddr = tsec_info->phyaddr;
 767         priv->tbiaddr = CONFIG_SYS_TBIPA_VALUE;
 768         priv->flags = tsec_info->flags;
 769
 770         strcpy(dev->name, tsec_info->devname);
 771         priv->interface = tsec_info->interface;
 772         priv->bus = miiphy_get_dev_by_name(tsec_info->mii_devname);
 773         priv->dev = dev;
 774         dev->iobase = 0;
 775         dev->priv = priv;
 776         dev->init = tsec_init;
 777         dev->halt = tsec_halt;
 778         dev->send = tsec_send;
 779         dev->recv = tsec_recv;
 780         dev->mcast = tsec_mcast_addr;
 781
 782         /* Tell U-Boot to get the addr from the env */
 783         for (i = 0; i < 6; i++)
 784                 dev->enetaddr[i] = 0;
 785
 786         eth_register(dev);
 787
 788         /* Reset the MAC */
 789         setbits_be32(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
 790         udelay(2);  /* Soft Reset must be asserted for 3 TX clocks */
 791         clrbits_be32(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
 792
 793         /* Try to initialize PHY here, and return */
 794         return init_phy(priv);
 795 }
 796
 797 /*
 798  * Initialize all the TSEC devices
 799  *
 800  * Returns the number of TSEC devices that were initialized
 801  */
 802 int tsec_eth_init(struct bd_info *bis, struct tsec_info_struct *tsecs,
 803                   int num)
 804 {
 805         int i;
 806         int count = 0;
 807
 808         for (i = 0; i < num; i++) {
 809                 int ret = tsec_initialize(bis, &tsecs[i]);
 810
 811                 if (ret > 0)
 812                         count += ret;
 813         }
 814
 815         return count;
 816 }
 817
 818 int tsec_standard_init(struct bd_info *bis)
 819 {
 820         struct fsl_pq_mdio_info info;
 821
 822         info.regs = TSEC_GET_MDIO_REGS_BASE(1);
 823         info.name = DEFAULT_MII_NAME;
 824
 825         fsl_pq_mdio_init(bis, &info);
 826
 827         return tsec_eth_init(bis, tsec_info, ARRAY_SIZE(tsec_info));
 828 }
 829 #else /* CONFIG_DM_ETH */
 830 int tsec_probe(struct udevice *dev)
 831 {
 832         struct eth_pdata *pdata = dev_get_plat(dev);
 833         struct tsec_private *priv = dev_get_priv(dev);
 834         struct ofnode_phandle_args phandle_args;
 835         u32 tbiaddr = CONFIG_SYS_TBIPA_VALUE;
 836         struct tsec_data *data;
 837         ofnode parent, child;
 838         fdt_addr_t reg;
 839         u32 max_speed;
 840         int ret;
 841
 842         data = (struct tsec_data *)dev_get_driver_data(dev);
 843
 844         pdata->iobase = (phys_addr_t)dev_read_addr(dev);
 845         if (pdata->iobase == FDT_ADDR_T_NONE) {
 846                 ofnode_for_each_subnode(child, dev_ofnode(dev)) {
 847                         if (strncmp(ofnode_get_name(child), "queue-group",
 848                                     strlen("queue-group")))
 849                                 continue;
 850
 851                         reg = ofnode_get_addr(child);
 852                         if (reg == FDT_ADDR_T_NONE) {
 853                                 printf("No 'reg' property of <queue-group>\n");
 854                                 return -ENOENT;
 855                         }
 856                         pdata->iobase = reg;
 857
 858                         /*
 859                          * if there are multiple queue groups,
 860                          * only the first one is used.
 861                          */
 862                         break;
 863                 }
 864
 865                 if (!ofnode_valid(child)) {
 866                         printf("No child node for <queue-group>?\n");
 867                         return -ENOENT;
 868                 }
 869         }
 870
 871         priv->regs = map_physmem(pdata->iobase, 0, MAP_NOCACHE);
 872
 873         ret = dev_read_phandle_with_args(dev, "tbi-handle", NULL, 0, 0,
 874                                          &phandle_args);
 875         if (ret == 0) {
 876                 ofnode_read_u32(phandle_args.node, "reg", &tbiaddr);
 877
 878                 parent = ofnode_get_parent(phandle_args.node);
 879                 if (!ofnode_valid(parent)) {
 880                         printf("No parent node for TBI PHY?\n");
 881                         return -ENOENT;
 882                 }
 883
 884                 reg = ofnode_get_addr_index(parent, 0);
 885                 if (reg == FDT_ADDR_T_NONE) {
 886                         printf("No 'reg' property of MII for TBI PHY\n");
 887                         return -ENOENT;
 888                 }
 889
 890                 priv->phyregs_sgmii = map_physmem(reg + data->mdio_regs_off,
 891                                                   0, MAP_NOCACHE);
 892         }
 893
 894         priv->tbiaddr = tbiaddr;
 895
 896         pdata->phy_interface = dev_read_phy_mode(dev);
 897         if (pdata->phy_interface == PHY_INTERFACE_MODE_NONE)
 898                 pdata->phy_interface = tsec_get_interface(priv);
 899
 900         priv->interface = pdata->phy_interface;
 901
 902         /* Check for speed limit, default is 1000Mbps */
 903         max_speed = dev_read_u32_default(dev, "max-speed", 1000);
 904
 905         /* Initialize flags */
 906         if (max_speed == 1000)
 907                 priv->flags = TSEC_GIGABIT;
 908         if (priv->interface == PHY_INTERFACE_MODE_SGMII)
 909                 priv->flags |= TSEC_SGMII;
 910
 911         /* Reset the MAC */
 912         setbits_be32(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
 913         udelay(2);  /* Soft Reset must be asserted for 3 TX clocks */
 914         clrbits_be32(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
 915
 916         priv->dev = dev;
 917         priv->bus = miiphy_get_dev_by_name(dev->name);
 918
 919         /* Try to initialize PHY here, and return */
 920         return !init_phy(priv);
 921 }
 922
 923 int tsec_remove(struct udevice *dev)
 924 {
 925         struct tsec_private *priv = dev_get_priv(dev);
 926
 927         free(priv->phydev);
 928         mdio_unregister(priv->bus);
 929         mdio_free(priv->bus);
 930
 931         return 0;
 932 }
 933
 934 static const struct eth_ops tsec_ops = {
 935         .start = tsec_init,
 936         .send = tsec_send,
 937         .recv = tsec_recv,
 938         .free_pkt = tsec_free_pkt,
 939         .stop = tsec_halt,
 940         .mcast = tsec_mcast_addr,
 941         .set_promisc = tsec_set_promisc,
 942 };
 943
 944 static struct tsec_data etsec2_data = {
 945         .mdio_regs_off = TSEC_MDIO_REGS_OFFSET,
 946 };
 947
 948 static struct tsec_data gianfar_data = {
 949         .mdio_regs_off = 0x0,
 950 };
 951
 952 static const struct udevice_id tsec_ids[] = {
 953         { .compatible = "fsl,etsec2", .data = (ulong)&etsec2_data },
 954         { .compatible = "gianfar", .data = (ulong)&gianfar_data },
 955         { }
 956 };
 957
 958 U_BOOT_DRIVER(eth_tsec) = {
 959         .name = "tsec",
 960         .id = UCLASS_ETH,
 961         .of_match = tsec_ids,
 962         .probe = tsec_probe,
 963         .remove = tsec_remove,
 964         .ops = &tsec_ops,
 965         .priv_auto      = sizeof(struct tsec_private),
 966         .plat_auto      = sizeof(struct eth_pdata),
 967         .flags = DM_FLAG_ALLOC_PRIV_DMA,
 968 };
 969 #endif /* CONFIG_DM_ETH */