drivers/net/macb.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2005-2006 Atmel Corporation
   4  */
   5 #include <common.h>
   6 #include <clk.h>
   7 #include <dm.h>
   8
   9 /*
  10  * The u-boot networking stack is a little weird.  It seems like the
  11  * networking core allocates receive buffers up front without any
  12  * regard to the hardware that's supposed to actually receive those
  13  * packets.
  14  *
  15  * The MACB receives packets into 128-byte receive buffers, so the
  16  * buffers allocated by the core isn't very practical to use.  We'll
  17  * allocate our own, but we need one such buffer in case a packet
  18  * wraps around the DMA ring so that we have to copy it.
  19  *
  20  * Therefore, define CONFIG_SYS_RX_ETH_BUFFER to 1 in the board-specific
  21  * configuration header.  This way, the core allocates one RX buffer
  22  * and one TX buffer, each of which can hold a ethernet packet of
  23  * maximum size.
  24  *
  25  * For some reason, the networking core unconditionally specifies a
  26  * 32-byte packet "alignment" (which really should be called
  27  * "padding").  MACB shouldn't need that, but we'll refrain from any
  28  * core modifications here...
  29  */
  30
  31 #include <net.h>
  32 #ifndef CONFIG_DM_ETH
  33 #include <netdev.h>
  34 #endif
  35 #include <malloc.h>
  36 #include <miiphy.h>
  37
  38 #include <linux/mii.h>
  39 #include <asm/io.h>
  40 #include <asm/dma-mapping.h>
  41 #include <asm/arch/clk.h>
  42 #include <linux/errno.h>
  43
  44 #include "macb.h"
  45
  46 DECLARE_GLOBAL_DATA_PTR;
  47
  48 #define MACB_RX_BUFFER_SIZE             4096
  49 #define MACB_RX_RING_SIZE               (MACB_RX_BUFFER_SIZE / 128)
  50 #define MACB_TX_RING_SIZE               16
  51 #define MACB_TX_TIMEOUT         1000
  52 #define MACB_AUTONEG_TIMEOUT    5000000
  53
  54 #ifdef CONFIG_MACB_ZYNQ
  55 /* INCR4 AHB bursts */
  56 #define MACB_ZYNQ_GEM_DMACR_BLENGTH             0x00000004
  57 /* Use full configured addressable space (8 Kb) */
  58 #define MACB_ZYNQ_GEM_DMACR_RXSIZE              0x00000300
  59 /* Use full configured addressable space (4 Kb) */
  60 #define MACB_ZYNQ_GEM_DMACR_TXSIZE              0x00000400
  61 /* Set RXBUF with use of 128 byte */
  62 #define MACB_ZYNQ_GEM_DMACR_RXBUF               0x00020000
  63 #define MACB_ZYNQ_GEM_DMACR_INIT \
  64                                 (MACB_ZYNQ_GEM_DMACR_BLENGTH | \
  65                                 MACB_ZYNQ_GEM_DMACR_RXSIZE | \
  66                                 MACB_ZYNQ_GEM_DMACR_TXSIZE | \
  67                                 MACB_ZYNQ_GEM_DMACR_RXBUF)
  68 #endif
  69
  70 struct macb_dma_desc {
  71         u32     addr;
  72         u32     ctrl;
  73 };
  74
  75 #define DMA_DESC_BYTES(n)       (n * sizeof(struct macb_dma_desc))
  76 #define MACB_TX_DMA_DESC_SIZE   (DMA_DESC_BYTES(MACB_TX_RING_SIZE))
  77 #define MACB_RX_DMA_DESC_SIZE   (DMA_DESC_BYTES(MACB_RX_RING_SIZE))
  78 #define MACB_TX_DUMMY_DMA_DESC_SIZE     (DMA_DESC_BYTES(1))
  79
  80 #define RXBUF_FRMLEN_MASK       0x00000fff
  81 #define TXBUF_FRMLEN_MASK       0x000007ff
  82
  83 struct macb_device {
  84         void                    *regs;
  85
  86         unsigned int            rx_tail;
  87         unsigned int            tx_head;
  88         unsigned int            tx_tail;
  89         unsigned int            next_rx_tail;
  90         bool                    wrapped;
  91
  92         void                    *rx_buffer;
  93         void                    *tx_buffer;
  94         struct macb_dma_desc    *rx_ring;
  95         struct macb_dma_desc    *tx_ring;
  96
  97         unsigned long           rx_buffer_dma;
  98         unsigned long           rx_ring_dma;
  99         unsigned long           tx_ring_dma;
 100
 101         struct macb_dma_desc    *dummy_desc;
 102         unsigned long           dummy_desc_dma;
 103
 104         const struct device     *dev;
 105 #ifndef CONFIG_DM_ETH
 106         struct eth_device       netdev;
 107 #endif
 108         unsigned short          phy_addr;
 109         struct mii_dev          *bus;
 110 #ifdef CONFIG_PHYLIB
 111         struct phy_device       *phydev;
 112 #endif
 113
 114 #ifdef CONFIG_DM_ETH
 115 #ifdef CONFIG_CLK
 116         unsigned long           pclk_rate;
 117 #endif
 118         phy_interface_t         phy_interface;
 119 #endif
 120 };
 121 #ifndef CONFIG_DM_ETH
 122 #define to_macb(_nd) container_of(_nd, struct macb_device, netdev)
 123 #endif
 124
 125 static int macb_is_gem(struct macb_device *macb)
 126 {
 127         return MACB_BFEXT(IDNUM, macb_readl(macb, MID)) >= 0x2;
 128 }
 129
 130 #ifndef cpu_is_sama5d2
 131 #define cpu_is_sama5d2() 0
 132 #endif
 133
 134 #ifndef cpu_is_sama5d4
 135 #define cpu_is_sama5d4() 0
 136 #endif
 137
 138 static int gem_is_gigabit_capable(struct macb_device *macb)
 139 {
 140         /*
 141          * The GEM controllers embedded in SAMA5D2 and SAMA5D4 are
 142          * configured to support only 10/100.
 143          */
 144         return macb_is_gem(macb) && !cpu_is_sama5d2() && !cpu_is_sama5d4();
 145 }
 146
 147 static void macb_mdio_write(struct macb_device *macb, u8 reg, u16 value)
 148 {
 149         unsigned long netctl;
 150         unsigned long netstat;
 151         unsigned long frame;
 152
 153         netctl = macb_readl(macb, NCR);
 154         netctl |= MACB_BIT(MPE);
 155         macb_writel(macb, NCR, netctl);
 156
 157         frame = (MACB_BF(SOF, 1)
 158                  | MACB_BF(RW, 1)
 159                  | MACB_BF(PHYA, macb->phy_addr)
 160                  | MACB_BF(REGA, reg)
 161                  | MACB_BF(CODE, 2)
 162                  | MACB_BF(DATA, value));
 163         macb_writel(macb, MAN, frame);
 164
 165         do {
 166                 netstat = macb_readl(macb, NSR);
 167         } while (!(netstat & MACB_BIT(IDLE)));
 168
 169         netctl = macb_readl(macb, NCR);
 170         netctl &= ~MACB_BIT(MPE);
 171         macb_writel(macb, NCR, netctl);
 172 }
 173
 174 static u16 macb_mdio_read(struct macb_device *macb, u8 reg)
 175 {
 176         unsigned long netctl;
 177         unsigned long netstat;
 178         unsigned long frame;
 179
 180         netctl = macb_readl(macb, NCR);
 181         netctl |= MACB_BIT(MPE);
 182         macb_writel(macb, NCR, netctl);
 183
 184         frame = (MACB_BF(SOF, 1)
 185                  | MACB_BF(RW, 2)
 186                  | MACB_BF(PHYA, macb->phy_addr)
 187                  | MACB_BF(REGA, reg)
 188                  | MACB_BF(CODE, 2));
 189         macb_writel(macb, MAN, frame);
 190
 191         do {
 192                 netstat = macb_readl(macb, NSR);
 193         } while (!(netstat & MACB_BIT(IDLE)));
 194
 195         frame = macb_readl(macb, MAN);
 196
 197         netctl = macb_readl(macb, NCR);
 198         netctl &= ~MACB_BIT(MPE);
 199         macb_writel(macb, NCR, netctl);
 200
 201         return MACB_BFEXT(DATA, frame);
 202 }
 203
 204 void __weak arch_get_mdio_control(const char *name)
 205 {
 206         return;
 207 }
 208
 209 #if defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB)
 210
 211 int macb_miiphy_read(struct mii_dev *bus, int phy_adr, int devad, int reg)
 212 {
 213         u16 value = 0;
 214 #ifdef CONFIG_DM_ETH
 215         struct udevice *dev = eth_get_dev_by_name(bus->name);
 216         struct macb_device *macb = dev_get_priv(dev);
 217 #else
 218         struct eth_device *dev = eth_get_dev_by_name(bus->name);
 219         struct macb_device *macb = to_macb(dev);
 220 #endif
 221
 222         if (macb->phy_addr != phy_adr)
 223                 return -1;
 224
 225         arch_get_mdio_control(bus->name);
 226         value = macb_mdio_read(macb, reg);
 227
 228         return value;
 229 }
 230
 231 int macb_miiphy_write(struct mii_dev *bus, int phy_adr, int devad, int reg,
 232                       u16 value)
 233 {
 234 #ifdef CONFIG_DM_ETH
 235         struct udevice *dev = eth_get_dev_by_name(bus->name);
 236         struct macb_device *macb = dev_get_priv(dev);
 237 #else
 238         struct eth_device *dev = eth_get_dev_by_name(bus->name);
 239         struct macb_device *macb = to_macb(dev);
 240 #endif
 241
 242         if (macb->phy_addr != phy_adr)
 243                 return -1;
 244
 245         arch_get_mdio_control(bus->name);
 246         macb_mdio_write(macb, reg, value);
 247
 248         return 0;
 249 }
 250 #endif
 251
 252 #define RX      1
 253 #define TX      0
 254 static inline void macb_invalidate_ring_desc(struct macb_device *macb, bool rx)
 255 {
 256         if (rx)
 257                 invalidate_dcache_range(macb->rx_ring_dma,
 258                         ALIGN(macb->rx_ring_dma + MACB_RX_DMA_DESC_SIZE,
 259                               PKTALIGN));
 260         else
 261                 invalidate_dcache_range(macb->tx_ring_dma,
 262                         ALIGN(macb->tx_ring_dma + MACB_TX_DMA_DESC_SIZE,
 263                               PKTALIGN));
 264 }
 265
 266 static inline void macb_flush_ring_desc(struct macb_device *macb, bool rx)
 267 {
 268         if (rx)
 269                 flush_dcache_range(macb->rx_ring_dma, macb->rx_ring_dma +
 270                                    ALIGN(MACB_RX_DMA_DESC_SIZE, PKTALIGN));
 271         else
 272                 flush_dcache_range(macb->tx_ring_dma, macb->tx_ring_dma +
 273                                    ALIGN(MACB_TX_DMA_DESC_SIZE, PKTALIGN));
 274 }
 275
 276 static inline void macb_flush_rx_buffer(struct macb_device *macb)
 277 {
 278         flush_dcache_range(macb->rx_buffer_dma, macb->rx_buffer_dma +
 279                            ALIGN(MACB_RX_BUFFER_SIZE, PKTALIGN));
 280 }
 281
 282 static inline void macb_invalidate_rx_buffer(struct macb_device *macb)
 283 {
 284         invalidate_dcache_range(macb->rx_buffer_dma, macb->rx_buffer_dma +
 285                                 ALIGN(MACB_RX_BUFFER_SIZE, PKTALIGN));
 286 }
 287
 288 #if defined(CONFIG_CMD_NET)
 289
 290 static int _macb_send(struct macb_device *macb, const char *name, void *packet,
 291                       int length)
 292 {
 293         unsigned long paddr, ctrl;
 294         unsigned int tx_head = macb->tx_head;
 295         int i;
 296
 297         paddr = dma_map_single(packet, length, DMA_TO_DEVICE);
 298
 299         ctrl = length & TXBUF_FRMLEN_MASK;
 300         ctrl |= MACB_BIT(TX_LAST);
 301         if (tx_head == (MACB_TX_RING_SIZE - 1)) {
 302                 ctrl |= MACB_BIT(TX_WRAP);
 303                 macb->tx_head = 0;
 304         } else {
 305                 macb->tx_head++;
 306         }
 307
 308         macb->tx_ring[tx_head].ctrl = ctrl;
 309         macb->tx_ring[tx_head].addr = paddr;
 310         barrier();
 311         macb_flush_ring_desc(macb, TX);
 312         /* Do we need check paddr and length is dcache line aligned? */
 313         flush_dcache_range(paddr, paddr + ALIGN(length, ARCH_DMA_MINALIGN));
 314         macb_writel(macb, NCR, MACB_BIT(TE) | MACB_BIT(RE) | MACB_BIT(TSTART));
 315
 316         /*
 317          * I guess this is necessary because the networking core may
 318          * re-use the transmit buffer as soon as we return...
 319          */
 320         for (i = 0; i <= MACB_TX_TIMEOUT; i++) {
 321                 barrier();
 322                 macb_invalidate_ring_desc(macb, TX);
 323                 ctrl = macb->tx_ring[tx_head].ctrl;
 324                 if (ctrl & MACB_BIT(TX_USED))
 325                         break;
 326                 udelay(1);
 327         }
 328
 329         dma_unmap_single(packet, length, paddr);
 330
 331         if (i <= MACB_TX_TIMEOUT) {
 332                 if (ctrl & MACB_BIT(TX_UNDERRUN))
 333                         printf("%s: TX underrun\n", name);
 334                 if (ctrl & MACB_BIT(TX_BUF_EXHAUSTED))
 335                         printf("%s: TX buffers exhausted in mid frame\n", name);
 336         } else {
 337                 printf("%s: TX timeout\n", name);
 338         }
 339
 340         /* No one cares anyway */
 341         return 0;
 342 }
 343
 344 static void reclaim_rx_buffers(struct macb_device *macb,
 345                                unsigned int new_tail)
 346 {
 347         unsigned int i;
 348
 349         i = macb->rx_tail;
 350
 351         macb_invalidate_ring_desc(macb, RX);
 352         while (i > new_tail) {
 353                 macb->rx_ring[i].addr &= ~MACB_BIT(RX_USED);
 354                 i++;
 355                 if (i > MACB_RX_RING_SIZE)
 356                         i = 0;
 357         }
 358
 359         while (i < new_tail) {
 360                 macb->rx_ring[i].addr &= ~MACB_BIT(RX_USED);
 361                 i++;
 362         }
 363
 364         barrier();
 365         macb_flush_ring_desc(macb, RX);
 366         macb->rx_tail = new_tail;
 367 }
 368
 369 static int _macb_recv(struct macb_device *macb, uchar **packetp)
 370 {
 371         unsigned int next_rx_tail = macb->next_rx_tail;
 372         void *buffer;
 373         int length;
 374         u32 status;
 375
 376         macb->wrapped = false;
 377         for (;;) {
 378                 macb_invalidate_ring_desc(macb, RX);
 379
 380                 if (!(macb->rx_ring[next_rx_tail].addr & MACB_BIT(RX_USED)))
 381                         return -EAGAIN;
 382
 383                 status = macb->rx_ring[next_rx_tail].ctrl;
 384                 if (status & MACB_BIT(RX_SOF)) {
 385                         if (next_rx_tail != macb->rx_tail)
 386                                 reclaim_rx_buffers(macb, next_rx_tail);
 387                         macb->wrapped = false;
 388                 }
 389
 390                 if (status & MACB_BIT(RX_EOF)) {
 391                         buffer = macb->rx_buffer + 128 * macb->rx_tail;
 392                         length = status & RXBUF_FRMLEN_MASK;
 393
 394                         macb_invalidate_rx_buffer(macb);
 395                         if (macb->wrapped) {
 396                                 unsigned int headlen, taillen;
 397
 398                                 headlen = 128 * (MACB_RX_RING_SIZE
 399                                                  - macb->rx_tail);
 400                                 taillen = length - headlen;
 401                                 memcpy((void *)net_rx_packets[0],
 402                                        buffer, headlen);
 403                                 memcpy((void *)net_rx_packets[0] + headlen,
 404                                        macb->rx_buffer, taillen);
 405                                 *packetp = (void *)net_rx_packets[0];
 406                         } else {
 407                                 *packetp = buffer;
 408                         }
 409
 410                         if (++next_rx_tail >= MACB_RX_RING_SIZE)
 411                                 next_rx_tail = 0;
 412                         macb->next_rx_tail = next_rx_tail;
 413                         return length;
 414                 } else {
 415                         if (++next_rx_tail >= MACB_RX_RING_SIZE) {
 416                                 macb->wrapped = true;
 417                                 next_rx_tail = 0;
 418                         }
 419                 }
 420                 barrier();
 421         }
 422 }
 423
 424 static void macb_phy_reset(struct macb_device *macb, const char *name)
 425 {
 426         int i;
 427         u16 status, adv;
 428
 429         adv = ADVERTISE_CSMA | ADVERTISE_ALL;
 430         macb_mdio_write(macb, MII_ADVERTISE, adv);
 431         printf("%s: Starting autonegotiation...\n", name);
 432         macb_mdio_write(macb, MII_BMCR, (BMCR_ANENABLE
 433                                          | BMCR_ANRESTART));
 434
 435         for (i = 0; i < MACB_AUTONEG_TIMEOUT / 100; i++) {
 436                 status = macb_mdio_read(macb, MII_BMSR);
 437                 if (status & BMSR_ANEGCOMPLETE)
 438                         break;
 439                 udelay(100);
 440         }
 441
 442         if (status & BMSR_ANEGCOMPLETE)
 443                 printf("%s: Autonegotiation complete\n", name);
 444         else
 445                 printf("%s: Autonegotiation timed out (status=0x%04x)\n",
 446                        name, status);
 447 }
 448
 449 static int macb_phy_find(struct macb_device *macb, const char *name)
 450 {
 451         int i;
 452         u16 phy_id;
 453
 454         /* Search for PHY... */
 455         for (i = 0; i < 32; i++) {
 456                 macb->phy_addr = i;
 457                 phy_id = macb_mdio_read(macb, MII_PHYSID1);
 458                 if (phy_id != 0xffff) {
 459                         printf("%s: PHY present at %d\n", name, i);
 460                         return 0;
 461                 }
 462         }
 463
 464         /* PHY isn't up to snuff */
 465         printf("%s: PHY not found\n", name);
 466
 467         return -ENODEV;
 468 }
 469
 470 /**
 471  * macb_linkspd_cb - Linkspeed change callback function
 472  * @dev/@regs:  MACB udevice (DM version) or
 473  *              Base Register of MACB devices (non-DM version)
 474  * @speed:      Linkspeed
 475  * Returns 0 when operation success and negative errno number
 476  * when operation failed.
 477  */
 478 #ifdef CONFIG_DM_ETH
 479 int __weak macb_linkspd_cb(struct udevice *dev, unsigned int speed)
 480 {
 481 #ifdef CONFIG_CLK
 482         struct clk tx_clk;
 483         ulong rate;
 484         int ret;
 485
 486         /*
 487          * "tx_clk" is an optional clock source for MACB.
 488          * Ignore if it does not exist in DT.
 489          */
 490         ret = clk_get_by_name(dev, "tx_clk", &tx_clk);
 491         if (ret)
 492                 return 0;
 493
 494         switch (speed) {
 495         case _10BASET:
 496                 rate = 2500000;         /* 2.5 MHz */
 497                 break;
 498         case _100BASET:
 499                 rate = 25000000;        /* 25 MHz */
 500                 break;
 501         case _1000BASET:
 502                 rate = 125000000;       /* 125 MHz */
 503                 break;
 504         default:
 505                 /* does not change anything */
 506                 return 0;
 507         }
 508
 509         if (tx_clk.dev) {
 510                 ret = clk_set_rate(&tx_clk, rate);
 511                 if (ret)
 512                         return ret;
 513         }
 514 #endif
 515
 516         return 0;
 517 }
 518 #else
 519 int __weak macb_linkspd_cb(void *regs, unsigned int speed)
 520 {
 521         return 0;
 522 }
 523 #endif
 524
 525 #ifdef CONFIG_DM_ETH
 526 static int macb_phy_init(struct udevice *dev, const char *name)
 527 #else
 528 static int macb_phy_init(struct macb_device *macb, const char *name)
 529 #endif
 530 {
 531 #ifdef CONFIG_DM_ETH
 532         struct macb_device *macb = dev_get_priv(dev);
 533 #endif
 534         u32 ncfgr;
 535         u16 phy_id, status, adv, lpa;
 536         int media, speed, duplex;
 537         int ret;
 538         int i;
 539
 540         arch_get_mdio_control(name);
 541         /* Auto-detect phy_addr */
 542         ret = macb_phy_find(macb, name);
 543         if (ret)
 544                 return ret;
 545
 546         /* Check if the PHY is up to snuff... */
 547         phy_id = macb_mdio_read(macb, MII_PHYSID1);
 548         if (phy_id == 0xffff) {
 549                 printf("%s: No PHY present\n", name);
 550                 return -ENODEV;
 551         }
 552
 553 #ifdef CONFIG_PHYLIB
 554 #ifdef CONFIG_DM_ETH
 555         macb->phydev = phy_connect(macb->bus, macb->phy_addr, dev,
 556                              macb->phy_interface);
 557 #else
 558         /* need to consider other phy interface mode */
 559         macb->phydev = phy_connect(macb->bus, macb->phy_addr, &macb->netdev,
 560                              PHY_INTERFACE_MODE_RGMII);
 561 #endif
 562         if (!macb->phydev) {
 563                 printf("phy_connect failed\n");
 564                 return -ENODEV;
 565         }
 566
 567         phy_config(macb->phydev);
 568 #endif
 569
 570         status = macb_mdio_read(macb, MII_BMSR);
 571         if (!(status & BMSR_LSTATUS)) {
 572                 /* Try to re-negotiate if we don't have link already. */
 573                 macb_phy_reset(macb, name);
 574
 575                 for (i = 0; i < MACB_AUTONEG_TIMEOUT / 100; i++) {
 576                         status = macb_mdio_read(macb, MII_BMSR);
 577                         if (status & BMSR_LSTATUS) {
 578                                 /*
 579                                  * Delay a bit after the link is established,
 580                                  * so that the next xfer does not fail
 581                                  */
 582                                 mdelay(10);
 583                                 break;
 584                         }
 585                         udelay(100);
 586                 }
 587         }
 588
 589         if (!(status & BMSR_LSTATUS)) {
 590                 printf("%s: link down (status: 0x%04x)\n",
 591                        name, status);
 592                 return -ENETDOWN;
 593         }
 594
 595         /* First check for GMAC and that it is GiB capable */
 596         if (gem_is_gigabit_capable(macb)) {
 597                 lpa = macb_mdio_read(macb, MII_LPA);
 598
 599                 if (lpa & (LPA_1000FULL | LPA_1000HALF | LPA_1000XFULL |
 600                                         LPA_1000XHALF)) {
 601                         duplex = ((lpa & (LPA_1000FULL | LPA_1000XFULL)) ?
 602                                         1 : 0);
 603
 604                         printf("%s: link up, 1000Mbps %s-duplex (lpa: 0x%04x)\n",
 605                                name,
 606                                duplex ? "full" : "half",
 607                                lpa);
 608
 609                         ncfgr = macb_readl(macb, NCFGR);
 610                         ncfgr &= ~(MACB_BIT(SPD) | MACB_BIT(FD));
 611                         ncfgr |= GEM_BIT(GBE);
 612
 613                         if (duplex)
 614                                 ncfgr |= MACB_BIT(FD);
 615
 616                         macb_writel(macb, NCFGR, ncfgr);
 617
 618 #ifdef CONFIG_DM_ETH
 619                         ret = macb_linkspd_cb(dev, _1000BASET);
 620 #else
 621                         ret = macb_linkspd_cb(macb->regs, _1000BASET);
 622 #endif
 623                         if (ret)
 624                                 return ret;
 625
 626                         return 0;
 627                 }
 628         }
 629
 630         /* fall back for EMAC checking */
 631         adv = macb_mdio_read(macb, MII_ADVERTISE);
 632         lpa = macb_mdio_read(macb, MII_LPA);
 633         media = mii_nway_result(lpa & adv);
 634         speed = (media & (ADVERTISE_100FULL | ADVERTISE_100HALF)
 635                  ? 1 : 0);
 636         duplex = (media & ADVERTISE_FULL) ? 1 : 0;
 637         printf("%s: link up, %sMbps %s-duplex (lpa: 0x%04x)\n",
 638                name,
 639                speed ? "100" : "10",
 640                duplex ? "full" : "half",
 641                lpa);
 642
 643         ncfgr = macb_readl(macb, NCFGR);
 644         ncfgr &= ~(MACB_BIT(SPD) | MACB_BIT(FD) | GEM_BIT(GBE));
 645         if (speed) {
 646                 ncfgr |= MACB_BIT(SPD);
 647 #ifdef CONFIG_DM_ETH
 648                 ret = macb_linkspd_cb(dev, _100BASET);
 649 #else
 650                 ret = macb_linkspd_cb(macb->regs, _100BASET);
 651 #endif
 652         } else {
 653 #ifdef CONFIG_DM_ETH
 654                 ret = macb_linkspd_cb(dev, _10BASET);
 655 #else
 656                 ret = macb_linkspd_cb(macb->regs, _10BASET);
 657 #endif
 658         }
 659
 660         if (ret)
 661                 return ret;
 662
 663         if (duplex)
 664                 ncfgr |= MACB_BIT(FD);
 665         macb_writel(macb, NCFGR, ncfgr);
 666
 667         return 0;
 668 }
 669
 670 static int gmac_init_multi_queues(struct macb_device *macb)
 671 {
 672         int i, num_queues = 1;
 673         u32 queue_mask;
 674
 675         /* bit 0 is never set but queue 0 always exists */
 676         queue_mask = gem_readl(macb, DCFG6) & 0xff;
 677         queue_mask |= 0x1;
 678
 679         for (i = 1; i < MACB_MAX_QUEUES; i++)
 680                 if (queue_mask & (1 << i))
 681                         num_queues++;
 682
 683         macb->dummy_desc->ctrl = MACB_BIT(TX_USED);
 684         macb->dummy_desc->addr = 0;
 685         flush_dcache_range(macb->dummy_desc_dma, macb->dummy_desc_dma +
 686                         ALIGN(MACB_TX_DUMMY_DMA_DESC_SIZE, PKTALIGN));
 687
 688         for (i = 1; i < num_queues; i++)
 689                 gem_writel_queue_TBQP(macb, macb->dummy_desc_dma, i - 1);
 690
 691         return 0;
 692 }
 693
 694 #ifdef CONFIG_DM_ETH
 695 static int _macb_init(struct udevice *dev, const char *name)
 696 #else
 697 static int _macb_init(struct macb_device *macb, const char *name)
 698 #endif
 699 {
 700 #ifdef CONFIG_DM_ETH
 701         struct macb_device *macb = dev_get_priv(dev);
 702 #endif
 703         unsigned long paddr;
 704         int ret;
 705         int i;
 706
 707         /*
 708          * macb_halt should have been called at some point before now,
 709          * so we'll assume the controller is idle.
 710          */
 711
 712         /* initialize DMA descriptors */
 713         paddr = macb->rx_buffer_dma;
 714         for (i = 0; i < MACB_RX_RING_SIZE; i++) {
 715                 if (i == (MACB_RX_RING_SIZE - 1))
 716                         paddr |= MACB_BIT(RX_WRAP);
 717                 macb->rx_ring[i].addr = paddr;
 718                 macb->rx_ring[i].ctrl = 0;
 719                 paddr += 128;
 720         }
 721         macb_flush_ring_desc(macb, RX);
 722         macb_flush_rx_buffer(macb);
 723
 724         for (i = 0; i < MACB_TX_RING_SIZE; i++) {
 725                 macb->tx_ring[i].addr = 0;
 726                 if (i == (MACB_TX_RING_SIZE - 1))
 727                         macb->tx_ring[i].ctrl = MACB_BIT(TX_USED) |
 728                                 MACB_BIT(TX_WRAP);
 729                 else
 730                         macb->tx_ring[i].ctrl = MACB_BIT(TX_USED);
 731         }
 732         macb_flush_ring_desc(macb, TX);
 733
 734         macb->rx_tail = 0;
 735         macb->tx_head = 0;
 736         macb->tx_tail = 0;
 737         macb->next_rx_tail = 0;
 738
 739 #ifdef CONFIG_MACB_ZYNQ
 740         macb_writel(macb, DMACFG, MACB_ZYNQ_GEM_DMACR_INIT);
 741 #endif
 742
 743         macb_writel(macb, RBQP, macb->rx_ring_dma);
 744         macb_writel(macb, TBQP, macb->tx_ring_dma);
 745
 746         if (macb_is_gem(macb)) {
 747                 /* Check the multi queue and initialize the queue for tx */
 748                 gmac_init_multi_queues(macb);
 749
 750                 /*
 751                  * When the GMAC IP with GE feature, this bit is used to
 752                  * select interface between RGMII and GMII.
 753                  * When the GMAC IP without GE feature, this bit is used
 754                  * to select interface between RMII and MII.
 755                  */
 756 #ifdef CONFIG_DM_ETH
 757                 if ((macb->phy_interface == PHY_INTERFACE_MODE_RMII) ||
 758                     (macb->phy_interface == PHY_INTERFACE_MODE_RGMII))
 759                         gem_writel(macb, USRIO, GEM_BIT(RGMII));
 760                 else
 761                         gem_writel(macb, USRIO, 0);
 762
 763                 if (macb->phy_interface == PHY_INTERFACE_MODE_SGMII) {
 764                         unsigned int ncfgr = macb_readl(macb, NCFGR);
 765
 766                         ncfgr |= GEM_BIT(SGMIIEN) | GEM_BIT(PCSSEL);
 767                         macb_writel(macb, NCFGR, ncfgr);
 768                 }
 769 #else
 770 #if defined(CONFIG_RGMII) || defined(CONFIG_RMII)
 771                 gem_writel(macb, USRIO, GEM_BIT(RGMII));
 772 #else
 773                 gem_writel(macb, USRIO, 0);
 774 #endif
 775 #endif
 776         } else {
 777         /* choose RMII or MII mode. This depends on the board */
 778 #ifdef CONFIG_DM_ETH
 779 #ifdef CONFIG_AT91FAMILY
 780                 if (macb->phy_interface == PHY_INTERFACE_MODE_RMII) {
 781                         macb_writel(macb, USRIO,
 782                                     MACB_BIT(RMII) | MACB_BIT(CLKEN));
 783                 } else {
 784                         macb_writel(macb, USRIO, MACB_BIT(CLKEN));
 785                 }
 786 #else
 787                 if (macb->phy_interface == PHY_INTERFACE_MODE_RMII)
 788                         macb_writel(macb, USRIO, 0);
 789                 else
 790                         macb_writel(macb, USRIO, MACB_BIT(MII));
 791 #endif
 792 #else
 793 #ifdef CONFIG_RMII
 794 #ifdef CONFIG_AT91FAMILY
 795         macb_writel(macb, USRIO, MACB_BIT(RMII) | MACB_BIT(CLKEN));
 796 #else
 797         macb_writel(macb, USRIO, 0);
 798 #endif
 799 #else
 800 #ifdef CONFIG_AT91FAMILY
 801         macb_writel(macb, USRIO, MACB_BIT(CLKEN));
 802 #else
 803         macb_writel(macb, USRIO, MACB_BIT(MII));
 804 #endif
 805 #endif /* CONFIG_RMII */
 806 #endif
 807         }
 808
 809 #ifdef CONFIG_DM_ETH
 810         ret = macb_phy_init(dev, name);
 811 #else
 812         ret = macb_phy_init(macb, name);
 813 #endif
 814         if (ret)
 815                 return ret;
 816
 817         /* Enable TX and RX */
 818         macb_writel(macb, NCR, MACB_BIT(TE) | MACB_BIT(RE));
 819
 820         return 0;
 821 }
 822
 823 static void _macb_halt(struct macb_device *macb)
 824 {
 825         u32 ncr, tsr;
 826
 827         /* Halt the controller and wait for any ongoing transmission to end. */
 828         ncr = macb_readl(macb, NCR);
 829         ncr |= MACB_BIT(THALT);
 830         macb_writel(macb, NCR, ncr);
 831
 832         do {
 833                 tsr = macb_readl(macb, TSR);
 834         } while (tsr & MACB_BIT(TGO));
 835
 836         /* Disable TX and RX, and clear statistics */
 837         macb_writel(macb, NCR, MACB_BIT(CLRSTAT));
 838 }
 839
 840 static int _macb_write_hwaddr(struct macb_device *macb, unsigned char *enetaddr)
 841 {
 842         u32 hwaddr_bottom;
 843         u16 hwaddr_top;
 844
 845         /* set hardware address */
 846         hwaddr_bottom = enetaddr[0] | enetaddr[1] << 8 |
 847                         enetaddr[2] << 16 | enetaddr[3] << 24;
 848         macb_writel(macb, SA1B, hwaddr_bottom);
 849         hwaddr_top = enetaddr[4] | enetaddr[5] << 8;
 850         macb_writel(macb, SA1T, hwaddr_top);
 851         return 0;
 852 }
 853
 854 static u32 macb_mdc_clk_div(int id, struct macb_device *macb)
 855 {
 856         u32 config;
 857 #if defined(CONFIG_DM_ETH) && defined(CONFIG_CLK)
 858         unsigned long macb_hz = macb->pclk_rate;
 859 #else
 860         unsigned long macb_hz = get_macb_pclk_rate(id);
 861 #endif
 862
 863         if (macb_hz < 20000000)
 864                 config = MACB_BF(CLK, MACB_CLK_DIV8);
 865         else if (macb_hz < 40000000)
 866                 config = MACB_BF(CLK, MACB_CLK_DIV16);
 867         else if (macb_hz < 80000000)
 868                 config = MACB_BF(CLK, MACB_CLK_DIV32);
 869         else
 870                 config = MACB_BF(CLK, MACB_CLK_DIV64);
 871
 872         return config;
 873 }
 874
 875 static u32 gem_mdc_clk_div(int id, struct macb_device *macb)
 876 {
 877         u32 config;
 878
 879 #if defined(CONFIG_DM_ETH) && defined(CONFIG_CLK)
 880         unsigned long macb_hz = macb->pclk_rate;
 881 #else
 882         unsigned long macb_hz = get_macb_pclk_rate(id);
 883 #endif
 884
 885         if (macb_hz < 20000000)
 886                 config = GEM_BF(CLK, GEM_CLK_DIV8);
 887         else if (macb_hz < 40000000)
 888                 config = GEM_BF(CLK, GEM_CLK_DIV16);
 889         else if (macb_hz < 80000000)
 890                 config = GEM_BF(CLK, GEM_CLK_DIV32);
 891         else if (macb_hz < 120000000)
 892                 config = GEM_BF(CLK, GEM_CLK_DIV48);
 893         else if (macb_hz < 160000000)
 894                 config = GEM_BF(CLK, GEM_CLK_DIV64);
 895         else if (macb_hz < 240000000)
 896                 config = GEM_BF(CLK, GEM_CLK_DIV96);
 897         else if (macb_hz < 320000000)
 898                 config = GEM_BF(CLK, GEM_CLK_DIV128);
 899         else
 900                 config = GEM_BF(CLK, GEM_CLK_DIV224);
 901
 902         return config;
 903 }
 904
 905 /*
 906  * Get the DMA bus width field of the network configuration register that we
 907  * should program. We find the width from decoding the design configuration
 908  * register to find the maximum supported data bus width.
 909  */
 910 static u32 macb_dbw(struct macb_device *macb)
 911 {
 912         switch (GEM_BFEXT(DBWDEF, gem_readl(macb, DCFG1))) {
 913         case 4:
 914                 return GEM_BF(DBW, GEM_DBW128);
 915         case 2:
 916                 return GEM_BF(DBW, GEM_DBW64);
 917         case 1:
 918         default:
 919                 return GEM_BF(DBW, GEM_DBW32);
 920         }
 921 }
 922
 923 static void _macb_eth_initialize(struct macb_device *macb)
 924 {
 925         int id = 0;     /* This is not used by functions we call */
 926         u32 ncfgr;
 927
 928         /* TODO: we need check the rx/tx_ring_dma is dcache line aligned */
 929         macb->rx_buffer = dma_alloc_coherent(MACB_RX_BUFFER_SIZE,
 930                                              &macb->rx_buffer_dma);
 931         macb->rx_ring = dma_alloc_coherent(MACB_RX_DMA_DESC_SIZE,
 932                                            &macb->rx_ring_dma);
 933         macb->tx_ring = dma_alloc_coherent(MACB_TX_DMA_DESC_SIZE,
 934                                            &macb->tx_ring_dma);
 935         macb->dummy_desc = dma_alloc_coherent(MACB_TX_DUMMY_DMA_DESC_SIZE,
 936                                            &macb->dummy_desc_dma);
 937
 938         /*
 939          * Do some basic initialization so that we at least can talk
 940          * to the PHY
 941          */
 942         if (macb_is_gem(macb)) {
 943                 ncfgr = gem_mdc_clk_div(id, macb);
 944                 ncfgr |= macb_dbw(macb);
 945         } else {
 946                 ncfgr = macb_mdc_clk_div(id, macb);
 947         }
 948
 949         macb_writel(macb, NCFGR, ncfgr);
 950 }
 951
 952 #ifndef CONFIG_DM_ETH
 953 static int macb_send(struct eth_device *netdev, void *packet, int length)
 954 {
 955         struct macb_device *macb = to_macb(netdev);
 956
 957         return _macb_send(macb, netdev->name, packet, length);
 958 }
 959
 960 static int macb_recv(struct eth_device *netdev)
 961 {
 962         struct macb_device *macb = to_macb(netdev);
 963         uchar *packet;
 964         int length;
 965
 966         macb->wrapped = false;
 967         for (;;) {
 968                 macb->next_rx_tail = macb->rx_tail;
 969                 length = _macb_recv(macb, &packet);
 970                 if (length >= 0) {
 971                         net_process_received_packet(packet, length);
 972                         reclaim_rx_buffers(macb, macb->next_rx_tail);
 973                 } else {
 974                         return length;
 975                 }
 976         }
 977 }
 978
 979 static int macb_init(struct eth_device *netdev, bd_t *bd)
 980 {
 981         struct macb_device *macb = to_macb(netdev);
 982
 983         return _macb_init(macb, netdev->name);
 984 }
 985
 986 static void macb_halt(struct eth_device *netdev)
 987 {
 988         struct macb_device *macb = to_macb(netdev);
 989
 990         return _macb_halt(macb);
 991 }
 992
 993 static int macb_write_hwaddr(struct eth_device *netdev)
 994 {
 995         struct macb_device *macb = to_macb(netdev);
 996
 997         return _macb_write_hwaddr(macb, netdev->enetaddr);
 998 }
 999
1000 int macb_eth_initialize(int id, void *regs, unsigned int phy_addr)
1001 {
1002         struct macb_device *macb;
1003         struct eth_device *netdev;
1004
1005         macb = malloc(sizeof(struct macb_device));
1006         if (!macb) {
1007                 printf("Error: Failed to allocate memory for MACB%d\n", id);
1008                 return -1;
1009         }
1010         memset(macb, 0, sizeof(struct macb_device));
1011
1012         netdev = &macb->netdev;
1013
1014         macb->regs = regs;
1015         macb->phy_addr = phy_addr;
1016
1017         if (macb_is_gem(macb))
1018                 sprintf(netdev->name, "gmac%d", id);
1019         else
1020                 sprintf(netdev->name, "macb%d", id);
1021
1022         netdev->init = macb_init;
1023         netdev->halt = macb_halt;
1024         netdev->send = macb_send;
1025         netdev->recv = macb_recv;
1026         netdev->write_hwaddr = macb_write_hwaddr;
1027
1028         _macb_eth_initialize(macb);
1029
1030         eth_register(netdev);
1031
1032 #if defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB)
1033         int retval;
1034         struct mii_dev *mdiodev = mdio_alloc();
1035         if (!mdiodev)
1036                 return -ENOMEM;
1037         strncpy(mdiodev->name, netdev->name, MDIO_NAME_LEN);
1038         mdiodev->read = macb_miiphy_read;
1039         mdiodev->write = macb_miiphy_write;
1040
1041         retval = mdio_register(mdiodev);
1042         if (retval < 0)
1043                 return retval;
1044         macb->bus = miiphy_get_dev_by_name(netdev->name);
1045 #endif
1046         return 0;
1047 }
1048 #endif /* !CONFIG_DM_ETH */
1049
1050 #ifdef CONFIG_DM_ETH
1051
1052 static int macb_start(struct udevice *dev)
1053 {
1054         return _macb_init(dev, dev->name);
1055 }
1056
1057 static int macb_send(struct udevice *dev, void *packet, int length)
1058 {
1059         struct macb_device *macb = dev_get_priv(dev);
1060
1061         return _macb_send(macb, dev->name, packet, length);
1062 }
1063
1064 static int macb_recv(struct udevice *dev, int flags, uchar **packetp)
1065 {
1066         struct macb_device *macb = dev_get_priv(dev);
1067
1068         macb->next_rx_tail = macb->rx_tail;
1069         macb->wrapped = false;
1070
1071         return _macb_recv(macb, packetp);
1072 }
1073
1074 static int macb_free_pkt(struct udevice *dev, uchar *packet, int length)
1075 {
1076         struct macb_device *macb = dev_get_priv(dev);
1077
1078         reclaim_rx_buffers(macb, macb->next_rx_tail);
1079
1080         return 0;
1081 }
1082
1083 static void macb_stop(struct udevice *dev)
1084 {
1085         struct macb_device *macb = dev_get_priv(dev);
1086
1087         _macb_halt(macb);
1088 }
1089
1090 static int macb_write_hwaddr(struct udevice *dev)
1091 {
1092         struct eth_pdata *plat = dev_get_platdata(dev);
1093         struct macb_device *macb = dev_get_priv(dev);
1094
1095         return _macb_write_hwaddr(macb, plat->enetaddr);
1096 }
1097
1098 static const struct eth_ops macb_eth_ops = {
1099         .start  = macb_start,
1100         .send   = macb_send,
1101         .recv   = macb_recv,
1102         .stop   = macb_stop,
1103         .free_pkt       = macb_free_pkt,
1104         .write_hwaddr   = macb_write_hwaddr,
1105 };
1106
1107 #ifdef CONFIG_CLK
1108 static int macb_enable_clk(struct udevice *dev)
1109 {
1110         struct macb_device *macb = dev_get_priv(dev);
1111         struct clk clk;
1112         ulong clk_rate;
1113         int ret;
1114
1115         ret = clk_get_by_index(dev, 0, &clk);
1116         if (ret)
1117                 return -EINVAL;
1118
1119         /*
1120          * If clock driver didn't support enable or disable then
1121          * we get -ENOSYS from clk_enable(). To handle this, we
1122          * don't fail for ret == -ENOSYS.
1123          */
1124         ret = clk_enable(&clk);
1125         if (ret && ret != -ENOSYS)
1126                 return ret;
1127
1128         clk_rate = clk_get_rate(&clk);
1129         if (!clk_rate)
1130                 return -EINVAL;
1131
1132         macb->pclk_rate = clk_rate;
1133
1134         return 0;
1135 }
1136 #endif
1137
1138 static int macb_eth_probe(struct udevice *dev)
1139 {
1140         struct eth_pdata *pdata = dev_get_platdata(dev);
1141         struct macb_device *macb = dev_get_priv(dev);
1142         const char *phy_mode;
1143         __maybe_unused int ret;
1144
1145         phy_mode = fdt_getprop(gd->fdt_blob, dev_of_offset(dev), "phy-mode",
1146                                NULL);
1147         if (phy_mode)
1148                 macb->phy_interface = phy_get_interface_by_name(phy_mode);
1149         if (macb->phy_interface == -1) {
1150                 debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);
1151                 return -EINVAL;
1152         }
1153
1154         macb->regs = (void *)pdata->iobase;
1155
1156 #ifdef CONFIG_CLK
1157         ret = macb_enable_clk(dev);
1158         if (ret)
1159                 return ret;
1160 #endif
1161
1162         _macb_eth_initialize(macb);
1163
1164 #if defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB)
1165         macb->bus = mdio_alloc();
1166         if (!macb->bus)
1167                 return -ENOMEM;
1168         strncpy(macb->bus->name, dev->name, MDIO_NAME_LEN);
1169         macb->bus->read = macb_miiphy_read;
1170         macb->bus->write = macb_miiphy_write;
1171
1172         ret = mdio_register(macb->bus);
1173         if (ret < 0)
1174                 return ret;
1175         macb->bus = miiphy_get_dev_by_name(dev->name);
1176 #endif
1177
1178         return 0;
1179 }
1180
1181 static int macb_eth_remove(struct udevice *dev)
1182 {
1183         struct macb_device *macb = dev_get_priv(dev);
1184
1185 #ifdef CONFIG_PHYLIB
1186         free(macb->phydev);
1187 #endif
1188         mdio_unregister(macb->bus);
1189         mdio_free(macb->bus);
1190
1191         return 0;
1192 }
1193
1194 /**
1195  * macb_late_eth_ofdata_to_platdata
1196  * @dev:        udevice struct
1197  * Returns 0 when operation success and negative errno number
1198  * when operation failed.
1199  */
1200 int __weak macb_late_eth_ofdata_to_platdata(struct udevice *dev)
1201 {
1202         return 0;
1203 }
1204
1205 static int macb_eth_ofdata_to_platdata(struct udevice *dev)
1206 {
1207         struct eth_pdata *pdata = dev_get_platdata(dev);
1208
1209         pdata->iobase = (phys_addr_t)dev_remap_addr(dev);
1210         if (!pdata->iobase)
1211                 return -EINVAL;
1212
1213         return macb_late_eth_ofdata_to_platdata(dev);
1214 }
1215
1216 static const struct udevice_id macb_eth_ids[] = {
1217         { .compatible = "cdns,macb" },
1218         { .compatible = "cdns,at91sam9260-macb" },
1219         { .compatible = "atmel,sama5d2-gem" },
1220         { .compatible = "atmel,sama5d3-gem" },
1221         { .compatible = "atmel,sama5d4-gem" },
1222         { .compatible = "cdns,zynq-gem" },
1223         { }
1224 };
1225
1226 U_BOOT_DRIVER(eth_macb) = {
1227         .name   = "eth_macb",
1228         .id     = UCLASS_ETH,
1229         .of_match = macb_eth_ids,
1230         .ofdata_to_platdata = macb_eth_ofdata_to_platdata,
1231         .probe  = macb_eth_probe,
1232         .remove = macb_eth_remove,
1233         .ops    = &macb_eth_ops,
1234         .priv_auto_alloc_size = sizeof(struct macb_device),
1235         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
1236 };
1237 #endif
1238
1239 #endif