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