git.sur5r.net Git - u-boot/blob - drivers/net/sun8i_emac.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2016
   4  * Author: Amit Singh Tomar, amittomer25@gmail.com
   5  *
   6  * Ethernet driver for H3/A64/A83T based SoC's
   7  *
   8  * It is derived from the work done by
   9  * LABBE Corentin & Chen-Yu Tsai for Linux, THANKS!
  10  *
  11 */
  12
  13 #include <asm/io.h>
  14 #include <asm/arch/clock.h>
  15 #include <asm/arch/gpio.h>
  16 #include <common.h>
  17 #include <dm.h>
  18 #include <fdt_support.h>
  19 #include <linux/err.h>
  20 #include <malloc.h>
  21 #include <miiphy.h>
  22 #include <net.h>
  23 #include <dt-bindings/pinctrl/sun4i-a10.h>
  24 #ifdef CONFIG_DM_GPIO
  25 #include <asm-generic/gpio.h>
  26 #endif
  27
  28 #define MDIO_CMD_MII_BUSY               BIT(0)
  29 #define MDIO_CMD_MII_WRITE              BIT(1)
  30
  31 #define MDIO_CMD_MII_PHY_REG_ADDR_MASK  0x000001f0
  32 #define MDIO_CMD_MII_PHY_REG_ADDR_SHIFT 4
  33 #define MDIO_CMD_MII_PHY_ADDR_MASK      0x0001f000
  34 #define MDIO_CMD_MII_PHY_ADDR_SHIFT     12
  35
  36 #define CONFIG_TX_DESCR_NUM     32
  37 #define CONFIG_RX_DESCR_NUM     32
  38 #define CONFIG_ETH_BUFSIZE      2048 /* Note must be dma aligned */
  39
  40 /*
  41  * The datasheet says that each descriptor can transfers up to 4096 bytes
  42  * But later, the register documentation reduces that value to 2048,
  43  * using 2048 cause strange behaviours and even BSP driver use 2047
  44  */
  45 #define CONFIG_ETH_RXSIZE       2044 /* Note must fit in ETH_BUFSIZE */
  46
  47 #define TX_TOTAL_BUFSIZE        (CONFIG_ETH_BUFSIZE * CONFIG_TX_DESCR_NUM)
  48 #define RX_TOTAL_BUFSIZE        (CONFIG_ETH_BUFSIZE * CONFIG_RX_DESCR_NUM)
  49
  50 #define H3_EPHY_DEFAULT_VALUE   0x58000
  51 #define H3_EPHY_DEFAULT_MASK    GENMASK(31, 15)
  52 #define H3_EPHY_ADDR_SHIFT      20
  53 #define REG_PHY_ADDR_MASK       GENMASK(4, 0)
  54 #define H3_EPHY_LED_POL         BIT(17) /* 1: active low, 0: active high */
  55 #define H3_EPHY_SHUTDOWN        BIT(16) /* 1: shutdown, 0: power up */
  56 #define H3_EPHY_SELECT          BIT(15) /* 1: internal PHY, 0: external PHY */
  57
  58 #define SC_RMII_EN              BIT(13)
  59 #define SC_EPIT                 BIT(2) /* 1: RGMII, 0: MII */
  60 #define SC_ETCS_MASK            GENMASK(1, 0)
  61 #define SC_ETCS_EXT_GMII        0x1
  62 #define SC_ETCS_INT_GMII        0x2
  63
  64 #define CONFIG_MDIO_TIMEOUT     (3 * CONFIG_SYS_HZ)
  65
  66 #define AHB_GATE_OFFSET_EPHY    0
  67
  68 /* IO mux settings */
  69 #define SUN8I_IOMUX_H3          2
  70 #define SUN8I_IOMUX             4
  71
  72 /* H3/A64 EMAC Register's offset */
  73 #define EMAC_CTL0               0x00
  74 #define EMAC_CTL1               0x04
  75 #define EMAC_INT_STA            0x08
  76 #define EMAC_INT_EN             0x0c
  77 #define EMAC_TX_CTL0            0x10
  78 #define EMAC_TX_CTL1            0x14
  79 #define EMAC_TX_FLOW_CTL        0x1c
  80 #define EMAC_TX_DMA_DESC        0x20
  81 #define EMAC_RX_CTL0            0x24
  82 #define EMAC_RX_CTL1            0x28
  83 #define EMAC_RX_DMA_DESC        0x34
  84 #define EMAC_MII_CMD            0x48
  85 #define EMAC_MII_DATA           0x4c
  86 #define EMAC_ADDR0_HIGH         0x50
  87 #define EMAC_ADDR0_LOW          0x54
  88 #define EMAC_TX_DMA_STA         0xb0
  89 #define EMAC_TX_CUR_DESC        0xb4
  90 #define EMAC_TX_CUR_BUF         0xb8
  91 #define EMAC_RX_DMA_STA         0xc0
  92 #define EMAC_RX_CUR_DESC        0xc4
  93
  94 DECLARE_GLOBAL_DATA_PTR;
  95
  96 enum emac_variant {
  97         A83T_EMAC = 1,
  98         H3_EMAC,
  99         A64_EMAC,
 100 };
 101
 102 struct emac_dma_desc {
 103         u32 status;
 104         u32 st;
 105         u32 buf_addr;
 106         u32 next;
 107 } __aligned(ARCH_DMA_MINALIGN);
 108
 109 struct emac_eth_dev {
 110         struct emac_dma_desc rx_chain[CONFIG_TX_DESCR_NUM];
 111         struct emac_dma_desc tx_chain[CONFIG_RX_DESCR_NUM];
 112         char rxbuffer[RX_TOTAL_BUFSIZE] __aligned(ARCH_DMA_MINALIGN);
 113         char txbuffer[TX_TOTAL_BUFSIZE] __aligned(ARCH_DMA_MINALIGN);
 114
 115         u32 interface;
 116         u32 phyaddr;
 117         u32 link;
 118         u32 speed;
 119         u32 duplex;
 120         u32 phy_configured;
 121         u32 tx_currdescnum;
 122         u32 rx_currdescnum;
 123         u32 addr;
 124         u32 tx_slot;
 125         bool use_internal_phy;
 126
 127         enum emac_variant variant;
 128         void *mac_reg;
 129         phys_addr_t sysctl_reg;
 130         struct phy_device *phydev;
 131         struct mii_dev *bus;
 132 #ifdef CONFIG_DM_GPIO
 133         struct gpio_desc reset_gpio;
 134 #endif
 135 };
 136
 137
 138 struct sun8i_eth_pdata {
 139         struct eth_pdata eth_pdata;
 140         u32 reset_delays[3];
 141 };
 142
 143
 144 static int sun8i_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
 145 {
 146         struct udevice *dev = bus->priv;
 147         struct emac_eth_dev *priv = dev_get_priv(dev);
 148         ulong start;
 149         u32 miiaddr = 0;
 150         int timeout = CONFIG_MDIO_TIMEOUT;
 151
 152         miiaddr &= ~MDIO_CMD_MII_WRITE;
 153         miiaddr &= ~MDIO_CMD_MII_PHY_REG_ADDR_MASK;
 154         miiaddr |= (reg << MDIO_CMD_MII_PHY_REG_ADDR_SHIFT) &
 155                 MDIO_CMD_MII_PHY_REG_ADDR_MASK;
 156
 157         miiaddr &= ~MDIO_CMD_MII_PHY_ADDR_MASK;
 158
 159         miiaddr |= (addr << MDIO_CMD_MII_PHY_ADDR_SHIFT) &
 160                 MDIO_CMD_MII_PHY_ADDR_MASK;
 161
 162         miiaddr |= MDIO_CMD_MII_BUSY;
 163
 164         writel(miiaddr, priv->mac_reg + EMAC_MII_CMD);
 165
 166         start = get_timer(0);
 167         while (get_timer(start) < timeout) {
 168                 if (!(readl(priv->mac_reg + EMAC_MII_CMD) & MDIO_CMD_MII_BUSY))
 169                         return readl(priv->mac_reg + EMAC_MII_DATA);
 170                 udelay(10);
 171         };
 172
 173         return -1;
 174 }
 175
 176 static int sun8i_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
 177                             u16 val)
 178 {
 179         struct udevice *dev = bus->priv;
 180         struct emac_eth_dev *priv = dev_get_priv(dev);
 181         ulong start;
 182         u32 miiaddr = 0;
 183         int ret = -1, timeout = CONFIG_MDIO_TIMEOUT;
 184
 185         miiaddr &= ~MDIO_CMD_MII_PHY_REG_ADDR_MASK;
 186         miiaddr |= (reg << MDIO_CMD_MII_PHY_REG_ADDR_SHIFT) &
 187                 MDIO_CMD_MII_PHY_REG_ADDR_MASK;
 188
 189         miiaddr &= ~MDIO_CMD_MII_PHY_ADDR_MASK;
 190         miiaddr |= (addr << MDIO_CMD_MII_PHY_ADDR_SHIFT) &
 191                 MDIO_CMD_MII_PHY_ADDR_MASK;
 192
 193         miiaddr |= MDIO_CMD_MII_WRITE;
 194         miiaddr |= MDIO_CMD_MII_BUSY;
 195
 196         writel(val, priv->mac_reg + EMAC_MII_DATA);
 197         writel(miiaddr, priv->mac_reg + EMAC_MII_CMD);
 198
 199         start = get_timer(0);
 200         while (get_timer(start) < timeout) {
 201                 if (!(readl(priv->mac_reg + EMAC_MII_CMD) &
 202                                         MDIO_CMD_MII_BUSY)) {
 203                         ret = 0;
 204                         break;
 205                 }
 206                 udelay(10);
 207         };
 208
 209         return ret;
 210 }
 211
 212 static int _sun8i_write_hwaddr(struct emac_eth_dev *priv, u8 *mac_id)
 213 {
 214         u32 macid_lo, macid_hi;
 215
 216         macid_lo = mac_id[0] + (mac_id[1] << 8) + (mac_id[2] << 16) +
 217                 (mac_id[3] << 24);
 218         macid_hi = mac_id[4] + (mac_id[5] << 8);
 219
 220         writel(macid_hi, priv->mac_reg + EMAC_ADDR0_HIGH);
 221         writel(macid_lo, priv->mac_reg + EMAC_ADDR0_LOW);
 222
 223         return 0;
 224 }
 225
 226 static void sun8i_adjust_link(struct emac_eth_dev *priv,
 227                               struct phy_device *phydev)
 228 {
 229         u32 v;
 230
 231         v = readl(priv->mac_reg + EMAC_CTL0);
 232
 233         if (phydev->duplex)
 234                 v |= BIT(0);
 235         else
 236                 v &= ~BIT(0);
 237
 238         v &= ~0x0C;
 239
 240         switch (phydev->speed) {
 241         case 1000:
 242                 break;
 243         case 100:
 244                 v |= BIT(2);
 245                 v |= BIT(3);
 246                 break;
 247         case 10:
 248                 v |= BIT(3);
 249                 break;
 250         }
 251         writel(v, priv->mac_reg + EMAC_CTL0);
 252 }
 253
 254 static int sun8i_emac_set_syscon_ephy(struct emac_eth_dev *priv, u32 *reg)
 255 {
 256         if (priv->use_internal_phy) {
 257                 /* H3 based SoC's that has an Internal 100MBit PHY
 258                  * needs to be configured and powered up before use
 259                 */
 260                 *reg &= ~H3_EPHY_DEFAULT_MASK;
 261                 *reg |=  H3_EPHY_DEFAULT_VALUE;
 262                 *reg |= priv->phyaddr << H3_EPHY_ADDR_SHIFT;
 263                 *reg &= ~H3_EPHY_SHUTDOWN;
 264                 *reg |= H3_EPHY_SELECT;
 265         } else
 266                 /* This is to select External Gigabit PHY on
 267                  * the boards with H3 SoC.
 268                 */
 269                 *reg &= ~H3_EPHY_SELECT;
 270
 271         return 0;
 272 }
 273
 274 static int sun8i_emac_set_syscon(struct emac_eth_dev *priv)
 275 {
 276         int ret;
 277         u32 reg;
 278
 279         reg = readl(priv->sysctl_reg + 0x30);
 280
 281         if (priv->variant == H3_EMAC) {
 282                 ret = sun8i_emac_set_syscon_ephy(priv, &reg);
 283                 if (ret)
 284                         return ret;
 285         }
 286
 287         reg &= ~(SC_ETCS_MASK | SC_EPIT);
 288         if (priv->variant == H3_EMAC || priv->variant == A64_EMAC)
 289                 reg &= ~SC_RMII_EN;
 290
 291         switch (priv->interface) {
 292         case PHY_INTERFACE_MODE_MII:
 293                 /* default */
 294                 break;
 295         case PHY_INTERFACE_MODE_RGMII:
 296                 reg |= SC_EPIT | SC_ETCS_INT_GMII;
 297                 break;
 298         case PHY_INTERFACE_MODE_RMII:
 299                 if (priv->variant == H3_EMAC ||
 300                     priv->variant == A64_EMAC) {
 301                         reg |= SC_RMII_EN | SC_ETCS_EXT_GMII;
 302                 break;
 303                 }
 304                 /* RMII not supported on A83T */
 305         default:
 306                 debug("%s: Invalid PHY interface\n", __func__);
 307                 return -EINVAL;
 308         }
 309
 310         writel(reg, priv->sysctl_reg + 0x30);
 311
 312         return 0;
 313 }
 314
 315 static int sun8i_phy_init(struct emac_eth_dev *priv, void *dev)
 316 {
 317         struct phy_device *phydev;
 318
 319         phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface);
 320         if (!phydev)
 321                 return -ENODEV;
 322
 323         phy_connect_dev(phydev, dev);
 324
 325         priv->phydev = phydev;
 326         phy_config(priv->phydev);
 327
 328         return 0;
 329 }
 330
 331 static void rx_descs_init(struct emac_eth_dev *priv)
 332 {
 333         struct emac_dma_desc *desc_table_p = &priv->rx_chain[0];
 334         char *rxbuffs = &priv->rxbuffer[0];
 335         struct emac_dma_desc *desc_p;
 336         u32 idx;
 337
 338         /* flush Rx buffers */
 339         flush_dcache_range((uintptr_t)rxbuffs, (ulong)rxbuffs +
 340                         RX_TOTAL_BUFSIZE);
 341
 342         for (idx = 0; idx < CONFIG_RX_DESCR_NUM; idx++) {
 343                 desc_p = &desc_table_p[idx];
 344                 desc_p->buf_addr = (uintptr_t)&rxbuffs[idx * CONFIG_ETH_BUFSIZE]
 345                         ;
 346                 desc_p->next = (uintptr_t)&desc_table_p[idx + 1];
 347                 desc_p->st |= CONFIG_ETH_RXSIZE;
 348                 desc_p->status = BIT(31);
 349         }
 350
 351         /* Correcting the last pointer of the chain */
 352         desc_p->next = (uintptr_t)&desc_table_p[0];
 353
 354         flush_dcache_range((uintptr_t)priv->rx_chain,
 355                            (uintptr_t)priv->rx_chain +
 356                         sizeof(priv->rx_chain));
 357
 358         writel((uintptr_t)&desc_table_p[0], (priv->mac_reg + EMAC_RX_DMA_DESC));
 359         priv->rx_currdescnum = 0;
 360 }
 361
 362 static void tx_descs_init(struct emac_eth_dev *priv)
 363 {
 364         struct emac_dma_desc *desc_table_p = &priv->tx_chain[0];
 365         char *txbuffs = &priv->txbuffer[0];
 366         struct emac_dma_desc *desc_p;
 367         u32 idx;
 368
 369         for (idx = 0; idx < CONFIG_TX_DESCR_NUM; idx++) {
 370                 desc_p = &desc_table_p[idx];
 371                 desc_p->buf_addr = (uintptr_t)&txbuffs[idx * CONFIG_ETH_BUFSIZE]
 372                         ;
 373                 desc_p->next = (uintptr_t)&desc_table_p[idx + 1];
 374                 desc_p->status = (1 << 31);
 375                 desc_p->st = 0;
 376         }
 377
 378         /* Correcting the last pointer of the chain */
 379         desc_p->next =  (uintptr_t)&desc_table_p[0];
 380
 381         /* Flush all Tx buffer descriptors */
 382         flush_dcache_range((uintptr_t)priv->tx_chain,
 383                            (uintptr_t)priv->tx_chain +
 384                         sizeof(priv->tx_chain));
 385
 386         writel((uintptr_t)&desc_table_p[0], priv->mac_reg + EMAC_TX_DMA_DESC);
 387         priv->tx_currdescnum = 0;
 388 }
 389
 390 static int _sun8i_emac_eth_init(struct emac_eth_dev *priv, u8 *enetaddr)
 391 {
 392         u32 reg, v;
 393         int timeout = 100;
 394
 395         reg = readl((priv->mac_reg + EMAC_CTL1));
 396
 397         if (!(reg & 0x1)) {
 398                 /* Soft reset MAC */
 399                 setbits_le32((priv->mac_reg + EMAC_CTL1), 0x1);
 400                 do {
 401                         reg = readl(priv->mac_reg + EMAC_CTL1);
 402                 } while ((reg & 0x01) != 0 &&  (--timeout));
 403                 if (!timeout) {
 404                         printf("%s: Timeout\n", __func__);
 405                         return -1;
 406                 }
 407         }
 408
 409         /* Rewrite mac address after reset */
 410         _sun8i_write_hwaddr(priv, enetaddr);
 411
 412         v = readl(priv->mac_reg + EMAC_TX_CTL1);
 413         /* TX_MD Transmission starts after a full frame located in TX DMA FIFO*/
 414         v |= BIT(1);
 415         writel(v, priv->mac_reg + EMAC_TX_CTL1);
 416
 417         v = readl(priv->mac_reg + EMAC_RX_CTL1);
 418         /* RX_MD RX DMA reads data from RX DMA FIFO to host memory after a
 419          * complete frame has been written to RX DMA FIFO
 420          */
 421         v |= BIT(1);
 422         writel(v, priv->mac_reg + EMAC_RX_CTL1);
 423
 424         /* DMA */
 425         writel(8 << 24, priv->mac_reg + EMAC_CTL1);
 426
 427         /* Initialize rx/tx descriptors */
 428         rx_descs_init(priv);
 429         tx_descs_init(priv);
 430
 431         /* PHY Start Up */
 432         phy_startup(priv->phydev);
 433
 434         sun8i_adjust_link(priv, priv->phydev);
 435
 436         /* Start RX DMA */
 437         v = readl(priv->mac_reg + EMAC_RX_CTL1);
 438         v |= BIT(30);
 439         writel(v, priv->mac_reg + EMAC_RX_CTL1);
 440         /* Start TX DMA */
 441         v = readl(priv->mac_reg + EMAC_TX_CTL1);
 442         v |= BIT(30);
 443         writel(v, priv->mac_reg + EMAC_TX_CTL1);
 444
 445         /* Enable RX/TX */
 446         setbits_le32(priv->mac_reg + EMAC_RX_CTL0, BIT(31));
 447         setbits_le32(priv->mac_reg + EMAC_TX_CTL0, BIT(31));
 448
 449         return 0;
 450 }
 451
 452 static int parse_phy_pins(struct udevice *dev)
 453 {
 454         struct emac_eth_dev *priv = dev_get_priv(dev);
 455         int offset;
 456         const char *pin_name;
 457         int drive, pull = SUN4I_PINCTRL_NO_PULL, i;
 458
 459         offset = fdtdec_lookup_phandle(gd->fdt_blob, dev_of_offset(dev),
 460                                        "pinctrl-0");
 461         if (offset < 0) {
 462                 printf("WARNING: emac: cannot find pinctrl-0 node\n");
 463                 return offset;
 464         }
 465
 466         drive = fdt_getprop_u32_default_node(gd->fdt_blob, offset, 0,
 467                                              "drive-strength", ~0);
 468         if (drive != ~0) {
 469                 if (drive <= 10)
 470                         drive = SUN4I_PINCTRL_10_MA;
 471                 else if (drive <= 20)
 472                         drive = SUN4I_PINCTRL_20_MA;
 473                 else if (drive <= 30)
 474                         drive = SUN4I_PINCTRL_30_MA;
 475                 else
 476                         drive = SUN4I_PINCTRL_40_MA;
 477         }
 478
 479         if (fdt_get_property(gd->fdt_blob, offset, "bias-pull-up", NULL))
 480                 pull = SUN4I_PINCTRL_PULL_UP;
 481         else if (fdt_get_property(gd->fdt_blob, offset, "bias-pull-down", NULL))
 482                 pull = SUN4I_PINCTRL_PULL_DOWN;
 483
 484         for (i = 0; ; i++) {
 485                 int pin;
 486
 487                 pin_name = fdt_stringlist_get(gd->fdt_blob, offset,
 488                                               "pins", i, NULL);
 489                 if (!pin_name)
 490                         break;
 491
 492                 pin = sunxi_name_to_gpio(pin_name);
 493                 if (pin < 0)
 494                         continue;
 495
 496                 if (priv->variant == H3_EMAC)
 497                         sunxi_gpio_set_cfgpin(pin, SUN8I_IOMUX_H3);
 498                 else
 499                         sunxi_gpio_set_cfgpin(pin, SUN8I_IOMUX);
 500
 501                 if (drive != ~0)
 502                         sunxi_gpio_set_drv(pin, drive);
 503                 if (pull != ~0)
 504                         sunxi_gpio_set_pull(pin, pull);
 505         }
 506
 507         if (!i) {
 508                 printf("WARNING: emac: cannot find pins property\n");
 509                 return -2;
 510         }
 511
 512         return 0;
 513 }
 514
 515 static int _sun8i_eth_recv(struct emac_eth_dev *priv, uchar **packetp)
 516 {
 517         u32 status, desc_num = priv->rx_currdescnum;
 518         struct emac_dma_desc *desc_p = &priv->rx_chain[desc_num];
 519         int length = -EAGAIN;
 520         int good_packet = 1;
 521         uintptr_t desc_start = (uintptr_t)desc_p;
 522         uintptr_t desc_end = desc_start +
 523                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
 524
 525         ulong data_start = (uintptr_t)desc_p->buf_addr;
 526         ulong data_end;
 527
 528         /* Invalidate entire buffer descriptor */
 529         invalidate_dcache_range(desc_start, desc_end);
 530
 531         status = desc_p->status;
 532
 533         /* Check for DMA own bit */
 534         if (!(status & BIT(31))) {
 535                 length = (desc_p->status >> 16) & 0x3FFF;
 536
 537                 if (length < 0x40) {
 538                         good_packet = 0;
 539                         debug("RX: Bad Packet (runt)\n");
 540                 }
 541
 542                 data_end = data_start + length;
 543                 /* Invalidate received data */
 544                 invalidate_dcache_range(rounddown(data_start,
 545                                                   ARCH_DMA_MINALIGN),
 546                                         roundup(data_end,
 547                                                 ARCH_DMA_MINALIGN));
 548                 if (good_packet) {
 549                         if (length > CONFIG_ETH_RXSIZE) {
 550                                 printf("Received packet is too big (len=%d)\n",
 551                                        length);
 552                                 return -EMSGSIZE;
 553                         }
 554                         *packetp = (uchar *)(ulong)desc_p->buf_addr;
 555                         return length;
 556                 }
 557         }
 558
 559         return length;
 560 }
 561
 562 static int _sun8i_emac_eth_send(struct emac_eth_dev *priv, void *packet,
 563                                 int len)
 564 {
 565         u32 v, desc_num = priv->tx_currdescnum;
 566         struct emac_dma_desc *desc_p = &priv->tx_chain[desc_num];
 567         uintptr_t desc_start = (uintptr_t)desc_p;
 568         uintptr_t desc_end = desc_start +
 569                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
 570
 571         uintptr_t data_start = (uintptr_t)desc_p->buf_addr;
 572         uintptr_t data_end = data_start +
 573                 roundup(len, ARCH_DMA_MINALIGN);
 574
 575         /* Invalidate entire buffer descriptor */
 576         invalidate_dcache_range(desc_start, desc_end);
 577
 578         desc_p->st = len;
 579         /* Mandatory undocumented bit */
 580         desc_p->st |= BIT(24);
 581
 582         memcpy((void *)data_start, packet, len);
 583
 584         /* Flush data to be sent */
 585         flush_dcache_range(data_start, data_end);
 586
 587         /* frame end */
 588         desc_p->st |= BIT(30);
 589         desc_p->st |= BIT(31);
 590
 591         /*frame begin */
 592         desc_p->st |= BIT(29);
 593         desc_p->status = BIT(31);
 594
 595         /*Descriptors st and status field has changed, so FLUSH it */
 596         flush_dcache_range(desc_start, desc_end);
 597
 598         /* Move to next Descriptor and wrap around */
 599         if (++desc_num >= CONFIG_TX_DESCR_NUM)
 600                 desc_num = 0;
 601         priv->tx_currdescnum = desc_num;
 602
 603         /* Start the DMA */
 604         v = readl(priv->mac_reg + EMAC_TX_CTL1);
 605         v |= BIT(31);/* mandatory */
 606         v |= BIT(30);/* mandatory */
 607         writel(v, priv->mac_reg + EMAC_TX_CTL1);
 608
 609         return 0;
 610 }
 611
 612 static int sun8i_eth_write_hwaddr(struct udevice *dev)
 613 {
 614         struct eth_pdata *pdata = dev_get_platdata(dev);
 615         struct emac_eth_dev *priv = dev_get_priv(dev);
 616
 617         return _sun8i_write_hwaddr(priv, pdata->enetaddr);
 618 }
 619
 620 static void sun8i_emac_board_setup(struct emac_eth_dev *priv)
 621 {
 622         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
 623
 624         if (priv->variant == H3_EMAC) {
 625                 /* Only H3/H5 have clock controls for internal EPHY */
 626                 if (priv->use_internal_phy) {
 627                         /* Set clock gating for ephy */
 628                         setbits_le32(&ccm->bus_gate4,
 629                                      BIT(AHB_GATE_OFFSET_EPHY));
 630
 631                         /* Deassert EPHY */
 632                         setbits_le32(&ccm->ahb_reset2_cfg,
 633                                      BIT(AHB_RESET_OFFSET_EPHY));
 634                 }
 635         }
 636
 637         /* Set clock gating for emac */
 638         setbits_le32(&ccm->ahb_gate0, BIT(AHB_GATE_OFFSET_GMAC));
 639
 640         /* De-assert EMAC */
 641         setbits_le32(&ccm->ahb_reset0_cfg, BIT(AHB_RESET_OFFSET_GMAC));
 642 }
 643
 644 #if defined(CONFIG_DM_GPIO)
 645 static int sun8i_mdio_reset(struct mii_dev *bus)
 646 {
 647         struct udevice *dev = bus->priv;
 648         struct emac_eth_dev *priv = dev_get_priv(dev);
 649         struct sun8i_eth_pdata *pdata = dev_get_platdata(dev);
 650         int ret;
 651
 652         if (!dm_gpio_is_valid(&priv->reset_gpio))
 653                 return 0;
 654
 655         /* reset the phy */
 656         ret = dm_gpio_set_value(&priv->reset_gpio, 0);
 657         if (ret)
 658                 return ret;
 659
 660         udelay(pdata->reset_delays[0]);
 661
 662         ret = dm_gpio_set_value(&priv->reset_gpio, 1);
 663         if (ret)
 664                 return ret;
 665
 666         udelay(pdata->reset_delays[1]);
 667
 668         ret = dm_gpio_set_value(&priv->reset_gpio, 0);
 669         if (ret)
 670                 return ret;
 671
 672         udelay(pdata->reset_delays[2]);
 673
 674         return 0;
 675 }
 676 #endif
 677
 678 static int sun8i_mdio_init(const char *name, struct udevice *priv)
 679 {
 680         struct mii_dev *bus = mdio_alloc();
 681
 682         if (!bus) {
 683                 debug("Failed to allocate MDIO bus\n");
 684                 return -ENOMEM;
 685         }
 686
 687         bus->read = sun8i_mdio_read;
 688         bus->write = sun8i_mdio_write;
 689         snprintf(bus->name, sizeof(bus->name), name);
 690         bus->priv = (void *)priv;
 691 #if defined(CONFIG_DM_GPIO)
 692         bus->reset = sun8i_mdio_reset;
 693 #endif
 694
 695         return  mdio_register(bus);
 696 }
 697
 698 static int sun8i_emac_eth_start(struct udevice *dev)
 699 {
 700         struct eth_pdata *pdata = dev_get_platdata(dev);
 701
 702         return _sun8i_emac_eth_init(dev->priv, pdata->enetaddr);
 703 }
 704
 705 static int sun8i_emac_eth_send(struct udevice *dev, void *packet, int length)
 706 {
 707         struct emac_eth_dev *priv = dev_get_priv(dev);
 708
 709         return _sun8i_emac_eth_send(priv, packet, length);
 710 }
 711
 712 static int sun8i_emac_eth_recv(struct udevice *dev, int flags, uchar **packetp)
 713 {
 714         struct emac_eth_dev *priv = dev_get_priv(dev);
 715
 716         return _sun8i_eth_recv(priv, packetp);
 717 }
 718
 719 static int _sun8i_free_pkt(struct emac_eth_dev *priv)
 720 {
 721         u32 desc_num = priv->rx_currdescnum;
 722         struct emac_dma_desc *desc_p = &priv->rx_chain[desc_num];
 723         uintptr_t desc_start = (uintptr_t)desc_p;
 724         uintptr_t desc_end = desc_start +
 725                 roundup(sizeof(u32), ARCH_DMA_MINALIGN);
 726
 727         /* Make the current descriptor valid again */
 728         desc_p->status |= BIT(31);
 729
 730         /* Flush Status field of descriptor */
 731         flush_dcache_range(desc_start, desc_end);
 732
 733         /* Move to next desc and wrap-around condition. */
 734         if (++desc_num >= CONFIG_RX_DESCR_NUM)
 735                 desc_num = 0;
 736         priv->rx_currdescnum = desc_num;
 737
 738         return 0;
 739 }
 740
 741 static int sun8i_eth_free_pkt(struct udevice *dev, uchar *packet,
 742                               int length)
 743 {
 744         struct emac_eth_dev *priv = dev_get_priv(dev);
 745
 746         return _sun8i_free_pkt(priv);
 747 }
 748
 749 static void sun8i_emac_eth_stop(struct udevice *dev)
 750 {
 751         struct emac_eth_dev *priv = dev_get_priv(dev);
 752
 753         /* Stop Rx/Tx transmitter */
 754         clrbits_le32(priv->mac_reg + EMAC_RX_CTL0, BIT(31));
 755         clrbits_le32(priv->mac_reg + EMAC_TX_CTL0, BIT(31));
 756
 757         /* Stop TX DMA */
 758         clrbits_le32(priv->mac_reg + EMAC_TX_CTL1, BIT(30));
 759
 760         phy_shutdown(priv->phydev);
 761 }
 762
 763 static int sun8i_emac_eth_probe(struct udevice *dev)
 764 {
 765         struct eth_pdata *pdata = dev_get_platdata(dev);
 766         struct emac_eth_dev *priv = dev_get_priv(dev);
 767
 768         priv->mac_reg = (void *)pdata->iobase;
 769
 770         sun8i_emac_board_setup(priv);
 771         sun8i_emac_set_syscon(priv);
 772
 773         sun8i_mdio_init(dev->name, dev);
 774         priv->bus = miiphy_get_dev_by_name(dev->name);
 775
 776         return sun8i_phy_init(priv, dev);
 777 }
 778
 779 static const struct eth_ops sun8i_emac_eth_ops = {
 780         .start                  = sun8i_emac_eth_start,
 781         .write_hwaddr           = sun8i_eth_write_hwaddr,
 782         .send                   = sun8i_emac_eth_send,
 783         .recv                   = sun8i_emac_eth_recv,
 784         .free_pkt               = sun8i_eth_free_pkt,
 785         .stop                   = sun8i_emac_eth_stop,
 786 };
 787
 788 static int sun8i_emac_eth_ofdata_to_platdata(struct udevice *dev)
 789 {
 790         struct sun8i_eth_pdata *sun8i_pdata = dev_get_platdata(dev);
 791         struct eth_pdata *pdata = &sun8i_pdata->eth_pdata;
 792         struct emac_eth_dev *priv = dev_get_priv(dev);
 793         const char *phy_mode;
 794         const fdt32_t *reg;
 795         int node = dev_of_offset(dev);
 796         int offset = 0;
 797 #ifdef CONFIG_DM_GPIO
 798         int reset_flags = GPIOD_IS_OUT;
 799         int ret = 0;
 800 #endif
 801
 802         pdata->iobase = devfdt_get_addr(dev);
 803         if (pdata->iobase == FDT_ADDR_T_NONE) {
 804                 debug("%s: Cannot find MAC base address\n", __func__);
 805                 return -EINVAL;
 806         }
 807
 808         offset = fdtdec_lookup_phandle(gd->fdt_blob, node, "syscon");
 809         if (offset < 0) {
 810                 debug("%s: cannot find syscon node\n", __func__);
 811                 return -EINVAL;
 812         }
 813         reg = fdt_getprop(gd->fdt_blob, offset, "reg", NULL);
 814         if (!reg) {
 815                 debug("%s: cannot find reg property in syscon node\n",
 816                       __func__);
 817                 return -EINVAL;
 818         }
 819         priv->sysctl_reg = fdt_translate_address((void *)gd->fdt_blob,
 820                                                  offset, reg);
 821         if (priv->sysctl_reg == FDT_ADDR_T_NONE) {
 822                 debug("%s: Cannot find syscon base address\n", __func__);
 823                 return -EINVAL;
 824         }
 825
 826         pdata->phy_interface = -1;
 827         priv->phyaddr = -1;
 828         priv->use_internal_phy = false;
 829
 830         offset = fdtdec_lookup_phandle(gd->fdt_blob, node, "phy-handle");
 831         if (offset < 0) {
 832                 debug("%s: Cannot find PHY address\n", __func__);
 833                 return -EINVAL;
 834         }
 835         priv->phyaddr = fdtdec_get_int(gd->fdt_blob, offset, "reg", -1);
 836
 837         phy_mode = fdt_getprop(gd->fdt_blob, node, "phy-mode", NULL);
 838
 839         if (phy_mode)
 840                 pdata->phy_interface = phy_get_interface_by_name(phy_mode);
 841         printf("phy interface%d\n", pdata->phy_interface);
 842
 843         if (pdata->phy_interface == -1) {
 844                 debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);
 845                 return -EINVAL;
 846         }
 847
 848         priv->variant = dev_get_driver_data(dev);
 849
 850         if (!priv->variant) {
 851                 printf("%s: Missing variant\n", __func__);
 852                 return -EINVAL;
 853         }
 854
 855         if (priv->variant == H3_EMAC) {
 856                 int parent = fdt_parent_offset(gd->fdt_blob, offset);
 857
 858                 if (parent >= 0 &&
 859                     !fdt_node_check_compatible(gd->fdt_blob, parent,
 860                                 "allwinner,sun8i-h3-mdio-internal"))
 861                         priv->use_internal_phy = true;
 862         }
 863
 864         priv->interface = pdata->phy_interface;
 865
 866         if (!priv->use_internal_phy)
 867                 parse_phy_pins(dev);
 868
 869 #ifdef CONFIG_DM_GPIO
 870         if (fdtdec_get_bool(gd->fdt_blob, dev_of_offset(dev),
 871                             "snps,reset-active-low"))
 872                 reset_flags |= GPIOD_ACTIVE_LOW;
 873
 874         ret = gpio_request_by_name(dev, "snps,reset-gpio", 0,
 875                                    &priv->reset_gpio, reset_flags);
 876
 877         if (ret == 0) {
 878                 ret = fdtdec_get_int_array(gd->fdt_blob, dev_of_offset(dev),
 879                                            "snps,reset-delays-us",
 880                                            sun8i_pdata->reset_delays, 3);
 881         } else if (ret == -ENOENT) {
 882                 ret = 0;
 883         }
 884 #endif
 885
 886         return 0;
 887 }
 888
 889 static const struct udevice_id sun8i_emac_eth_ids[] = {
 890         {.compatible = "allwinner,sun8i-h3-emac", .data = (uintptr_t)H3_EMAC },
 891         {.compatible = "allwinner,sun50i-a64-emac",
 892                 .data = (uintptr_t)A64_EMAC },
 893         {.compatible = "allwinner,sun8i-a83t-emac",
 894                 .data = (uintptr_t)A83T_EMAC },
 895         { }
 896 };
 897
 898 U_BOOT_DRIVER(eth_sun8i_emac) = {
 899         .name   = "eth_sun8i_emac",
 900         .id     = UCLASS_ETH,
 901         .of_match = sun8i_emac_eth_ids,
 902         .ofdata_to_platdata = sun8i_emac_eth_ofdata_to_platdata,
 903         .probe  = sun8i_emac_eth_probe,
 904         .ops    = &sun8i_emac_eth_ops,
 905         .priv_auto_alloc_size = sizeof(struct emac_eth_dev),
 906         .platdata_auto_alloc_size = sizeof(struct sun8i_eth_pdata),
 907         .flags = DM_FLAG_ALLOC_PRIV_DMA,
 908 };