drivers/net/designware.c

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