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

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