drivers/net/ftgmac100.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Faraday FTGMAC100 Ethernet
   4  *
   5  * (C) Copyright 2009 Faraday Technology
   6  * Po-Yu Chuang <ratbert@faraday-tech.com>
   7  *
   8  * (C) Copyright 2010 Andes Technology
   9  * Macpaul Lin <macpaul@andestech.com>
  10  *
  11  * Copyright (C) 2018, IBM Corporation.
  12  */
  13
  14 #include <common.h>
  15 #include <clk.h>
  16 #include <cpu_func.h>
  17 #include <dm.h>
  18 #include <log.h>
  19 #include <malloc.h>
  20 #include <miiphy.h>
  21 #include <net.h>
  22 #include <wait_bit.h>
  23 #include <asm/cache.h>
  24 #include <dm/device_compat.h>
  25 #include <linux/bitops.h>
  26 #include <linux/io.h>
  27 #include <linux/iopoll.h>
  28
  29 #include "ftgmac100.h"
  30
  31 /* Min frame ethernet frame size without FCS */
  32 #define ETH_ZLEN                        60
  33
  34 /* Receive Buffer Size Register - HW default is 0x640 */
  35 #define FTGMAC100_RBSR_DEFAULT          0x640
  36
  37 /* PKTBUFSTX/PKTBUFSRX must both be power of 2 */
  38 #define PKTBUFSTX       4       /* must be power of 2 */
  39
  40 /* Timeout for transmit */
  41 #define FTGMAC100_TX_TIMEOUT_MS         1000
  42
  43 /* Timeout for a mdio read/write operation */
  44 #define FTGMAC100_MDIO_TIMEOUT_USEC     10000
  45
  46 /*
  47  * MDC clock cycle threshold
  48  *
  49  * 20us * 100 = 2ms > (1 / 2.5Mhz) * 0x34
  50  */
  51 #define MDC_CYCTHR                      0x34
  52
  53 /*
  54  * ftgmac100 model variants
  55  */
  56 enum ftgmac100_model {
  57         FTGMAC100_MODEL_FARADAY,
  58         FTGMAC100_MODEL_ASPEED,
  59 };
  60
  61 /**
  62  * struct ftgmac100_data - private data for the FTGMAC100 driver
  63  *
  64  * @iobase: The base address of the hardware registers
  65  * @txdes: The array of transmit descriptors
  66  * @rxdes: The array of receive descriptors
  67  * @tx_index: Transmit descriptor index in @txdes
  68  * @rx_index: Receive descriptor index in @rxdes
  69  * @phy_addr: The PHY interface address to use
  70  * @phydev: The PHY device backing the MAC
  71  * @bus: The mdio bus
  72  * @phy_mode: The mode of the PHY interface (rgmii, rmii, ...)
  73  * @max_speed: Maximum speed of Ethernet connection supported by MAC
  74  * @clks: The bulk of clocks assigned to the device in the DT
  75  * @rxdes0_edorr_mask: The bit number identifying the end of the RX ring buffer
  76  * @txdes0_edotr_mask: The bit number identifying the end of the TX ring buffer
  77  */
  78 struct ftgmac100_data {
  79         struct ftgmac100 *iobase;
  80
  81         struct ftgmac100_txdes txdes[PKTBUFSTX] __aligned(ARCH_DMA_MINALIGN);
  82         struct ftgmac100_rxdes rxdes[PKTBUFSRX] __aligned(ARCH_DMA_MINALIGN);
  83         int tx_index;
  84         int rx_index;
  85
  86         u32 phy_addr;
  87         struct phy_device *phydev;
  88         struct mii_dev *bus;
  89         u32 phy_mode;
  90         u32 max_speed;
  91
  92         struct clk_bulk clks;
  93
  94         /* End of RX/TX ring buffer bits. Depend on model */
  95         u32 rxdes0_edorr_mask;
  96         u32 txdes0_edotr_mask;
  97 };
  98
  99 /*
 100  * struct mii_bus functions
 101  */
 102 static int ftgmac100_mdio_read(struct mii_dev *bus, int phy_addr, int dev_addr,
 103                                int reg_addr)
 104 {
 105         struct ftgmac100_data *priv = bus->priv;
 106         struct ftgmac100 *ftgmac100 = priv->iobase;
 107         int phycr;
 108         int data;
 109         int ret;
 110
 111         phycr = FTGMAC100_PHYCR_MDC_CYCTHR(MDC_CYCTHR) |
 112                 FTGMAC100_PHYCR_PHYAD(phy_addr) |
 113                 FTGMAC100_PHYCR_REGAD(reg_addr) |
 114                 FTGMAC100_PHYCR_MIIRD;
 115         writel(phycr, &ftgmac100->phycr);
 116
 117         ret = readl_poll_timeout(&ftgmac100->phycr, phycr,
 118                                  !(phycr & FTGMAC100_PHYCR_MIIRD),
 119                                  FTGMAC100_MDIO_TIMEOUT_USEC);
 120         if (ret) {
 121                 pr_err("%s: mdio read failed (phy:%d reg:%x)\n",
 122                        priv->phydev->dev->name, phy_addr, reg_addr);
 123                 return ret;
 124         }
 125
 126         data = readl(&ftgmac100->phydata);
 127
 128         return FTGMAC100_PHYDATA_MIIRDATA(data);
 129 }
 130
 131 static int ftgmac100_mdio_write(struct mii_dev *bus, int phy_addr, int dev_addr,
 132                                 int reg_addr, u16 value)
 133 {
 134         struct ftgmac100_data *priv = bus->priv;
 135         struct ftgmac100 *ftgmac100 = priv->iobase;
 136         int phycr;
 137         int data;
 138         int ret;
 139
 140         phycr = FTGMAC100_PHYCR_MDC_CYCTHR(MDC_CYCTHR) |
 141                 FTGMAC100_PHYCR_PHYAD(phy_addr) |
 142                 FTGMAC100_PHYCR_REGAD(reg_addr) |
 143                 FTGMAC100_PHYCR_MIIWR;
 144         data = FTGMAC100_PHYDATA_MIIWDATA(value);
 145
 146         writel(data, &ftgmac100->phydata);
 147         writel(phycr, &ftgmac100->phycr);
 148
 149         ret = readl_poll_timeout(&ftgmac100->phycr, phycr,
 150                                  !(phycr & FTGMAC100_PHYCR_MIIWR),
 151                                  FTGMAC100_MDIO_TIMEOUT_USEC);
 152         if (ret) {
 153                 pr_err("%s: mdio write failed (phy:%d reg:%x)\n",
 154                        priv->phydev->dev->name, phy_addr, reg_addr);
 155         }
 156
 157         return ret;
 158 }
 159
 160 static int ftgmac100_mdio_init(struct udevice *dev)
 161 {
 162         struct ftgmac100_data *priv = dev_get_priv(dev);
 163         struct mii_dev *bus;
 164         int ret;
 165
 166         bus = mdio_alloc();
 167         if (!bus)
 168                 return -ENOMEM;
 169
 170         bus->read  = ftgmac100_mdio_read;
 171         bus->write = ftgmac100_mdio_write;
 172         bus->priv  = priv;
 173
 174         ret = mdio_register_seq(bus, dev->seq);
 175         if (ret) {
 176                 free(bus);
 177                 return ret;
 178         }
 179
 180         priv->bus = bus;
 181
 182         return 0;
 183 }
 184
 185 static int ftgmac100_phy_adjust_link(struct ftgmac100_data *priv)
 186 {
 187         struct ftgmac100 *ftgmac100 = priv->iobase;
 188         struct phy_device *phydev = priv->phydev;
 189         u32 maccr;
 190
 191         if (!phydev->link) {
 192                 dev_err(phydev->dev, "No link\n");
 193                 return -EREMOTEIO;
 194         }
 195
 196         /* read MAC control register and clear related bits */
 197         maccr = readl(&ftgmac100->maccr) &
 198                 ~(FTGMAC100_MACCR_GIGA_MODE |
 199                   FTGMAC100_MACCR_FAST_MODE |
 200                   FTGMAC100_MACCR_FULLDUP);
 201
 202         if (phy_interface_is_rgmii(phydev) && phydev->speed == 1000)
 203                 maccr |= FTGMAC100_MACCR_GIGA_MODE;
 204
 205         if (phydev->speed == 100)
 206                 maccr |= FTGMAC100_MACCR_FAST_MODE;
 207
 208         if (phydev->duplex)
 209                 maccr |= FTGMAC100_MACCR_FULLDUP;
 210
 211         /* update MII config into maccr */
 212         writel(maccr, &ftgmac100->maccr);
 213
 214         return 0;
 215 }
 216
 217 static int ftgmac100_phy_init(struct udevice *dev)
 218 {
 219         struct ftgmac100_data *priv = dev_get_priv(dev);
 220         struct phy_device *phydev;
 221         int ret;
 222
 223         phydev = phy_connect(priv->bus, priv->phy_addr, dev, priv->phy_mode);
 224         if (!phydev)
 225                 return -ENODEV;
 226
 227         phydev->supported &= PHY_GBIT_FEATURES;
 228         if (priv->max_speed) {
 229                 ret = phy_set_supported(phydev, priv->max_speed);
 230                 if (ret)
 231                         return ret;
 232         }
 233         phydev->advertising = phydev->supported;
 234         priv->phydev = phydev;
 235         phy_config(phydev);
 236
 237         return 0;
 238 }
 239
 240 /*
 241  * Reset MAC
 242  */
 243 static void ftgmac100_reset(struct ftgmac100_data *priv)
 244 {
 245         struct ftgmac100 *ftgmac100 = priv->iobase;
 246
 247         debug("%s()\n", __func__);
 248
 249         setbits_le32(&ftgmac100->maccr, FTGMAC100_MACCR_SW_RST);
 250
 251         while (readl(&ftgmac100->maccr) & FTGMAC100_MACCR_SW_RST)
 252                 ;
 253 }
 254
 255 /*
 256  * Set MAC address
 257  */
 258 static int ftgmac100_set_mac(struct ftgmac100_data *priv,
 259                              const unsigned char *mac)
 260 {
 261         struct ftgmac100 *ftgmac100 = priv->iobase;
 262         unsigned int maddr = mac[0] << 8 | mac[1];
 263         unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
 264
 265         debug("%s(%x %x)\n", __func__, maddr, laddr);
 266
 267         writel(maddr, &ftgmac100->mac_madr);
 268         writel(laddr, &ftgmac100->mac_ladr);
 269
 270         return 0;
 271 }
 272
 273 /*
 274  * disable transmitter, receiver
 275  */
 276 static void ftgmac100_stop(struct udevice *dev)
 277 {
 278         struct ftgmac100_data *priv = dev_get_priv(dev);
 279         struct ftgmac100 *ftgmac100 = priv->iobase;
 280
 281         debug("%s()\n", __func__);
 282
 283         writel(0, &ftgmac100->maccr);
 284
 285         phy_shutdown(priv->phydev);
 286 }
 287
 288 static int ftgmac100_start(struct udevice *dev)
 289 {
 290         struct eth_pdata *plat = dev_get_platdata(dev);
 291         struct ftgmac100_data *priv = dev_get_priv(dev);
 292         struct ftgmac100 *ftgmac100 = priv->iobase;
 293         struct phy_device *phydev = priv->phydev;
 294         unsigned int maccr;
 295         ulong start, end;
 296         int ret;
 297         int i;
 298
 299         debug("%s()\n", __func__);
 300
 301         ftgmac100_reset(priv);
 302
 303         /* set the ethernet address */
 304         ftgmac100_set_mac(priv, plat->enetaddr);
 305
 306         /* disable all interrupts */
 307         writel(0, &ftgmac100->ier);
 308
 309         /* initialize descriptors */
 310         priv->tx_index = 0;
 311         priv->rx_index = 0;
 312
 313         for (i = 0; i < PKTBUFSTX; i++) {
 314                 priv->txdes[i].txdes3 = 0;
 315                 priv->txdes[i].txdes0 = 0;
 316         }
 317         priv->txdes[PKTBUFSTX - 1].txdes0 = priv->txdes0_edotr_mask;
 318
 319         start = ((ulong)&priv->txdes[0]) & ~(ARCH_DMA_MINALIGN - 1);
 320         end = start + roundup(sizeof(priv->txdes), ARCH_DMA_MINALIGN);
 321         flush_dcache_range(start, end);
 322
 323         for (i = 0; i < PKTBUFSRX; i++) {
 324                 priv->rxdes[i].rxdes3 = (unsigned int)net_rx_packets[i];
 325                 priv->rxdes[i].rxdes0 = 0;
 326         }
 327         priv->rxdes[PKTBUFSRX - 1].rxdes0 = priv->rxdes0_edorr_mask;
 328
 329         start = ((ulong)&priv->rxdes[0]) & ~(ARCH_DMA_MINALIGN - 1);
 330         end = start + roundup(sizeof(priv->rxdes), ARCH_DMA_MINALIGN);
 331         flush_dcache_range(start, end);
 332
 333         /* transmit ring */
 334         writel((u32)priv->txdes, &ftgmac100->txr_badr);
 335
 336         /* receive ring */
 337         writel((u32)priv->rxdes, &ftgmac100->rxr_badr);
 338
 339         /* poll receive descriptor automatically */
 340         writel(FTGMAC100_APTC_RXPOLL_CNT(1), &ftgmac100->aptc);
 341
 342         /* config receive buffer size register */
 343         writel(FTGMAC100_RBSR_SIZE(FTGMAC100_RBSR_DEFAULT), &ftgmac100->rbsr);
 344
 345         /* enable transmitter, receiver */
 346         maccr = FTGMAC100_MACCR_TXMAC_EN |
 347                 FTGMAC100_MACCR_RXMAC_EN |
 348                 FTGMAC100_MACCR_TXDMA_EN |
 349                 FTGMAC100_MACCR_RXDMA_EN |
 350                 FTGMAC100_MACCR_CRC_APD |
 351                 FTGMAC100_MACCR_FULLDUP |
 352                 FTGMAC100_MACCR_RX_RUNT |
 353                 FTGMAC100_MACCR_RX_BROADPKT;
 354
 355         writel(maccr, &ftgmac100->maccr);
 356
 357         ret = phy_startup(phydev);
 358         if (ret) {
 359                 dev_err(phydev->dev, "Could not start PHY\n");
 360                 return ret;
 361         }
 362
 363         ret = ftgmac100_phy_adjust_link(priv);
 364         if (ret) {
 365                 dev_err(phydev->dev,  "Could not adjust link\n");
 366                 return ret;
 367         }
 368
 369         printf("%s: link up, %d Mbps %s-duplex mac:%pM\n", phydev->dev->name,
 370                phydev->speed, phydev->duplex ? "full" : "half", plat->enetaddr);
 371
 372         return 0;
 373 }
 374
 375 static int ftgmac100_free_pkt(struct udevice *dev, uchar *packet, int length)
 376 {
 377         struct ftgmac100_data *priv = dev_get_priv(dev);
 378         struct ftgmac100_rxdes *curr_des = &priv->rxdes[priv->rx_index];
 379         ulong des_start = ((ulong)curr_des) & ~(ARCH_DMA_MINALIGN - 1);
 380         ulong des_end = des_start +
 381                 roundup(sizeof(*curr_des), ARCH_DMA_MINALIGN);
 382
 383         /* Release buffer to DMA and flush descriptor */
 384         curr_des->rxdes0 &= ~FTGMAC100_RXDES0_RXPKT_RDY;
 385         flush_dcache_range(des_start, des_end);
 386
 387         /* Move to next descriptor */
 388         priv->rx_index = (priv->rx_index + 1) % PKTBUFSRX;
 389
 390         return 0;
 391 }
 392
 393 /*
 394  * Get a data block via Ethernet
 395  */
 396 static int ftgmac100_recv(struct udevice *dev, int flags, uchar **packetp)
 397 {
 398         struct ftgmac100_data *priv = dev_get_priv(dev);
 399         struct ftgmac100_rxdes *curr_des = &priv->rxdes[priv->rx_index];
 400         unsigned short rxlen;
 401         ulong des_start = ((ulong)curr_des) & ~(ARCH_DMA_MINALIGN - 1);
 402         ulong des_end = des_start +
 403                 roundup(sizeof(*curr_des), ARCH_DMA_MINALIGN);
 404         ulong data_start = curr_des->rxdes3;
 405         ulong data_end;
 406
 407         invalidate_dcache_range(des_start, des_end);
 408
 409         if (!(curr_des->rxdes0 & FTGMAC100_RXDES0_RXPKT_RDY))
 410                 return -EAGAIN;
 411
 412         if (curr_des->rxdes0 & (FTGMAC100_RXDES0_RX_ERR |
 413                                 FTGMAC100_RXDES0_CRC_ERR |
 414                                 FTGMAC100_RXDES0_FTL |
 415                                 FTGMAC100_RXDES0_RUNT |
 416                                 FTGMAC100_RXDES0_RX_ODD_NB)) {
 417                 return -EAGAIN;
 418         }
 419
 420         rxlen = FTGMAC100_RXDES0_VDBC(curr_des->rxdes0);
 421
 422         debug("%s(): RX buffer %d, %x received\n",
 423                __func__, priv->rx_index, rxlen);
 424
 425         /* Invalidate received data */
 426         data_end = data_start + roundup(rxlen, ARCH_DMA_MINALIGN);
 427         invalidate_dcache_range(data_start, data_end);
 428         *packetp = (uchar *)data_start;
 429
 430         return rxlen;
 431 }
 432
 433 static u32 ftgmac100_read_txdesc(const void *desc)
 434 {
 435         const struct ftgmac100_txdes *txdes = desc;
 436         ulong des_start = ((ulong)txdes) & ~(ARCH_DMA_MINALIGN - 1);
 437         ulong des_end = des_start + roundup(sizeof(*txdes), ARCH_DMA_MINALIGN);
 438
 439         invalidate_dcache_range(des_start, des_end);
 440
 441         return txdes->txdes0;
 442 }
 443
 444 BUILD_WAIT_FOR_BIT(ftgmac100_txdone, u32, ftgmac100_read_txdesc)
 445
 446 /*
 447  * Send a data block via Ethernet
 448  */
 449 static int ftgmac100_send(struct udevice *dev, void *packet, int length)
 450 {
 451         struct ftgmac100_data *priv = dev_get_priv(dev);
 452         struct ftgmac100 *ftgmac100 = priv->iobase;
 453         struct ftgmac100_txdes *curr_des = &priv->txdes[priv->tx_index];
 454         ulong des_start = ((ulong)curr_des) & ~(ARCH_DMA_MINALIGN - 1);
 455         ulong des_end = des_start +
 456                 roundup(sizeof(*curr_des), ARCH_DMA_MINALIGN);
 457         ulong data_start;
 458         ulong data_end;
 459         int rc;
 460
 461         invalidate_dcache_range(des_start, des_end);
 462
 463         if (curr_des->txdes0 & FTGMAC100_TXDES0_TXDMA_OWN) {
 464                 dev_err(dev, "no TX descriptor available\n");
 465                 return -EPERM;
 466         }
 467
 468         debug("%s(%x, %x)\n", __func__, (int)packet, length);
 469
 470         length = (length < ETH_ZLEN) ? ETH_ZLEN : length;
 471
 472         curr_des->txdes3 = (unsigned int)packet;
 473
 474         /* Flush data to be sent */
 475         data_start = curr_des->txdes3;
 476         data_end = data_start + roundup(length, ARCH_DMA_MINALIGN);
 477         flush_dcache_range(data_start, data_end);
 478
 479         /* Only one segment on TXBUF */
 480         curr_des->txdes0 &= priv->txdes0_edotr_mask;
 481         curr_des->txdes0 |= FTGMAC100_TXDES0_FTS |
 482                             FTGMAC100_TXDES0_LTS |
 483                             FTGMAC100_TXDES0_TXBUF_SIZE(length) |
 484                             FTGMAC100_TXDES0_TXDMA_OWN ;
 485
 486         /* Flush modified buffer descriptor */
 487         flush_dcache_range(des_start, des_end);
 488
 489         /* Start transmit */
 490         writel(1, &ftgmac100->txpd);
 491
 492         rc = wait_for_bit_ftgmac100_txdone(curr_des,
 493                                            FTGMAC100_TXDES0_TXDMA_OWN, false,
 494                                            FTGMAC100_TX_TIMEOUT_MS, true);
 495         if (rc)
 496                 return rc;
 497
 498         debug("%s(): packet sent\n", __func__);
 499
 500         /* Move to next descriptor */
 501         priv->tx_index = (priv->tx_index + 1) % PKTBUFSTX;
 502
 503         return 0;
 504 }
 505
 506 static int ftgmac100_write_hwaddr(struct udevice *dev)
 507 {
 508         struct eth_pdata *pdata = dev_get_platdata(dev);
 509         struct ftgmac100_data *priv = dev_get_priv(dev);
 510
 511         return ftgmac100_set_mac(priv, pdata->enetaddr);
 512 }
 513
 514 static int ftgmac100_ofdata_to_platdata(struct udevice *dev)
 515 {
 516         struct eth_pdata *pdata = dev_get_platdata(dev);
 517         struct ftgmac100_data *priv = dev_get_priv(dev);
 518         const char *phy_mode;
 519
 520         pdata->iobase = devfdt_get_addr(dev);
 521         pdata->phy_interface = -1;
 522         phy_mode = dev_read_string(dev, "phy-mode");
 523         if (phy_mode)
 524                 pdata->phy_interface = phy_get_interface_by_name(phy_mode);
 525         if (pdata->phy_interface == -1) {
 526                 dev_err(dev, "Invalid PHY interface '%s'\n", phy_mode);
 527                 return -EINVAL;
 528         }
 529
 530         pdata->max_speed = dev_read_u32_default(dev, "max-speed", 0);
 531
 532         if (dev_get_driver_data(dev) == FTGMAC100_MODEL_ASPEED) {
 533                 priv->rxdes0_edorr_mask = BIT(30);
 534                 priv->txdes0_edotr_mask = BIT(30);
 535         } else {
 536                 priv->rxdes0_edorr_mask = BIT(15);
 537                 priv->txdes0_edotr_mask = BIT(15);
 538         }
 539
 540         return clk_get_bulk(dev, &priv->clks);
 541 }
 542
 543 static int ftgmac100_probe(struct udevice *dev)
 544 {
 545         struct eth_pdata *pdata = dev_get_platdata(dev);
 546         struct ftgmac100_data *priv = dev_get_priv(dev);
 547         int ret;
 548
 549         priv->iobase = (struct ftgmac100 *)pdata->iobase;
 550         priv->phy_mode = pdata->phy_interface;
 551         priv->max_speed = pdata->max_speed;
 552         priv->phy_addr = 0;
 553
 554         ret = clk_enable_bulk(&priv->clks);
 555         if (ret)
 556                 goto out;
 557
 558         ret = ftgmac100_mdio_init(dev);
 559         if (ret) {
 560                 dev_err(dev, "Failed to initialize mdiobus: %d\n", ret);
 561                 goto out;
 562         }
 563
 564         ret = ftgmac100_phy_init(dev);
 565         if (ret) {
 566                 dev_err(dev, "Failed to initialize PHY: %d\n", ret);
 567                 goto out;
 568         }
 569
 570 out:
 571         if (ret)
 572                 clk_release_bulk(&priv->clks);
 573
 574         return ret;
 575 }
 576
 577 static int ftgmac100_remove(struct udevice *dev)
 578 {
 579         struct ftgmac100_data *priv = dev_get_priv(dev);
 580
 581         free(priv->phydev);
 582         mdio_unregister(priv->bus);
 583         mdio_free(priv->bus);
 584         clk_release_bulk(&priv->clks);
 585
 586         return 0;
 587 }
 588
 589 static const struct eth_ops ftgmac100_ops = {
 590         .start  = ftgmac100_start,
 591         .send   = ftgmac100_send,
 592         .recv   = ftgmac100_recv,
 593         .stop   = ftgmac100_stop,
 594         .free_pkt = ftgmac100_free_pkt,
 595         .write_hwaddr = ftgmac100_write_hwaddr,
 596 };
 597
 598 static const struct udevice_id ftgmac100_ids[] = {
 599         { .compatible = "faraday,ftgmac100",  .data = FTGMAC100_MODEL_FARADAY },
 600         { .compatible = "aspeed,ast2500-mac", .data = FTGMAC100_MODEL_ASPEED  },
 601         { }
 602 };
 603
 604 U_BOOT_DRIVER(ftgmac100) = {
 605         .name   = "ftgmac100",
 606         .id     = UCLASS_ETH,
 607         .of_match = ftgmac100_ids,
 608         .ofdata_to_platdata = ftgmac100_ofdata_to_platdata,
 609         .probe  = ftgmac100_probe,
 610         .remove = ftgmac100_remove,
 611         .ops    = &ftgmac100_ops,
 612         .priv_auto_alloc_size = sizeof(struct ftgmac100_data),
 613         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
 614         .flags  = DM_FLAG_ALLOC_PRIV_DMA,
 615 };