drivers/net/designware.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2010
   4  * Vipin Kumar, ST Micoelectronics, vipin.kumar@st.com.
   5  */
   6
   7 /*
   8  * Designware ethernet IP driver for U-Boot
   9  */
  10
  11 #include <common.h>
  12 #include <clk.h>
  13 #include <cpu_func.h>
  14 #include <dm.h>
  15 #include <errno.h>
  16 #include <log.h>
  17 #include <miiphy.h>
  18 #include <malloc.h>
  19 #include <net.h>
  20 #include <pci.h>
  21 #include <reset.h>
  22 #include <asm/cache.h>
  23 #include <dm/device_compat.h>
  24 #include <dm/devres.h>
  25 #include <linux/compiler.h>
  26 #include <linux/err.h>
  27 #include <linux/kernel.h>
  28 #include <asm/io.h>
  29 #include <power/regulator.h>
  30 #include "designware.h"
  31
  32 static int dw_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
  33 {
  34 #ifdef CONFIG_DM_ETH
  35         struct dw_eth_dev *priv = dev_get_priv((struct udevice *)bus->priv);
  36         struct eth_mac_regs *mac_p = priv->mac_regs_p;
  37 #else
  38         struct eth_mac_regs *mac_p = bus->priv;
  39 #endif
  40         ulong start;
  41         u16 miiaddr;
  42         int timeout = CONFIG_MDIO_TIMEOUT;
  43
  44         miiaddr = ((addr << MIIADDRSHIFT) & MII_ADDRMSK) |
  45                   ((reg << MIIREGSHIFT) & MII_REGMSK);
  46
  47         writel(miiaddr | MII_CLKRANGE_150_250M | MII_BUSY, &mac_p->miiaddr);
  48
  49         start = get_timer(0);
  50         while (get_timer(start) < timeout) {
  51                 if (!(readl(&mac_p->miiaddr) & MII_BUSY))
  52                         return readl(&mac_p->miidata);
  53                 udelay(10);
  54         };
  55
  56         return -ETIMEDOUT;
  57 }
  58
  59 static int dw_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
  60                         u16 val)
  61 {
  62 #ifdef CONFIG_DM_ETH
  63         struct dw_eth_dev *priv = dev_get_priv((struct udevice *)bus->priv);
  64         struct eth_mac_regs *mac_p = priv->mac_regs_p;
  65 #else
  66         struct eth_mac_regs *mac_p = bus->priv;
  67 #endif
  68         ulong start;
  69         u16 miiaddr;
  70         int ret = -ETIMEDOUT, timeout = CONFIG_MDIO_TIMEOUT;
  71
  72         writel(val, &mac_p->miidata);
  73         miiaddr = ((addr << MIIADDRSHIFT) & MII_ADDRMSK) |
  74                   ((reg << MIIREGSHIFT) & MII_REGMSK) | MII_WRITE;
  75
  76         writel(miiaddr | MII_CLKRANGE_150_250M | MII_BUSY, &mac_p->miiaddr);
  77
  78         start = get_timer(0);
  79         while (get_timer(start) < timeout) {
  80                 if (!(readl(&mac_p->miiaddr) & MII_BUSY)) {
  81                         ret = 0;
  82                         break;
  83                 }
  84                 udelay(10);
  85         };
  86
  87         return ret;
  88 }
  89
  90 #if defined(CONFIG_DM_ETH) && CONFIG_IS_ENABLED(DM_GPIO)
  91 static int dw_mdio_reset(struct mii_dev *bus)
  92 {
  93         struct udevice *dev = bus->priv;
  94         struct dw_eth_dev *priv = dev_get_priv(dev);
  95         struct dw_eth_pdata *pdata = dev_get_platdata(dev);
  96         int ret;
  97
  98         if (!dm_gpio_is_valid(&priv->reset_gpio))
  99                 return 0;
 100
 101         /* reset the phy */
 102         ret = dm_gpio_set_value(&priv->reset_gpio, 0);
 103         if (ret)
 104                 return ret;
 105
 106         udelay(pdata->reset_delays[0]);
 107
 108         ret = dm_gpio_set_value(&priv->reset_gpio, 1);
 109         if (ret)
 110                 return ret;
 111
 112         udelay(pdata->reset_delays[1]);
 113
 114         ret = dm_gpio_set_value(&priv->reset_gpio, 0);
 115         if (ret)
 116                 return ret;
 117
 118         udelay(pdata->reset_delays[2]);
 119
 120         return 0;
 121 }
 122 #endif
 123
 124 static int dw_mdio_init(const char *name, void *priv)
 125 {
 126         struct mii_dev *bus = mdio_alloc();
 127
 128         if (!bus) {
 129                 printf("Failed to allocate MDIO bus\n");
 130                 return -ENOMEM;
 131         }
 132
 133         bus->read = dw_mdio_read;
 134         bus->write = dw_mdio_write;
 135         snprintf(bus->name, sizeof(bus->name), "%s", name);
 136 #if defined(CONFIG_DM_ETH) && CONFIG_IS_ENABLED(DM_GPIO)
 137         bus->reset = dw_mdio_reset;
 138 #endif
 139
 140         bus->priv = priv;
 141
 142         return mdio_register(bus);
 143 }
 144
 145 static void tx_descs_init(struct dw_eth_dev *priv)
 146 {
 147         struct eth_dma_regs *dma_p = priv->dma_regs_p;
 148         struct dmamacdescr *desc_table_p = &priv->tx_mac_descrtable[0];
 149         char *txbuffs = &priv->txbuffs[0];
 150         struct dmamacdescr *desc_p;
 151         u32 idx;
 152
 153         for (idx = 0; idx < CONFIG_TX_DESCR_NUM; idx++) {
 154                 desc_p = &desc_table_p[idx];
 155                 desc_p->dmamac_addr = (ulong)&txbuffs[idx * CONFIG_ETH_BUFSIZE];
 156                 desc_p->dmamac_next = (ulong)&desc_table_p[idx + 1];
 157
 158 #if defined(CONFIG_DW_ALTDESCRIPTOR)
 159                 desc_p->txrx_status &= ~(DESC_TXSTS_TXINT | DESC_TXSTS_TXLAST |
 160                                 DESC_TXSTS_TXFIRST | DESC_TXSTS_TXCRCDIS |
 161                                 DESC_TXSTS_TXCHECKINSCTRL |
 162                                 DESC_TXSTS_TXRINGEND | DESC_TXSTS_TXPADDIS);
 163
 164                 desc_p->txrx_status |= DESC_TXSTS_TXCHAIN;
 165                 desc_p->dmamac_cntl = 0;
 166                 desc_p->txrx_status &= ~(DESC_TXSTS_MSK | DESC_TXSTS_OWNBYDMA);
 167 #else
 168                 desc_p->dmamac_cntl = DESC_TXCTRL_TXCHAIN;
 169                 desc_p->txrx_status = 0;
 170 #endif
 171         }
 172
 173         /* Correcting the last pointer of the chain */
 174         desc_p->dmamac_next = (ulong)&desc_table_p[0];
 175
 176         /* Flush all Tx buffer descriptors at once */
 177         flush_dcache_range((ulong)priv->tx_mac_descrtable,
 178                            (ulong)priv->tx_mac_descrtable +
 179                            sizeof(priv->tx_mac_descrtable));
 180
 181         writel((ulong)&desc_table_p[0], &dma_p->txdesclistaddr);
 182         priv->tx_currdescnum = 0;
 183 }
 184
 185 static void rx_descs_init(struct dw_eth_dev *priv)
 186 {
 187         struct eth_dma_regs *dma_p = priv->dma_regs_p;
 188         struct dmamacdescr *desc_table_p = &priv->rx_mac_descrtable[0];
 189         char *rxbuffs = &priv->rxbuffs[0];
 190         struct dmamacdescr *desc_p;
 191         u32 idx;
 192
 193         /* Before passing buffers to GMAC we need to make sure zeros
 194          * written there right after "priv" structure allocation were
 195          * flushed into RAM.
 196          * Otherwise there's a chance to get some of them flushed in RAM when
 197          * GMAC is already pushing data to RAM via DMA. This way incoming from
 198          * GMAC data will be corrupted. */
 199         flush_dcache_range((ulong)rxbuffs, (ulong)rxbuffs + RX_TOTAL_BUFSIZE);
 200
 201         for (idx = 0; idx < CONFIG_RX_DESCR_NUM; idx++) {
 202                 desc_p = &desc_table_p[idx];
 203                 desc_p->dmamac_addr = (ulong)&rxbuffs[idx * CONFIG_ETH_BUFSIZE];
 204                 desc_p->dmamac_next = (ulong)&desc_table_p[idx + 1];
 205
 206                 desc_p->dmamac_cntl =
 207                         (MAC_MAX_FRAME_SZ & DESC_RXCTRL_SIZE1MASK) |
 208                                       DESC_RXCTRL_RXCHAIN;
 209
 210                 desc_p->txrx_status = DESC_RXSTS_OWNBYDMA;
 211         }
 212
 213         /* Correcting the last pointer of the chain */
 214         desc_p->dmamac_next = (ulong)&desc_table_p[0];
 215
 216         /* Flush all Rx buffer descriptors at once */
 217         flush_dcache_range((ulong)priv->rx_mac_descrtable,
 218                            (ulong)priv->rx_mac_descrtable +
 219                            sizeof(priv->rx_mac_descrtable));
 220
 221         writel((ulong)&desc_table_p[0], &dma_p->rxdesclistaddr);
 222         priv->rx_currdescnum = 0;
 223 }
 224
 225 static int _dw_write_hwaddr(struct dw_eth_dev *priv, u8 *mac_id)
 226 {
 227         struct eth_mac_regs *mac_p = priv->mac_regs_p;
 228         u32 macid_lo, macid_hi;
 229
 230         macid_lo = mac_id[0] + (mac_id[1] << 8) + (mac_id[2] << 16) +
 231                    (mac_id[3] << 24);
 232         macid_hi = mac_id[4] + (mac_id[5] << 8);
 233
 234         writel(macid_hi, &mac_p->macaddr0hi);
 235         writel(macid_lo, &mac_p->macaddr0lo);
 236
 237         return 0;
 238 }
 239
 240 static int dw_adjust_link(struct dw_eth_dev *priv, struct eth_mac_regs *mac_p,
 241                           struct phy_device *phydev)
 242 {
 243         u32 conf = readl(&mac_p->conf) | FRAMEBURSTENABLE | DISABLERXOWN;
 244
 245         if (!phydev->link) {
 246                 printf("%s: No link.\n", phydev->dev->name);
 247                 return 0;
 248         }
 249
 250         if (phydev->speed != 1000)
 251                 conf |= MII_PORTSELECT;
 252         else
 253                 conf &= ~MII_PORTSELECT;
 254
 255         if (phydev->speed == 100)
 256                 conf |= FES_100;
 257
 258         if (phydev->duplex)
 259                 conf |= FULLDPLXMODE;
 260
 261         writel(conf, &mac_p->conf);
 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         return 0;
 268 }
 269
 270 static void _dw_eth_halt(struct dw_eth_dev *priv)
 271 {
 272         struct eth_mac_regs *mac_p = priv->mac_regs_p;
 273         struct eth_dma_regs *dma_p = priv->dma_regs_p;
 274
 275         writel(readl(&mac_p->conf) & ~(RXENABLE | TXENABLE), &mac_p->conf);
 276         writel(readl(&dma_p->opmode) & ~(RXSTART | TXSTART), &dma_p->opmode);
 277
 278         phy_shutdown(priv->phydev);
 279 }
 280
 281 int designware_eth_init(struct dw_eth_dev *priv, u8 *enetaddr)
 282 {
 283         struct eth_mac_regs *mac_p = priv->mac_regs_p;
 284         struct eth_dma_regs *dma_p = priv->dma_regs_p;
 285         unsigned int start;
 286         int ret;
 287
 288         writel(readl(&dma_p->busmode) | DMAMAC_SRST, &dma_p->busmode);
 289
 290         /*
 291          * When a MII PHY is used, we must set the PS bit for the DMA
 292          * reset to succeed.
 293          */
 294         if (priv->phydev->interface == PHY_INTERFACE_MODE_MII)
 295                 writel(readl(&mac_p->conf) | MII_PORTSELECT, &mac_p->conf);
 296         else
 297                 writel(readl(&mac_p->conf) & ~MII_PORTSELECT, &mac_p->conf);
 298
 299         start = get_timer(0);
 300         while (readl(&dma_p->busmode) & DMAMAC_SRST) {
 301                 if (get_timer(start) >= CONFIG_MACRESET_TIMEOUT) {
 302                         printf("DMA reset timeout\n");
 303                         return -ETIMEDOUT;
 304                 }
 305
 306                 mdelay(100);
 307         };
 308
 309         /*
 310          * Soft reset above clears HW address registers.
 311          * So we have to set it here once again.
 312          */
 313         _dw_write_hwaddr(priv, enetaddr);
 314
 315         rx_descs_init(priv);
 316         tx_descs_init(priv);
 317
 318         writel(FIXEDBURST | PRIORXTX_41 | DMA_PBL, &dma_p->busmode);
 319
 320 #ifndef CONFIG_DW_MAC_FORCE_THRESHOLD_MODE
 321         writel(readl(&dma_p->opmode) | FLUSHTXFIFO | STOREFORWARD,
 322                &dma_p->opmode);
 323 #else
 324         writel(readl(&dma_p->opmode) | FLUSHTXFIFO,
 325                &dma_p->opmode);
 326 #endif
 327
 328         writel(readl(&dma_p->opmode) | RXSTART | TXSTART, &dma_p->opmode);
 329
 330 #ifdef CONFIG_DW_AXI_BURST_LEN
 331         writel((CONFIG_DW_AXI_BURST_LEN & 0x1FF >> 1), &dma_p->axibus);
 332 #endif
 333
 334         /* Start up the PHY */
 335         ret = phy_startup(priv->phydev);
 336         if (ret) {
 337                 printf("Could not initialize PHY %s\n",
 338                        priv->phydev->dev->name);
 339                 return ret;
 340         }
 341
 342         ret = dw_adjust_link(priv, mac_p, priv->phydev);
 343         if (ret)
 344                 return ret;
 345
 346         return 0;
 347 }
 348
 349 int designware_eth_enable(struct dw_eth_dev *priv)
 350 {
 351         struct eth_mac_regs *mac_p = priv->mac_regs_p;
 352
 353         if (!priv->phydev->link)
 354                 return -EIO;
 355
 356         writel(readl(&mac_p->conf) | RXENABLE | TXENABLE, &mac_p->conf);
 357
 358         return 0;
 359 }
 360
 361 #define ETH_ZLEN        60
 362
 363 static int _dw_eth_send(struct dw_eth_dev *priv, void *packet, int length)
 364 {
 365         struct eth_dma_regs *dma_p = priv->dma_regs_p;
 366         u32 desc_num = priv->tx_currdescnum;
 367         struct dmamacdescr *desc_p = &priv->tx_mac_descrtable[desc_num];
 368         ulong desc_start = (ulong)desc_p;
 369         ulong desc_end = desc_start +
 370                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
 371         ulong data_start = desc_p->dmamac_addr;
 372         ulong data_end = data_start + roundup(length, ARCH_DMA_MINALIGN);
 373         /*
 374          * Strictly we only need to invalidate the "txrx_status" field
 375          * for the following check, but on some platforms we cannot
 376          * invalidate only 4 bytes, so we flush the entire descriptor,
 377          * which is 16 bytes in total. This is safe because the
 378          * individual descriptors in the array are each aligned to
 379          * ARCH_DMA_MINALIGN and padded appropriately.
 380          */
 381         invalidate_dcache_range(desc_start, desc_end);
 382
 383         /* Check if the descriptor is owned by CPU */
 384         if (desc_p->txrx_status & DESC_TXSTS_OWNBYDMA) {
 385                 printf("CPU not owner of tx frame\n");
 386                 return -EPERM;
 387         }
 388
 389         memcpy((void *)data_start, packet, length);
 390         if (length < ETH_ZLEN) {
 391                 memset(&((char *)data_start)[length], 0, ETH_ZLEN - length);
 392                 length = ETH_ZLEN;
 393         }
 394
 395         /* Flush data to be sent */
 396         flush_dcache_range(data_start, data_end);
 397
 398 #if defined(CONFIG_DW_ALTDESCRIPTOR)
 399         desc_p->txrx_status |= DESC_TXSTS_TXFIRST | DESC_TXSTS_TXLAST;
 400         desc_p->dmamac_cntl = (desc_p->dmamac_cntl & ~DESC_TXCTRL_SIZE1MASK) |
 401                               ((length << DESC_TXCTRL_SIZE1SHFT) &
 402                               DESC_TXCTRL_SIZE1MASK);
 403
 404         desc_p->txrx_status &= ~(DESC_TXSTS_MSK);
 405         desc_p->txrx_status |= DESC_TXSTS_OWNBYDMA;
 406 #else
 407         desc_p->dmamac_cntl = (desc_p->dmamac_cntl & ~DESC_TXCTRL_SIZE1MASK) |
 408                               ((length << DESC_TXCTRL_SIZE1SHFT) &
 409                               DESC_TXCTRL_SIZE1MASK) | DESC_TXCTRL_TXLAST |
 410                               DESC_TXCTRL_TXFIRST;
 411
 412         desc_p->txrx_status = DESC_TXSTS_OWNBYDMA;
 413 #endif
 414
 415         /* Flush modified buffer descriptor */
 416         flush_dcache_range(desc_start, desc_end);
 417
 418         /* Test the wrap-around condition. */
 419         if (++desc_num >= CONFIG_TX_DESCR_NUM)
 420                 desc_num = 0;
 421
 422         priv->tx_currdescnum = desc_num;
 423
 424         /* Start the transmission */
 425         writel(POLL_DATA, &dma_p->txpolldemand);
 426
 427         return 0;
 428 }
 429
 430 static int _dw_eth_recv(struct dw_eth_dev *priv, uchar **packetp)
 431 {
 432         u32 status, desc_num = priv->rx_currdescnum;
 433         struct dmamacdescr *desc_p = &priv->rx_mac_descrtable[desc_num];
 434         int length = -EAGAIN;
 435         ulong desc_start = (ulong)desc_p;
 436         ulong desc_end = desc_start +
 437                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
 438         ulong data_start = desc_p->dmamac_addr;
 439         ulong data_end;
 440
 441         /* Invalidate entire buffer descriptor */
 442         invalidate_dcache_range(desc_start, desc_end);
 443
 444         status = desc_p->txrx_status;
 445
 446         /* Check  if the owner is the CPU */
 447         if (!(status & DESC_RXSTS_OWNBYDMA)) {
 448
 449                 length = (status & DESC_RXSTS_FRMLENMSK) >>
 450                          DESC_RXSTS_FRMLENSHFT;
 451
 452                 /* Invalidate received data */
 453                 data_end = data_start + roundup(length, ARCH_DMA_MINALIGN);
 454                 invalidate_dcache_range(data_start, data_end);
 455                 *packetp = (uchar *)(ulong)desc_p->dmamac_addr;
 456         }
 457
 458         return length;
 459 }
 460
 461 static int _dw_free_pkt(struct dw_eth_dev *priv)
 462 {
 463         u32 desc_num = priv->rx_currdescnum;
 464         struct dmamacdescr *desc_p = &priv->rx_mac_descrtable[desc_num];
 465         ulong desc_start = (ulong)desc_p;
 466         ulong desc_end = desc_start +
 467                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
 468
 469         /*
 470          * Make the current descriptor valid again and go to
 471          * the next one
 472          */
 473         desc_p->txrx_status |= DESC_RXSTS_OWNBYDMA;
 474
 475         /* Flush only status field - others weren't changed */
 476         flush_dcache_range(desc_start, desc_end);
 477
 478         /* Test the wrap-around condition. */
 479         if (++desc_num >= CONFIG_RX_DESCR_NUM)
 480                 desc_num = 0;
 481         priv->rx_currdescnum = desc_num;
 482
 483         return 0;
 484 }
 485
 486 static int dw_phy_init(struct dw_eth_dev *priv, void *dev)
 487 {
 488         struct phy_device *phydev;
 489         int phy_addr = -1, ret;
 490
 491 #ifdef CONFIG_PHY_ADDR
 492         phy_addr = CONFIG_PHY_ADDR;
 493 #endif
 494
 495         phydev = phy_connect(priv->bus, phy_addr, dev, priv->interface);
 496         if (!phydev)
 497                 return -ENODEV;
 498
 499         phydev->supported &= PHY_GBIT_FEATURES;
 500         if (priv->max_speed) {
 501                 ret = phy_set_supported(phydev, priv->max_speed);
 502                 if (ret)
 503                         return ret;
 504         }
 505         phydev->advertising = phydev->supported;
 506
 507         priv->phydev = phydev;
 508         phy_config(phydev);
 509
 510         return 0;
 511 }
 512
 513 #ifndef CONFIG_DM_ETH
 514 static int dw_eth_init(struct eth_device *dev, bd_t *bis)
 515 {
 516         int ret;
 517
 518         ret = designware_eth_init(dev->priv, dev->enetaddr);
 519         if (!ret)
 520                 ret = designware_eth_enable(dev->priv);
 521
 522         return ret;
 523 }
 524
 525 static int dw_eth_send(struct eth_device *dev, void *packet, int length)
 526 {
 527         return _dw_eth_send(dev->priv, packet, length);
 528 }
 529
 530 static int dw_eth_recv(struct eth_device *dev)
 531 {
 532         uchar *packet;
 533         int length;
 534
 535         length = _dw_eth_recv(dev->priv, &packet);
 536         if (length == -EAGAIN)
 537                 return 0;
 538         net_process_received_packet(packet, length);
 539
 540         _dw_free_pkt(dev->priv);
 541
 542         return 0;
 543 }
 544
 545 static void dw_eth_halt(struct eth_device *dev)
 546 {
 547         return _dw_eth_halt(dev->priv);
 548 }
 549
 550 static int dw_write_hwaddr(struct eth_device *dev)
 551 {
 552         return _dw_write_hwaddr(dev->priv, dev->enetaddr);
 553 }
 554
 555 int designware_initialize(ulong base_addr, u32 interface)
 556 {
 557         struct eth_device *dev;
 558         struct dw_eth_dev *priv;
 559
 560         dev = (struct eth_device *) malloc(sizeof(struct eth_device));
 561         if (!dev)
 562                 return -ENOMEM;
 563
 564         /*
 565          * Since the priv structure contains the descriptors which need a strict
 566          * buswidth alignment, memalign is used to allocate memory
 567          */
 568         priv = (struct dw_eth_dev *) memalign(ARCH_DMA_MINALIGN,
 569                                               sizeof(struct dw_eth_dev));
 570         if (!priv) {
 571                 free(dev);
 572                 return -ENOMEM;
 573         }
 574
 575         if ((phys_addr_t)priv + sizeof(*priv) > (1ULL << 32)) {
 576                 printf("designware: buffers are outside DMA memory\n");
 577                 return -EINVAL;
 578         }
 579
 580         memset(dev, 0, sizeof(struct eth_device));
 581         memset(priv, 0, sizeof(struct dw_eth_dev));
 582
 583         sprintf(dev->name, "dwmac.%lx", base_addr);
 584         dev->iobase = (int)base_addr;
 585         dev->priv = priv;
 586
 587         priv->dev = dev;
 588         priv->mac_regs_p = (struct eth_mac_regs *)base_addr;
 589         priv->dma_regs_p = (struct eth_dma_regs *)(base_addr +
 590                         DW_DMA_BASE_OFFSET);
 591
 592         dev->init = dw_eth_init;
 593         dev->send = dw_eth_send;
 594         dev->recv = dw_eth_recv;
 595         dev->halt = dw_eth_halt;
 596         dev->write_hwaddr = dw_write_hwaddr;
 597
 598         eth_register(dev);
 599
 600         priv->interface = interface;
 601
 602         dw_mdio_init(dev->name, priv->mac_regs_p);
 603         priv->bus = miiphy_get_dev_by_name(dev->name);
 604
 605         return dw_phy_init(priv, dev);
 606 }
 607 #endif
 608
 609 #ifdef CONFIG_DM_ETH
 610 static int designware_eth_start(struct udevice *dev)
 611 {
 612         struct eth_pdata *pdata = dev_get_platdata(dev);
 613         struct dw_eth_dev *priv = dev_get_priv(dev);
 614         int ret;
 615
 616         ret = designware_eth_init(priv, pdata->enetaddr);
 617         if (ret)
 618                 return ret;
 619         ret = designware_eth_enable(priv);
 620         if (ret)
 621                 return ret;
 622
 623         return 0;
 624 }
 625
 626 int designware_eth_send(struct udevice *dev, void *packet, int length)
 627 {
 628         struct dw_eth_dev *priv = dev_get_priv(dev);
 629
 630         return _dw_eth_send(priv, packet, length);
 631 }
 632
 633 int designware_eth_recv(struct udevice *dev, int flags, uchar **packetp)
 634 {
 635         struct dw_eth_dev *priv = dev_get_priv(dev);
 636
 637         return _dw_eth_recv(priv, packetp);
 638 }
 639
 640 int designware_eth_free_pkt(struct udevice *dev, uchar *packet, int length)
 641 {
 642         struct dw_eth_dev *priv = dev_get_priv(dev);
 643
 644         return _dw_free_pkt(priv);
 645 }
 646
 647 void designware_eth_stop(struct udevice *dev)
 648 {
 649         struct dw_eth_dev *priv = dev_get_priv(dev);
 650
 651         return _dw_eth_halt(priv);
 652 }
 653
 654 int designware_eth_write_hwaddr(struct udevice *dev)
 655 {
 656         struct eth_pdata *pdata = dev_get_platdata(dev);
 657         struct dw_eth_dev *priv = dev_get_priv(dev);
 658
 659         return _dw_write_hwaddr(priv, pdata->enetaddr);
 660 }
 661
 662 static int designware_eth_bind(struct udevice *dev)
 663 {
 664 #ifdef CONFIG_DM_PCI
 665         static int num_cards;
 666         char name[20];
 667
 668         /* Create a unique device name for PCI type devices */
 669         if (device_is_on_pci_bus(dev)) {
 670                 sprintf(name, "eth_designware#%u", num_cards++);
 671                 device_set_name(dev, name);
 672         }
 673 #endif
 674
 675         return 0;
 676 }
 677
 678 int designware_eth_probe(struct udevice *dev)
 679 {
 680         struct eth_pdata *pdata = dev_get_platdata(dev);
 681         struct dw_eth_dev *priv = dev_get_priv(dev);
 682         u32 iobase = pdata->iobase;
 683         ulong ioaddr;
 684         int ret, err;
 685         struct reset_ctl_bulk reset_bulk;
 686 #ifdef CONFIG_CLK
 687         int i, clock_nb;
 688
 689         priv->clock_count = 0;
 690         clock_nb = dev_count_phandle_with_args(dev, "clocks", "#clock-cells");
 691         if (clock_nb > 0) {
 692                 priv->clocks = devm_kcalloc(dev, clock_nb, sizeof(struct clk),
 693                                             GFP_KERNEL);
 694                 if (!priv->clocks)
 695                         return -ENOMEM;
 696
 697                 for (i = 0; i < clock_nb; i++) {
 698                         err = clk_get_by_index(dev, i, &priv->clocks[i]);
 699                         if (err < 0)
 700                                 break;
 701
 702                         err = clk_enable(&priv->clocks[i]);
 703                         if (err && err != -ENOSYS && err != -ENOTSUPP) {
 704                                 pr_err("failed to enable clock %d\n", i);
 705                                 clk_free(&priv->clocks[i]);
 706                                 goto clk_err;
 707                         }
 708                         priv->clock_count++;
 709                 }
 710         } else if (clock_nb != -ENOENT) {
 711                 pr_err("failed to get clock phandle(%d)\n", clock_nb);
 712                 return clock_nb;
 713         }
 714 #endif
 715
 716 #if defined(CONFIG_DM_REGULATOR)
 717         struct udevice *phy_supply;
 718
 719         ret = device_get_supply_regulator(dev, "phy-supply",
 720                                           &phy_supply);
 721         if (ret) {
 722                 debug("%s: No phy supply\n", dev->name);
 723         } else {
 724                 ret = regulator_set_enable(phy_supply, true);
 725                 if (ret) {
 726                         puts("Error enabling phy supply\n");
 727                         return ret;
 728                 }
 729         }
 730 #endif
 731
 732         ret = reset_get_bulk(dev, &reset_bulk);
 733         if (ret)
 734                 dev_warn(dev, "Can't get reset: %d\n", ret);
 735         else
 736                 reset_deassert_bulk(&reset_bulk);
 737
 738 #ifdef CONFIG_DM_PCI
 739         /*
 740          * If we are on PCI bus, either directly attached to a PCI root port,
 741          * or via a PCI bridge, fill in platdata before we probe the hardware.
 742          */
 743         if (device_is_on_pci_bus(dev)) {
 744                 dm_pci_read_config32(dev, PCI_BASE_ADDRESS_0, &iobase);
 745                 iobase &= PCI_BASE_ADDRESS_MEM_MASK;
 746                 iobase = dm_pci_mem_to_phys(dev, iobase);
 747
 748                 pdata->iobase = iobase;
 749                 pdata->phy_interface = PHY_INTERFACE_MODE_RMII;
 750         }
 751 #endif
 752
 753         debug("%s, iobase=%x, priv=%p\n", __func__, iobase, priv);
 754         ioaddr = iobase;
 755         priv->mac_regs_p = (struct eth_mac_regs *)ioaddr;
 756         priv->dma_regs_p = (struct eth_dma_regs *)(ioaddr + DW_DMA_BASE_OFFSET);
 757         priv->interface = pdata->phy_interface;
 758         priv->max_speed = pdata->max_speed;
 759
 760         ret = dw_mdio_init(dev->name, dev);
 761         if (ret) {
 762                 err = ret;
 763                 goto mdio_err;
 764         }
 765         priv->bus = miiphy_get_dev_by_name(dev->name);
 766
 767         ret = dw_phy_init(priv, dev);
 768         debug("%s, ret=%d\n", __func__, ret);
 769         if (!ret)
 770                 return 0;
 771
 772         /* continue here for cleanup if no PHY found */
 773         err = ret;
 774         mdio_unregister(priv->bus);
 775         mdio_free(priv->bus);
 776 mdio_err:
 777
 778 #ifdef CONFIG_CLK
 779 clk_err:
 780         ret = clk_release_all(priv->clocks, priv->clock_count);
 781         if (ret)
 782                 pr_err("failed to disable all clocks\n");
 783
 784 #endif
 785         return err;
 786 }
 787
 788 static int designware_eth_remove(struct udevice *dev)
 789 {
 790         struct dw_eth_dev *priv = dev_get_priv(dev);
 791
 792         free(priv->phydev);
 793         mdio_unregister(priv->bus);
 794         mdio_free(priv->bus);
 795
 796 #ifdef CONFIG_CLK
 797         return clk_release_all(priv->clocks, priv->clock_count);
 798 #else
 799         return 0;
 800 #endif
 801 }
 802
 803 const struct eth_ops designware_eth_ops = {
 804         .start                  = designware_eth_start,
 805         .send                   = designware_eth_send,
 806         .recv                   = designware_eth_recv,
 807         .free_pkt               = designware_eth_free_pkt,
 808         .stop                   = designware_eth_stop,
 809         .write_hwaddr           = designware_eth_write_hwaddr,
 810 };
 811
 812 int designware_eth_ofdata_to_platdata(struct udevice *dev)
 813 {
 814         struct dw_eth_pdata *dw_pdata = dev_get_platdata(dev);
 815 #if CONFIG_IS_ENABLED(DM_GPIO)
 816         struct dw_eth_dev *priv = dev_get_priv(dev);
 817 #endif
 818         struct eth_pdata *pdata = &dw_pdata->eth_pdata;
 819         const char *phy_mode;
 820 #if CONFIG_IS_ENABLED(DM_GPIO)
 821         int reset_flags = GPIOD_IS_OUT;
 822 #endif
 823         int ret = 0;
 824
 825         pdata->iobase = dev_read_addr(dev);
 826         pdata->phy_interface = -1;
 827         phy_mode = dev_read_string(dev, "phy-mode");
 828         if (phy_mode)
 829                 pdata->phy_interface = phy_get_interface_by_name(phy_mode);
 830         if (pdata->phy_interface == -1) {
 831                 debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);
 832                 return -EINVAL;
 833         }
 834
 835         pdata->max_speed = dev_read_u32_default(dev, "max-speed", 0);
 836
 837 #if CONFIG_IS_ENABLED(DM_GPIO)
 838         if (dev_read_bool(dev, "snps,reset-active-low"))
 839                 reset_flags |= GPIOD_ACTIVE_LOW;
 840
 841         ret = gpio_request_by_name(dev, "snps,reset-gpio", 0,
 842                 &priv->reset_gpio, reset_flags);
 843         if (ret == 0) {
 844                 ret = dev_read_u32_array(dev, "snps,reset-delays-us",
 845                                          dw_pdata->reset_delays, 3);
 846         } else if (ret == -ENOENT) {
 847                 ret = 0;
 848         }
 849 #endif
 850
 851         return ret;
 852 }
 853
 854 static const struct udevice_id designware_eth_ids[] = {
 855         { .compatible = "allwinner,sun7i-a20-gmac" },
 856         { .compatible = "amlogic,meson6-dwmac" },
 857         { .compatible = "amlogic,meson-gx-dwmac" },
 858         { .compatible = "amlogic,meson-gxbb-dwmac" },
 859         { .compatible = "amlogic,meson-axg-dwmac" },
 860         { .compatible = "st,stm32-dwmac" },
 861         { .compatible = "snps,arc-dwmac-3.70a" },
 862         { }
 863 };
 864
 865 U_BOOT_DRIVER(eth_designware) = {
 866         .name   = "eth_designware",
 867         .id     = UCLASS_ETH,
 868         .of_match = designware_eth_ids,
 869         .ofdata_to_platdata = designware_eth_ofdata_to_platdata,
 870         .bind   = designware_eth_bind,
 871         .probe  = designware_eth_probe,
 872         .remove = designware_eth_remove,
 873         .ops    = &designware_eth_ops,
 874         .priv_auto_alloc_size = sizeof(struct dw_eth_dev),
 875         .platdata_auto_alloc_size = sizeof(struct dw_eth_pdata),
 876         .flags = DM_FLAG_ALLOC_PRIV_DMA,
 877 };
 878
 879 static struct pci_device_id supported[] = {
 880         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_QRK_EMAC) },
 881         { }
 882 };
 883
 884 U_BOOT_PCI_DEVICE(eth_designware, supported);
 885 #endif