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