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