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