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 <[email protected]>
   7  *
   8  * (C) Copyright 2010 Andes Technology
   9  * Macpaul Lin <[email protected]>
  10  *
  11  * Copyright (C) 2018, IBM Corporation.
  12  */
  13
  14 #include <clk.h>
  15 #include <reset.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 #include <linux/printk.h>
  29 #include <linux/bitfield.h>
  30
  31 #include "ftgmac100.h"
  32
  33 /* Min frame ethernet frame size without FCS */
  34 #define ETH_ZLEN                        60
  35
  36 /* Receive Buffer Size Register - HW default is 0x640 */
  37 #define FTGMAC100_RBSR_DEFAULT          0x640
  38
  39 /* PKTBUFSTX/PKTBUFSRX must both be power of 2 */
  40 #define PKTBUFSTX       4       /* must be power of 2 */
  41
  42 /* Timeout for transmit */
  43 #define FTGMAC100_TX_TIMEOUT_MS         1000
  44
  45 /* Timeout for a mdio read/write operation */
  46 #define FTGMAC100_MDIO_TIMEOUT_USEC     10000
  47
  48 /*
  49  * MDC clock cycle threshold
  50  *
  51  * 20us * 100 = 2ms > (1 / 2.5Mhz) * 0x34
  52  */
  53 #define MDC_CYCTHR                      0x34
  54
  55 /*
  56  * ftgmac100 model variants
  57  */
  58 enum ftgmac100_model {
  59         FTGMAC100_MODEL_FARADAY,
  60         FTGMAC100_MODEL_ASPEED,
  61         FTGMAC100_MODEL_ASPEED_AST2700,
  62 };
  63
  64 union ftgmac100_dma_addr {
  65         dma_addr_t addr;
  66         struct {
  67                 u32 lo;
  68                 u32 hi;
  69         };
  70 };
  71
  72 /**
  73  * struct ftgmac100_data - private data for the FTGMAC100 driver
  74  *
  75  * @iobase: The base address of the hardware registers
  76  * @txdes: The array of transmit descriptors
  77  * @rxdes: The array of receive descriptors
  78  * @tx_index: Transmit descriptor index in @txdes
  79  * @rx_index: Receive descriptor index in @rxdes
  80  * @phy_addr: The PHY interface address to use
  81  * @phydev: The PHY device backing the MAC
  82  * @bus: The mdio bus
  83  * @phy_mode: The mode of the PHY interface (rgmii, rmii, ...)
  84  * @max_speed: Maximum speed of Ethernet connection supported by MAC
  85  * @clks: The bulk of clocks assigned to the device in the DT
  86  * @rxdes0_edorr_mask: The bit number identifying the end of the RX ring buffer
  87  * @txdes0_edotr_mask: The bit number identifying the end of the TX ring buffer
  88  */
  89 struct ftgmac100_data {
  90         struct ftgmac100 *iobase;
  91
  92         struct ftgmac100_txdes txdes[PKTBUFSTX] __aligned(ARCH_DMA_MINALIGN);
  93         struct ftgmac100_rxdes rxdes[PKTBUFSRX] __aligned(ARCH_DMA_MINALIGN);
  94         int tx_index;
  95         int rx_index;
  96
  97         u32 phy_addr;
  98         struct phy_device *phydev;
  99         struct mii_dev *bus;
 100         u32 phy_mode;
 101         u32 max_speed;
 102
 103         struct clk_bulk clks;
 104         struct reset_ctl *reset_ctl;
 105
 106         /* End of RX/TX ring buffer bits. Depend on model */
 107         u32 rxdes0_edorr_mask;
 108         u32 txdes0_edotr_mask;
 109
 110         bool is_ast2700;
 111 };
 112
 113 /*
 114  * struct mii_bus functions
 115  */
 116 static int ftgmac100_mdio_read(struct mii_dev *bus, int phy_addr, int dev_addr,
 117                                int reg_addr)
 118 {
 119         struct ftgmac100_data *priv = bus->priv;
 120         struct ftgmac100 *ftgmac100 = priv->iobase;
 121         int phycr;
 122         int data;
 123         int ret;
 124
 125         phycr = FTGMAC100_PHYCR_MDC_CYCTHR(MDC_CYCTHR) |
 126                 FTGMAC100_PHYCR_PHYAD(phy_addr) |
 127                 FTGMAC100_PHYCR_REGAD(reg_addr) |
 128                 FTGMAC100_PHYCR_MIIRD;
 129         writel(phycr, &ftgmac100->phycr);
 130
 131         ret = readl_poll_timeout(&ftgmac100->phycr, phycr,
 132                                  !(phycr & FTGMAC100_PHYCR_MIIRD),
 133                                  FTGMAC100_MDIO_TIMEOUT_USEC);
 134         if (ret) {
 135                 pr_err("%s: mdio read failed (phy:%d reg:%x)\n",
 136                        bus->name, phy_addr, reg_addr);
 137                 return ret;
 138         }
 139
 140         data = readl(&ftgmac100->phydata);
 141
 142         return FTGMAC100_PHYDATA_MIIRDATA(data);
 143 }
 144
 145 static int ftgmac100_mdio_write(struct mii_dev *bus, int phy_addr, int dev_addr,
 146                                 int reg_addr, u16 value)
 147 {
 148         struct ftgmac100_data *priv = bus->priv;
 149         struct ftgmac100 *ftgmac100 = priv->iobase;
 150         int phycr;
 151         int data;
 152         int ret;
 153
 154         phycr = FTGMAC100_PHYCR_MDC_CYCTHR(MDC_CYCTHR) |
 155                 FTGMAC100_PHYCR_PHYAD(phy_addr) |
 156                 FTGMAC100_PHYCR_REGAD(reg_addr) |
 157                 FTGMAC100_PHYCR_MIIWR;
 158         data = FTGMAC100_PHYDATA_MIIWDATA(value);
 159
 160         writel(data, &ftgmac100->phydata);
 161         writel(phycr, &ftgmac100->phycr);
 162
 163         ret = readl_poll_timeout(&ftgmac100->phycr, phycr,
 164                                  !(phycr & FTGMAC100_PHYCR_MIIWR),
 165                                  FTGMAC100_MDIO_TIMEOUT_USEC);
 166         if (ret) {
 167                 pr_err("%s: mdio write failed (phy:%d reg:%x)\n",
 168                        bus->name, phy_addr, reg_addr);
 169         }
 170
 171         return ret;
 172 }
 173
 174 static int ftgmac100_mdio_init(struct udevice *dev)
 175 {
 176         struct ftgmac100_data *priv = dev_get_priv(dev);
 177         struct mii_dev *bus;
 178         int ret;
 179
 180         bus = mdio_alloc();
 181         if (!bus)
 182                 return -ENOMEM;
 183
 184         bus->read  = ftgmac100_mdio_read;
 185         bus->write = ftgmac100_mdio_write;
 186         bus->priv  = priv;
 187
 188         ret = mdio_register_seq(bus, dev_seq(dev));
 189         if (ret) {
 190                 free(bus);
 191                 return ret;
 192         }
 193
 194         priv->bus = bus;
 195
 196         return 0;
 197 }
 198
 199 static int ftgmac100_phy_adjust_link(struct ftgmac100_data *priv)
 200 {
 201         struct ftgmac100 *ftgmac100 = priv->iobase;
 202         struct phy_device *phydev = priv->phydev;
 203         u32 maccr;
 204
 205         if (!phydev->link && priv->phy_mode != PHY_INTERFACE_MODE_NCSI) {
 206                 dev_err(phydev->dev, "No link\n");
 207                 return -EREMOTEIO;
 208         }
 209
 210         /* read MAC control register and clear related bits */
 211         maccr = readl(&ftgmac100->maccr) &
 212                 ~(FTGMAC100_MACCR_GIGA_MODE |
 213                   FTGMAC100_MACCR_FAST_MODE |
 214                   FTGMAC100_MACCR_FULLDUP);
 215
 216         if (phy_interface_is_rgmii(phydev) && phydev->speed == 1000)
 217                 maccr |= FTGMAC100_MACCR_GIGA_MODE;
 218
 219         if (phydev->speed == 100)
 220                 maccr |= FTGMAC100_MACCR_FAST_MODE;
 221
 222         if (phydev->duplex)
 223                 maccr |= FTGMAC100_MACCR_FULLDUP;
 224
 225         /* update MII config into maccr */
 226         writel(maccr, &ftgmac100->maccr);
 227
 228         return 0;
 229 }
 230
 231 static int ftgmac100_phy_init(struct udevice *dev)
 232 {
 233         struct ftgmac100_data *priv = dev_get_priv(dev);
 234         struct phy_device *phydev;
 235         int ret;
 236
 237         if (IS_ENABLED(CONFIG_DM_MDIO) && priv->phy_mode != PHY_INTERFACE_MODE_NCSI)
 238                 phydev = dm_eth_phy_connect(dev);
 239         else
 240                 phydev = phy_connect(priv->bus, priv->phy_addr, dev, priv->phy_mode);
 241
 242         if (!phydev)
 243                 return -ENODEV;
 244
 245         if (priv->phy_mode != PHY_INTERFACE_MODE_NCSI)
 246                 phydev->supported &= PHY_GBIT_FEATURES;
 247         if (priv->max_speed) {
 248                 ret = phy_set_supported(phydev, priv->max_speed);
 249                 if (ret)
 250                         return ret;
 251         }
 252         phydev->advertising = phydev->supported;
 253         priv->phydev = phydev;
 254         phy_config(phydev);
 255
 256         return 0;
 257 }
 258
 259 /*
 260  * Reset MAC
 261  */
 262 static void ftgmac100_reset(struct ftgmac100_data *priv)
 263 {
 264         struct ftgmac100 *ftgmac100 = priv->iobase;
 265
 266         debug("%s()\n", __func__);
 267
 268         setbits_le32(&ftgmac100->maccr, FTGMAC100_MACCR_SW_RST);
 269
 270         while (readl(&ftgmac100->maccr) & FTGMAC100_MACCR_SW_RST)
 271                 ;
 272 }
 273
 274 /*
 275  * Set MAC address
 276  */
 277 static int ftgmac100_set_mac(struct ftgmac100_data *priv,
 278                              const unsigned char *mac)
 279 {
 280         struct ftgmac100 *ftgmac100 = priv->iobase;
 281         unsigned int maddr = mac[0] << 8 | mac[1];
 282         unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
 283
 284         debug("%s(%x %x)\n", __func__, maddr, laddr);
 285
 286         writel(maddr, &ftgmac100->mac_madr);
 287         writel(laddr, &ftgmac100->mac_ladr);
 288
 289         return 0;
 290 }
 291
 292 /*
 293  * Get MAC address
 294  */
 295 static int ftgmac100_get_mac(struct ftgmac100_data *priv,
 296                                 unsigned char *mac)
 297 {
 298         struct ftgmac100 *ftgmac100 = priv->iobase;
 299         unsigned int maddr = readl(&ftgmac100->mac_madr);
 300         unsigned int laddr = readl(&ftgmac100->mac_ladr);
 301
 302         debug("%s(%x %x)\n", __func__, maddr, laddr);
 303
 304         mac[0] = (maddr >> 8) & 0xff;
 305         mac[1] =  maddr & 0xff;
 306         mac[2] = (laddr >> 24) & 0xff;
 307         mac[3] = (laddr >> 16) & 0xff;
 308         mac[4] = (laddr >> 8) & 0xff;
 309         mac[5] =  laddr & 0xff;
 310
 311         return 0;
 312 }
 313
 314 /*
 315  * disable transmitter, receiver
 316  */
 317 static void ftgmac100_stop(struct udevice *dev)
 318 {
 319         struct ftgmac100_data *priv = dev_get_priv(dev);
 320         struct ftgmac100 *ftgmac100 = priv->iobase;
 321
 322         debug("%s()\n", __func__);
 323
 324         writel(0, &ftgmac100->maccr);
 325
 326         if (priv->phy_mode != PHY_INTERFACE_MODE_NCSI)
 327                 phy_shutdown(priv->phydev);
 328 }
 329
 330 static int ftgmac100_start(struct udevice *dev)
 331 {
 332         struct eth_pdata *plat = dev_get_plat(dev);
 333         struct ftgmac100_data *priv = dev_get_priv(dev);
 334         struct ftgmac100 *ftgmac100 = priv->iobase;
 335         union ftgmac100_dma_addr dma_addr = {.hi = 0, .lo = 0};
 336         struct phy_device *phydev = priv->phydev;
 337         unsigned int maccr, dblac, desc_size;
 338         ulong start, end;
 339         int ret;
 340         int i;
 341
 342         debug("%s()\n", __func__);
 343
 344         ftgmac100_reset(priv);
 345
 346         /* set the ethernet address */
 347         ftgmac100_set_mac(priv, plat->enetaddr);
 348
 349         /* disable all interrupts */
 350         writel(0, &ftgmac100->ier);
 351
 352         /* initialize descriptors */
 353         priv->tx_index = 0;
 354         priv->rx_index = 0;
 355
 356         for (i = 0; i < PKTBUFSTX; i++) {
 357                 priv->txdes[i].txdes2 = 0;
 358                 priv->txdes[i].txdes3 = 0;
 359                 priv->txdes[i].txdes0 = 0;
 360         }
 361         priv->txdes[PKTBUFSTX - 1].txdes0 = priv->txdes0_edotr_mask;
 362
 363         start = ((ulong)&priv->txdes[0]) & ~(ARCH_DMA_MINALIGN - 1);
 364         end = start + roundup(sizeof(priv->txdes), ARCH_DMA_MINALIGN);
 365         flush_dcache_range(start, end);
 366
 367         for (i = 0; i < PKTBUFSRX; i++) {
 368                 unsigned int ip_align = 0;
 369
 370                 dma_addr.addr = (dma_addr_t)net_rx_packets[i];
 371                 priv->rxdes[i].rxdes2 = FIELD_PREP(FTGMAC100_RXDES2_RXBUF_BADR_HI, dma_addr.hi);
 372                 /* For IP alignment */
 373                 if ((dma_addr.lo & (PKTALIGN - 1)) == 0)
 374                         ip_align = 2;
 375                 priv->rxdes[i].rxdes3 = dma_addr.lo + ip_align;
 376                 priv->rxdes[i].rxdes0 = 0;
 377         }
 378         priv->rxdes[PKTBUFSRX - 1].rxdes0 = priv->rxdes0_edorr_mask;
 379
 380         start = ((ulong)&priv->rxdes[0]) & ~(ARCH_DMA_MINALIGN - 1);
 381         end = start + roundup(sizeof(priv->rxdes), ARCH_DMA_MINALIGN);
 382         flush_dcache_range(start, end);
 383
 384         /* transmit ring */
 385         dma_addr.addr = (dma_addr_t)priv->txdes;
 386         writel(dma_addr.lo, &ftgmac100->txr_badr);
 387         writel(dma_addr.hi, &ftgmac100->txr_badr_hi);
 388
 389         /* receive ring */
 390         dma_addr.addr = (dma_addr_t)priv->rxdes;
 391         writel(dma_addr.lo, &ftgmac100->rxr_badr);
 392         writel(dma_addr.hi, &ftgmac100->rxr_badr_hi);
 393
 394         /* Configure TX/RX decsriptor size
 395          * This size is calculated based on cache line.
 396          */
 397         desc_size = ARCH_DMA_MINALIGN / FTGMAC100_DESC_UNIT;
 398         /* The descriptor size is at least 2 descriptor units. */
 399         if (desc_size < 2)
 400                 desc_size = 2;
 401         dblac = readl(&ftgmac100->dblac) & ~GENMASK(19, 12);
 402         dblac |= FTGMAC100_DBLAC_RXDES_SIZE(desc_size) | FTGMAC100_DBLAC_TXDES_SIZE(desc_size);
 403         writel(dblac, &ftgmac100->dblac);
 404
 405         /* poll receive descriptor automatically */
 406         writel(FTGMAC100_APTC_RXPOLL_CNT(1), &ftgmac100->aptc);
 407
 408         /* config receive buffer size register */
 409         writel(FTGMAC100_RBSR_SIZE(FTGMAC100_RBSR_DEFAULT), &ftgmac100->rbsr);
 410
 411         /* enable transmitter, receiver */
 412         maccr = FTGMAC100_MACCR_TXMAC_EN |
 413                 FTGMAC100_MACCR_RXMAC_EN |
 414                 FTGMAC100_MACCR_TXDMA_EN |
 415                 FTGMAC100_MACCR_RXDMA_EN |
 416                 FTGMAC100_MACCR_CRC_APD |
 417                 FTGMAC100_MACCR_FULLDUP |
 418                 FTGMAC100_MACCR_RX_RUNT |
 419                 FTGMAC100_MACCR_RX_BROADPKT;
 420
 421         if (priv->is_ast2700 && (priv->phydev->interface == PHY_INTERFACE_MODE_RMII ||
 422                                  priv->phydev->interface == PHY_INTERFACE_MODE_NCSI))
 423                 maccr |= FTGMAC100_MACCR_RMII_ENABLE;
 424
 425         writel(maccr, &ftgmac100->maccr);
 426
 427         ret = phy_startup(phydev);
 428         if (ret) {
 429                 dev_err(phydev->dev, "Could not start PHY\n");
 430                 return ret;
 431         }
 432
 433         ret = ftgmac100_phy_adjust_link(priv);
 434         if (ret) {
 435                 dev_err(phydev->dev,  "Could not adjust link\n");
 436                 return ret;
 437         }
 438
 439         printf("%s: link up, %d Mbps %s-duplex mac:%pM\n", phydev->dev->name,
 440                phydev->speed, phydev->duplex ? "full" : "half", plat->enetaddr);
 441
 442         return 0;
 443 }
 444
 445 static int ftgmac100_free_pkt(struct udevice *dev, uchar *packet, int length)
 446 {
 447         struct ftgmac100_data *priv = dev_get_priv(dev);
 448         struct ftgmac100_rxdes *curr_des = &priv->rxdes[priv->rx_index];
 449         ulong des_start = ((ulong)curr_des) & ~(ARCH_DMA_MINALIGN - 1);
 450         ulong des_end = des_start +
 451                 roundup(sizeof(*curr_des), ARCH_DMA_MINALIGN);
 452
 453         /*
 454          * Make sure there are no stale data in write-back over this area, which
 455          * might get written into the memory while the ftgmac100 also writes
 456          * into the same memory area.
 457          */
 458         flush_dcache_range((ulong)net_rx_packets[priv->rx_index],
 459                            (ulong)net_rx_packets[priv->rx_index] + PKTSIZE_ALIGN);
 460
 461         /* Release buffer to DMA and flush descriptor */
 462         curr_des->rxdes0 &= ~FTGMAC100_RXDES0_RXPKT_RDY;
 463         flush_dcache_range(des_start, des_end);
 464
 465         /* Move to next descriptor */
 466         priv->rx_index = (priv->rx_index + 1) % PKTBUFSRX;
 467
 468         return 0;
 469 }
 470
 471 /*
 472  * Get a data block via Ethernet
 473  */
 474 static int ftgmac100_recv(struct udevice *dev, int flags, uchar **packetp)
 475 {
 476         struct ftgmac100_data *priv = dev_get_priv(dev);
 477         struct ftgmac100_rxdes *curr_des = &priv->rxdes[priv->rx_index];
 478         unsigned short rxlen;
 479         ulong des_start = ((ulong)curr_des) & ~(ARCH_DMA_MINALIGN - 1);
 480         ulong des_end = des_start +
 481                 roundup(sizeof(*curr_des), ARCH_DMA_MINALIGN);
 482         union ftgmac100_dma_addr data_start = { .lo = 0, .hi = 0 };
 483         ulong data_end;
 484
 485         data_start.hi = FIELD_GET(FTGMAC100_RXDES2_RXBUF_BADR_HI, curr_des->rxdes2);
 486         data_start.lo = curr_des->rxdes3;
 487         invalidate_dcache_range(des_start, des_end);
 488
 489         if (!(curr_des->rxdes0 & FTGMAC100_RXDES0_RXPKT_RDY))
 490                 return -EAGAIN;
 491
 492         if (curr_des->rxdes0 & (FTGMAC100_RXDES0_RX_ERR |
 493                                 FTGMAC100_RXDES0_CRC_ERR |
 494                                 FTGMAC100_RXDES0_FTL |
 495                                 FTGMAC100_RXDES0_RUNT |
 496                                 FTGMAC100_RXDES0_RX_ODD_NB)) {
 497                 return -EAGAIN;
 498         }
 499
 500         rxlen = FTGMAC100_RXDES0_VDBC(curr_des->rxdes0);
 501
 502         debug("%s(): RX buffer %d, %x received\n",
 503                __func__, priv->rx_index, rxlen);
 504
 505         /* Invalidate received data */
 506         data_end = data_start.addr + roundup(rxlen, ARCH_DMA_MINALIGN);
 507         invalidate_dcache_range(data_start.addr, data_end);
 508         *packetp = (uchar *)data_start.addr;
 509
 510         return rxlen;
 511 }
 512
 513 static u32 ftgmac100_read_txdesc(const void *desc)
 514 {
 515         const struct ftgmac100_txdes *txdes = desc;
 516         ulong des_start = ((ulong)txdes) & ~(ARCH_DMA_MINALIGN - 1);
 517         ulong des_end = des_start + roundup(sizeof(*txdes), ARCH_DMA_MINALIGN);
 518
 519         invalidate_dcache_range(des_start, des_end);
 520
 521         return txdes->txdes0;
 522 }
 523
 524 BUILD_WAIT_FOR_BIT(ftgmac100_txdone, u32, ftgmac100_read_txdesc)
 525
 526 /*
 527  * Send a data block via Ethernet
 528  */
 529 static int ftgmac100_send(struct udevice *dev, void *packet, int length)
 530 {
 531         struct ftgmac100_data *priv = dev_get_priv(dev);
 532         struct ftgmac100 *ftgmac100 = priv->iobase;
 533         struct ftgmac100_txdes *curr_des = &priv->txdes[priv->tx_index];
 534         union ftgmac100_dma_addr dma_addr;
 535         ulong des_start = ((ulong)curr_des) & ~(ARCH_DMA_MINALIGN - 1);
 536         ulong des_end = des_start +
 537                 roundup(sizeof(*curr_des), ARCH_DMA_MINALIGN);
 538         ulong data_start;
 539         ulong data_end;
 540         int rc;
 541
 542         invalidate_dcache_range(des_start, des_end);
 543
 544         if (curr_des->txdes0 & FTGMAC100_TXDES0_TXDMA_OWN) {
 545                 dev_err(dev, "no TX descriptor available\n");
 546                 return -EPERM;
 547         }
 548
 549         debug("%s(%x, %x)\n", __func__, (int)packet, length);
 550
 551         length = (length < ETH_ZLEN) ? ETH_ZLEN : length;
 552
 553         dma_addr.addr = (dma_addr_t)packet;
 554         curr_des->txdes2 = FIELD_PREP(FTGMAC100_TXDES2_TXBUF_BADR_HI, dma_addr.hi);
 555         curr_des->txdes3 = dma_addr.lo;
 556
 557         /* Flush data to be sent */
 558         data_start = (ulong)dma_addr.addr;
 559         data_end = data_start + roundup(length, ARCH_DMA_MINALIGN);
 560         flush_dcache_range(data_start, data_end);
 561
 562         /* Only one segment on TXBUF */
 563         curr_des->txdes0 &= priv->txdes0_edotr_mask;
 564         curr_des->txdes0 |= FTGMAC100_TXDES0_FTS |
 565                             FTGMAC100_TXDES0_LTS |
 566                             FTGMAC100_TXDES0_TXBUF_SIZE(length) |
 567                             FTGMAC100_TXDES0_TXDMA_OWN ;
 568
 569         /* Flush modified buffer descriptor */
 570         flush_dcache_range(des_start, des_end);
 571
 572         /* Start transmit */
 573         writel(1, &ftgmac100->txpd);
 574
 575         rc = wait_for_bit_ftgmac100_txdone(curr_des,
 576                                            FTGMAC100_TXDES0_TXDMA_OWN, false,
 577                                            FTGMAC100_TX_TIMEOUT_MS, true);
 578         if (rc)
 579                 return rc;
 580
 581         debug("%s(): packet sent\n", __func__);
 582
 583         /* Move to next descriptor */
 584         priv->tx_index = (priv->tx_index + 1) % PKTBUFSTX;
 585
 586         return 0;
 587 }
 588
 589 static int ftgmac100_write_hwaddr(struct udevice *dev)
 590 {
 591         struct eth_pdata *pdata = dev_get_plat(dev);
 592         struct ftgmac100_data *priv = dev_get_priv(dev);
 593
 594         return ftgmac100_set_mac(priv, pdata->enetaddr);
 595 }
 596
 597 static int ftgmac_read_hwaddr(struct udevice *dev)
 598 {
 599         struct eth_pdata *pdata = dev_get_plat(dev);
 600         struct ftgmac100_data *priv = dev_get_priv(dev);
 601
 602         return ftgmac100_get_mac(priv, pdata->enetaddr);
 603 }
 604
 605 static int ftgmac100_of_to_plat(struct udevice *dev)
 606 {
 607         struct eth_pdata *pdata = dev_get_plat(dev);
 608         struct ftgmac100_data *priv = dev_get_priv(dev);
 609
 610         pdata->iobase = dev_read_addr(dev);
 611
 612         pdata->phy_interface = dev_read_phy_mode(dev);
 613         if (pdata->phy_interface == PHY_INTERFACE_MODE_NA)
 614                 return -EINVAL;
 615
 616         pdata->max_speed = dev_read_u32_default(dev, "max-speed", 0);
 617
 618         if (dev_get_driver_data(dev) == FTGMAC100_MODEL_ASPEED) {
 619                 priv->rxdes0_edorr_mask = BIT(30);
 620                 priv->txdes0_edotr_mask = BIT(30);
 621                 priv->is_ast2700 = false;
 622         } else if (dev_get_driver_data(dev) == FTGMAC100_MODEL_ASPEED_AST2700) {
 623                 priv->rxdes0_edorr_mask = BIT(30);
 624                 priv->txdes0_edotr_mask = BIT(30);
 625                 priv->is_ast2700 = true;
 626         } else {
 627                 priv->rxdes0_edorr_mask = BIT(15);
 628                 priv->txdes0_edotr_mask = BIT(15);
 629         }
 630
 631         priv->reset_ctl = devm_reset_control_get_optional(dev, NULL);
 632
 633         return clk_get_bulk(dev, &priv->clks);
 634 }
 635
 636 static int ftgmac100_probe(struct udevice *dev)
 637 {
 638         struct eth_pdata *pdata = dev_get_plat(dev);
 639         struct ftgmac100_data *priv = dev_get_priv(dev);
 640         int ret;
 641
 642         priv->iobase = (struct ftgmac100 *)pdata->iobase;
 643         priv->phy_mode = pdata->phy_interface;
 644         priv->max_speed = pdata->max_speed;
 645         priv->phy_addr = 0;
 646
 647         if (dev_read_bool(dev, "use-ncsi"))
 648                 priv->phy_mode = PHY_INTERFACE_MODE_NCSI;
 649
 650 #ifdef CONFIG_PHY_ADDR
 651         priv->phy_addr = CONFIG_PHY_ADDR;
 652 #endif
 653
 654         ret = clk_enable_bulk(&priv->clks);
 655         if (ret)
 656                 goto out;
 657
 658         if (priv->reset_ctl) {
 659                 ret = reset_deassert(priv->reset_ctl);
 660                 if (ret)
 661                         goto out;
 662         }
 663
 664         /*
 665          * If DM MDIO is enabled, the MDIO bus will be initialized later in
 666          * dm_eth_phy_connect
 667          */
 668         if (priv->phy_mode != PHY_INTERFACE_MODE_NCSI &&
 669             !IS_ENABLED(CONFIG_DM_MDIO)) {
 670                 ret = ftgmac100_mdio_init(dev);
 671                 if (ret) {
 672                         dev_err(dev, "Failed to initialize mdiobus: %d\n", ret);
 673                         goto out;
 674                 }
 675         }
 676
 677         ret = ftgmac100_phy_init(dev);
 678         if (ret) {
 679                 dev_err(dev, "Failed to initialize PHY: %d\n", ret);
 680                 goto out;
 681         }
 682
 683         ftgmac_read_hwaddr(dev);
 684
 685 out:
 686         if (ret)
 687                 clk_release_bulk(&priv->clks);
 688
 689         return ret;
 690 }
 691
 692 static int ftgmac100_remove(struct udevice *dev)
 693 {
 694         struct ftgmac100_data *priv = dev_get_priv(dev);
 695
 696         free(priv->phydev);
 697         mdio_unregister(priv->bus);
 698         mdio_free(priv->bus);
 699         if (priv->reset_ctl)
 700                 reset_assert(priv->reset_ctl);
 701         clk_release_bulk(&priv->clks);
 702
 703         return 0;
 704 }
 705
 706 static const struct eth_ops ftgmac100_ops = {
 707         .start  = ftgmac100_start,
 708         .send   = ftgmac100_send,
 709         .recv   = ftgmac100_recv,
 710         .stop   = ftgmac100_stop,
 711         .free_pkt = ftgmac100_free_pkt,
 712         .write_hwaddr = ftgmac100_write_hwaddr,
 713 };
 714
 715 static const struct udevice_id ftgmac100_ids[] = {
 716         { .compatible = "faraday,ftgmac100", .data = FTGMAC100_MODEL_FARADAY },
 717         { .compatible = "aspeed,ast2500-mac", .data = FTGMAC100_MODEL_ASPEED },
 718         { .compatible = "aspeed,ast2600-mac", .data = FTGMAC100_MODEL_ASPEED },
 719         { .compatible = "aspeed,ast2700-mac", .data = FTGMAC100_MODEL_ASPEED_AST2700 },
 720         {}
 721 };
 722
 723 U_BOOT_DRIVER(ftgmac100) = {
 724         .name   = "ftgmac100",
 725         .id     = UCLASS_ETH,
 726         .of_match = ftgmac100_ids,
 727         .of_to_plat = ftgmac100_of_to_plat,
 728         .probe  = ftgmac100_probe,
 729         .remove = ftgmac100_remove,
 730         .ops    = &ftgmac100_ops,
 731         .priv_auto      = sizeof(struct ftgmac100_data),
 732         .plat_auto      = sizeof(struct eth_pdata),
 733         .flags  = DM_FLAG_ALLOC_PRIV_DMA,
 734 };