drivers/net/dwc_eth_qos.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016, NVIDIA CORPORATION.
   4  *
   5  * Portions based on U-Boot's rtl8169.c.
   6  */
   7
   8 /*
   9  * This driver supports the Synopsys Designware Ethernet QOS (Quality Of
  10  * Service) IP block. The IP supports multiple options for bus type, clocking/
  11  * reset structure, and feature list.
  12  *
  13  * The driver is written such that generic core logic is kept separate from
  14  * configuration-specific logic. Code that interacts with configuration-
  15  * specific resources is split out into separate functions to avoid polluting
  16  * common code. If/when this driver is enhanced to support multiple
  17  * configurations, the core code should be adapted to call all configuration-
  18  * specific functions through function pointers, with the definition of those
  19  * function pointers being supplied by struct udevice_id eqos_ids[]'s .data
  20  * field.
  21  *
  22  * The following configurations are currently supported:
  23  * tegra186:
  24  *    NVIDIA's Tegra186 chip. This configuration uses an AXI master/DMA bus, an
  25  *    AHB slave/register bus, contains the DMA, MTL, and MAC sub-blocks, and
  26  *    supports a single RGMII PHY. This configuration also has SW control over
  27  *    all clock and reset signals to the HW block.
  28  */
  29 #include <common.h>
  30 #include <clk.h>
  31 #include <cpu_func.h>
  32 #include <dm.h>
  33 #include <errno.h>
  34 #include <malloc.h>
  35 #include <memalign.h>
  36 #include <miiphy.h>
  37 #include <net.h>
  38 #include <netdev.h>
  39 #include <phy.h>
  40 #include <reset.h>
  41 #include <wait_bit.h>
  42 #include <asm/gpio.h>
  43 #include <asm/io.h>
  44 #include <eth_phy.h>
  45
  46 /* Core registers */
  47
  48 #define EQOS_MAC_REGS_BASE 0x000
  49 struct eqos_mac_regs {
  50         uint32_t configuration;                         /* 0x000 */
  51         uint32_t unused_004[(0x070 - 0x004) / 4];       /* 0x004 */
  52         uint32_t q0_tx_flow_ctrl;                       /* 0x070 */
  53         uint32_t unused_070[(0x090 - 0x074) / 4];       /* 0x074 */
  54         uint32_t rx_flow_ctrl;                          /* 0x090 */
  55         uint32_t unused_094;                            /* 0x094 */
  56         uint32_t txq_prty_map0;                         /* 0x098 */
  57         uint32_t unused_09c;                            /* 0x09c */
  58         uint32_t rxq_ctrl0;                             /* 0x0a0 */
  59         uint32_t unused_0a4;                            /* 0x0a4 */
  60         uint32_t rxq_ctrl2;                             /* 0x0a8 */
  61         uint32_t unused_0ac[(0x0dc - 0x0ac) / 4];       /* 0x0ac */
  62         uint32_t us_tic_counter;                        /* 0x0dc */
  63         uint32_t unused_0e0[(0x11c - 0x0e0) / 4];       /* 0x0e0 */
  64         uint32_t hw_feature0;                           /* 0x11c */
  65         uint32_t hw_feature1;                           /* 0x120 */
  66         uint32_t hw_feature2;                           /* 0x124 */
  67         uint32_t unused_128[(0x200 - 0x128) / 4];       /* 0x128 */
  68         uint32_t mdio_address;                          /* 0x200 */
  69         uint32_t mdio_data;                             /* 0x204 */
  70         uint32_t unused_208[(0x300 - 0x208) / 4];       /* 0x208 */
  71         uint32_t address0_high;                         /* 0x300 */
  72         uint32_t address0_low;                          /* 0x304 */
  73 };
  74
  75 #define EQOS_MAC_CONFIGURATION_GPSLCE                   BIT(23)
  76 #define EQOS_MAC_CONFIGURATION_CST                      BIT(21)
  77 #define EQOS_MAC_CONFIGURATION_ACS                      BIT(20)
  78 #define EQOS_MAC_CONFIGURATION_WD                       BIT(19)
  79 #define EQOS_MAC_CONFIGURATION_JD                       BIT(17)
  80 #define EQOS_MAC_CONFIGURATION_JE                       BIT(16)
  81 #define EQOS_MAC_CONFIGURATION_PS                       BIT(15)
  82 #define EQOS_MAC_CONFIGURATION_FES                      BIT(14)
  83 #define EQOS_MAC_CONFIGURATION_DM                       BIT(13)
  84 #define EQOS_MAC_CONFIGURATION_TE                       BIT(1)
  85 #define EQOS_MAC_CONFIGURATION_RE                       BIT(0)
  86
  87 #define EQOS_MAC_Q0_TX_FLOW_CTRL_PT_SHIFT               16
  88 #define EQOS_MAC_Q0_TX_FLOW_CTRL_PT_MASK                0xffff
  89 #define EQOS_MAC_Q0_TX_FLOW_CTRL_TFE                    BIT(1)
  90
  91 #define EQOS_MAC_RX_FLOW_CTRL_RFE                       BIT(0)
  92
  93 #define EQOS_MAC_TXQ_PRTY_MAP0_PSTQ0_SHIFT              0
  94 #define EQOS_MAC_TXQ_PRTY_MAP0_PSTQ0_MASK               0xff
  95
  96 #define EQOS_MAC_RXQ_CTRL0_RXQ0EN_SHIFT                 0
  97 #define EQOS_MAC_RXQ_CTRL0_RXQ0EN_MASK                  3
  98 #define EQOS_MAC_RXQ_CTRL0_RXQ0EN_NOT_ENABLED           0
  99 #define EQOS_MAC_RXQ_CTRL0_RXQ0EN_ENABLED_DCB           2
 100 #define EQOS_MAC_RXQ_CTRL0_RXQ0EN_ENABLED_AV            1
 101
 102 #define EQOS_MAC_RXQ_CTRL2_PSRQ0_SHIFT                  0
 103 #define EQOS_MAC_RXQ_CTRL2_PSRQ0_MASK                   0xff
 104
 105 #define EQOS_MAC_HW_FEATURE1_TXFIFOSIZE_SHIFT           6
 106 #define EQOS_MAC_HW_FEATURE1_TXFIFOSIZE_MASK            0x1f
 107 #define EQOS_MAC_HW_FEATURE1_RXFIFOSIZE_SHIFT           0
 108 #define EQOS_MAC_HW_FEATURE1_RXFIFOSIZE_MASK            0x1f
 109
 110 #define EQOS_MAC_MDIO_ADDRESS_PA_SHIFT                  21
 111 #define EQOS_MAC_MDIO_ADDRESS_RDA_SHIFT                 16
 112 #define EQOS_MAC_MDIO_ADDRESS_CR_SHIFT                  8
 113 #define EQOS_MAC_MDIO_ADDRESS_CR_20_35                  2
 114 #define EQOS_MAC_MDIO_ADDRESS_CR_250_300                5
 115 #define EQOS_MAC_MDIO_ADDRESS_SKAP                      BIT(4)
 116 #define EQOS_MAC_MDIO_ADDRESS_GOC_SHIFT                 2
 117 #define EQOS_MAC_MDIO_ADDRESS_GOC_READ                  3
 118 #define EQOS_MAC_MDIO_ADDRESS_GOC_WRITE                 1
 119 #define EQOS_MAC_MDIO_ADDRESS_C45E                      BIT(1)
 120 #define EQOS_MAC_MDIO_ADDRESS_GB                        BIT(0)
 121
 122 #define EQOS_MAC_MDIO_DATA_GD_MASK                      0xffff
 123
 124 #define EQOS_MTL_REGS_BASE 0xd00
 125 struct eqos_mtl_regs {
 126         uint32_t txq0_operation_mode;                   /* 0xd00 */
 127         uint32_t unused_d04;                            /* 0xd04 */
 128         uint32_t txq0_debug;                            /* 0xd08 */
 129         uint32_t unused_d0c[(0xd18 - 0xd0c) / 4];       /* 0xd0c */
 130         uint32_t txq0_quantum_weight;                   /* 0xd18 */
 131         uint32_t unused_d1c[(0xd30 - 0xd1c) / 4];       /* 0xd1c */
 132         uint32_t rxq0_operation_mode;                   /* 0xd30 */
 133         uint32_t unused_d34;                            /* 0xd34 */
 134         uint32_t rxq0_debug;                            /* 0xd38 */
 135 };
 136
 137 #define EQOS_MTL_TXQ0_OPERATION_MODE_TQS_SHIFT          16
 138 #define EQOS_MTL_TXQ0_OPERATION_MODE_TQS_MASK           0x1ff
 139 #define EQOS_MTL_TXQ0_OPERATION_MODE_TXQEN_SHIFT        2
 140 #define EQOS_MTL_TXQ0_OPERATION_MODE_TXQEN_MASK         3
 141 #define EQOS_MTL_TXQ0_OPERATION_MODE_TXQEN_ENABLED      2
 142 #define EQOS_MTL_TXQ0_OPERATION_MODE_TSF                BIT(1)
 143 #define EQOS_MTL_TXQ0_OPERATION_MODE_FTQ                BIT(0)
 144
 145 #define EQOS_MTL_TXQ0_DEBUG_TXQSTS                      BIT(4)
 146 #define EQOS_MTL_TXQ0_DEBUG_TRCSTS_SHIFT                1
 147 #define EQOS_MTL_TXQ0_DEBUG_TRCSTS_MASK                 3
 148
 149 #define EQOS_MTL_RXQ0_OPERATION_MODE_RQS_SHIFT          20
 150 #define EQOS_MTL_RXQ0_OPERATION_MODE_RQS_MASK           0x3ff
 151 #define EQOS_MTL_RXQ0_OPERATION_MODE_RFD_SHIFT          14
 152 #define EQOS_MTL_RXQ0_OPERATION_MODE_RFD_MASK           0x3f
 153 #define EQOS_MTL_RXQ0_OPERATION_MODE_RFA_SHIFT          8
 154 #define EQOS_MTL_RXQ0_OPERATION_MODE_RFA_MASK           0x3f
 155 #define EQOS_MTL_RXQ0_OPERATION_MODE_EHFC               BIT(7)
 156 #define EQOS_MTL_RXQ0_OPERATION_MODE_RSF                BIT(5)
 157
 158 #define EQOS_MTL_RXQ0_DEBUG_PRXQ_SHIFT                  16
 159 #define EQOS_MTL_RXQ0_DEBUG_PRXQ_MASK                   0x7fff
 160 #define EQOS_MTL_RXQ0_DEBUG_RXQSTS_SHIFT                4
 161 #define EQOS_MTL_RXQ0_DEBUG_RXQSTS_MASK                 3
 162
 163 #define EQOS_DMA_REGS_BASE 0x1000
 164 struct eqos_dma_regs {
 165         uint32_t mode;                                  /* 0x1000 */
 166         uint32_t sysbus_mode;                           /* 0x1004 */
 167         uint32_t unused_1008[(0x1100 - 0x1008) / 4];    /* 0x1008 */
 168         uint32_t ch0_control;                           /* 0x1100 */
 169         uint32_t ch0_tx_control;                        /* 0x1104 */
 170         uint32_t ch0_rx_control;                        /* 0x1108 */
 171         uint32_t unused_110c;                           /* 0x110c */
 172         uint32_t ch0_txdesc_list_haddress;              /* 0x1110 */
 173         uint32_t ch0_txdesc_list_address;               /* 0x1114 */
 174         uint32_t ch0_rxdesc_list_haddress;              /* 0x1118 */
 175         uint32_t ch0_rxdesc_list_address;               /* 0x111c */
 176         uint32_t ch0_txdesc_tail_pointer;               /* 0x1120 */
 177         uint32_t unused_1124;                           /* 0x1124 */
 178         uint32_t ch0_rxdesc_tail_pointer;               /* 0x1128 */
 179         uint32_t ch0_txdesc_ring_length;                /* 0x112c */
 180         uint32_t ch0_rxdesc_ring_length;                /* 0x1130 */
 181 };
 182
 183 #define EQOS_DMA_MODE_SWR                               BIT(0)
 184
 185 #define EQOS_DMA_SYSBUS_MODE_RD_OSR_LMT_SHIFT           16
 186 #define EQOS_DMA_SYSBUS_MODE_RD_OSR_LMT_MASK            0xf
 187 #define EQOS_DMA_SYSBUS_MODE_EAME                       BIT(11)
 188 #define EQOS_DMA_SYSBUS_MODE_BLEN16                     BIT(3)
 189 #define EQOS_DMA_SYSBUS_MODE_BLEN8                      BIT(2)
 190 #define EQOS_DMA_SYSBUS_MODE_BLEN4                      BIT(1)
 191
 192 #define EQOS_DMA_CH0_CONTROL_PBLX8                      BIT(16)
 193
 194 #define EQOS_DMA_CH0_TX_CONTROL_TXPBL_SHIFT             16
 195 #define EQOS_DMA_CH0_TX_CONTROL_TXPBL_MASK              0x3f
 196 #define EQOS_DMA_CH0_TX_CONTROL_OSP                     BIT(4)
 197 #define EQOS_DMA_CH0_TX_CONTROL_ST                      BIT(0)
 198
 199 #define EQOS_DMA_CH0_RX_CONTROL_RXPBL_SHIFT             16
 200 #define EQOS_DMA_CH0_RX_CONTROL_RXPBL_MASK              0x3f
 201 #define EQOS_DMA_CH0_RX_CONTROL_RBSZ_SHIFT              1
 202 #define EQOS_DMA_CH0_RX_CONTROL_RBSZ_MASK               0x3fff
 203 #define EQOS_DMA_CH0_RX_CONTROL_SR                      BIT(0)
 204
 205 /* These registers are Tegra186-specific */
 206 #define EQOS_TEGRA186_REGS_BASE 0x8800
 207 struct eqos_tegra186_regs {
 208         uint32_t sdmemcomppadctrl;                      /* 0x8800 */
 209         uint32_t auto_cal_config;                       /* 0x8804 */
 210         uint32_t unused_8808;                           /* 0x8808 */
 211         uint32_t auto_cal_status;                       /* 0x880c */
 212 };
 213
 214 #define EQOS_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD     BIT(31)
 215
 216 #define EQOS_AUTO_CAL_CONFIG_START                      BIT(31)
 217 #define EQOS_AUTO_CAL_CONFIG_ENABLE                     BIT(29)
 218
 219 #define EQOS_AUTO_CAL_STATUS_ACTIVE                     BIT(31)
 220
 221 /* Descriptors */
 222
 223 #define EQOS_DESCRIPTOR_WORDS   4
 224 #define EQOS_DESCRIPTOR_SIZE    (EQOS_DESCRIPTOR_WORDS * 4)
 225 /* We assume ARCH_DMA_MINALIGN >= 16; 16 is the EQOS HW minimum */
 226 #define EQOS_DESCRIPTOR_ALIGN   ARCH_DMA_MINALIGN
 227 #define EQOS_DESCRIPTORS_TX     4
 228 #define EQOS_DESCRIPTORS_RX     4
 229 #define EQOS_DESCRIPTORS_NUM    (EQOS_DESCRIPTORS_TX + EQOS_DESCRIPTORS_RX)
 230 #define EQOS_DESCRIPTORS_SIZE   ALIGN(EQOS_DESCRIPTORS_NUM * \
 231                                       EQOS_DESCRIPTOR_SIZE, ARCH_DMA_MINALIGN)
 232 #define EQOS_BUFFER_ALIGN       ARCH_DMA_MINALIGN
 233 #define EQOS_MAX_PACKET_SIZE    ALIGN(1568, ARCH_DMA_MINALIGN)
 234 #define EQOS_RX_BUFFER_SIZE     (EQOS_DESCRIPTORS_RX * EQOS_MAX_PACKET_SIZE)
 235
 236 /*
 237  * Warn if the cache-line size is larger than the descriptor size. In such
 238  * cases the driver will likely fail because the CPU needs to flush the cache
 239  * when requeuing RX buffers, therefore descriptors written by the hardware
 240  * may be discarded. Architectures with full IO coherence, such as x86, do not
 241  * experience this issue, and hence are excluded from this condition.
 242  *
 243  * This can be fixed by defining CONFIG_SYS_NONCACHED_MEMORY which will cause
 244  * the driver to allocate descriptors from a pool of non-cached memory.
 245  */
 246 #if EQOS_DESCRIPTOR_SIZE < ARCH_DMA_MINALIGN
 247 #if !defined(CONFIG_SYS_NONCACHED_MEMORY) && \
 248         !CONFIG_IS_ENABLED(SYS_DCACHE_OFF) && !defined(CONFIG_X86)
 249 #warning Cache line size is larger than descriptor size
 250 #endif
 251 #endif
 252
 253 struct eqos_desc {
 254         u32 des0;
 255         u32 des1;
 256         u32 des2;
 257         u32 des3;
 258 };
 259
 260 #define EQOS_DESC3_OWN          BIT(31)
 261 #define EQOS_DESC3_FD           BIT(29)
 262 #define EQOS_DESC3_LD           BIT(28)
 263 #define EQOS_DESC3_BUF1V        BIT(24)
 264
 265 struct eqos_config {
 266         bool reg_access_always_ok;
 267         int mdio_wait;
 268         int swr_wait;
 269         int config_mac;
 270         int config_mac_mdio;
 271         phy_interface_t (*interface)(struct udevice *dev);
 272         struct eqos_ops *ops;
 273 };
 274
 275 struct eqos_ops {
 276         void (*eqos_inval_desc)(void *desc);
 277         void (*eqos_flush_desc)(void *desc);
 278         void (*eqos_inval_buffer)(void *buf, size_t size);
 279         void (*eqos_flush_buffer)(void *buf, size_t size);
 280         int (*eqos_probe_resources)(struct udevice *dev);
 281         int (*eqos_remove_resources)(struct udevice *dev);
 282         int (*eqos_stop_resets)(struct udevice *dev);
 283         int (*eqos_start_resets)(struct udevice *dev);
 284         void (*eqos_stop_clks)(struct udevice *dev);
 285         int (*eqos_start_clks)(struct udevice *dev);
 286         int (*eqos_calibrate_pads)(struct udevice *dev);
 287         int (*eqos_disable_calibration)(struct udevice *dev);
 288         int (*eqos_set_tx_clk_speed)(struct udevice *dev);
 289         ulong (*eqos_get_tick_clk_rate)(struct udevice *dev);
 290 };
 291
 292 struct eqos_priv {
 293         struct udevice *dev;
 294         const struct eqos_config *config;
 295         fdt_addr_t regs;
 296         struct eqos_mac_regs *mac_regs;
 297         struct eqos_mtl_regs *mtl_regs;
 298         struct eqos_dma_regs *dma_regs;
 299         struct eqos_tegra186_regs *tegra186_regs;
 300         struct reset_ctl reset_ctl;
 301         struct gpio_desc phy_reset_gpio;
 302         struct clk clk_master_bus;
 303         struct clk clk_rx;
 304         struct clk clk_ptp_ref;
 305         struct clk clk_tx;
 306         struct clk clk_ck;
 307         struct clk clk_slave_bus;
 308         struct mii_dev *mii;
 309         struct phy_device *phy;
 310         int phyaddr;
 311         u32 max_speed;
 312         void *descs;
 313         struct eqos_desc *tx_descs;
 314         struct eqos_desc *rx_descs;
 315         int tx_desc_idx, rx_desc_idx;
 316         void *tx_dma_buf;
 317         void *rx_dma_buf;
 318         void *rx_pkt;
 319         bool started;
 320         bool reg_access_ok;
 321 };
 322
 323 /*
 324  * TX and RX descriptors are 16 bytes. This causes problems with the cache
 325  * maintenance on CPUs where the cache-line size exceeds the size of these
 326  * descriptors. What will happen is that when the driver receives a packet
 327  * it will be immediately requeued for the hardware to reuse. The CPU will
 328  * therefore need to flush the cache-line containing the descriptor, which
 329  * will cause all other descriptors in the same cache-line to be flushed
 330  * along with it. If one of those descriptors had been written to by the
 331  * device those changes (and the associated packet) will be lost.
 332  *
 333  * To work around this, we make use of non-cached memory if available. If
 334  * descriptors are mapped uncached there's no need to manually flush them
 335  * or invalidate them.
 336  *
 337  * Note that this only applies to descriptors. The packet data buffers do
 338  * not have the same constraints since they are 1536 bytes large, so they
 339  * are unlikely to share cache-lines.
 340  */
 341 static void *eqos_alloc_descs(unsigned int num)
 342 {
 343 #ifdef CONFIG_SYS_NONCACHED_MEMORY
 344         return (void *)noncached_alloc(EQOS_DESCRIPTORS_SIZE,
 345                                       EQOS_DESCRIPTOR_ALIGN);
 346 #else
 347         return memalign(EQOS_DESCRIPTOR_ALIGN, EQOS_DESCRIPTORS_SIZE);
 348 #endif
 349 }
 350
 351 static void eqos_free_descs(void *descs)
 352 {
 353 #ifdef CONFIG_SYS_NONCACHED_MEMORY
 354         /* FIXME: noncached_alloc() has no opposite */
 355 #else
 356         free(descs);
 357 #endif
 358 }
 359
 360 static void eqos_inval_desc_tegra186(void *desc)
 361 {
 362 #ifndef CONFIG_SYS_NONCACHED_MEMORY
 363         unsigned long start = (unsigned long)desc & ~(ARCH_DMA_MINALIGN - 1);
 364         unsigned long end = ALIGN(start + EQOS_DESCRIPTOR_SIZE,
 365                                   ARCH_DMA_MINALIGN);
 366
 367         invalidate_dcache_range(start, end);
 368 #endif
 369 }
 370
 371 static void eqos_inval_desc_stm32(void *desc)
 372 {
 373 #ifndef CONFIG_SYS_NONCACHED_MEMORY
 374         unsigned long start = rounddown((unsigned long)desc, ARCH_DMA_MINALIGN);
 375         unsigned long end = roundup((unsigned long)desc + EQOS_DESCRIPTOR_SIZE,
 376                                     ARCH_DMA_MINALIGN);
 377
 378         invalidate_dcache_range(start, end);
 379 #endif
 380 }
 381
 382 static void eqos_flush_desc_tegra186(void *desc)
 383 {
 384 #ifndef CONFIG_SYS_NONCACHED_MEMORY
 385         flush_cache((unsigned long)desc, EQOS_DESCRIPTOR_SIZE);
 386 #endif
 387 }
 388
 389 static void eqos_flush_desc_stm32(void *desc)
 390 {
 391 #ifndef CONFIG_SYS_NONCACHED_MEMORY
 392         unsigned long start = rounddown((unsigned long)desc, ARCH_DMA_MINALIGN);
 393         unsigned long end = roundup((unsigned long)desc + EQOS_DESCRIPTOR_SIZE,
 394                                     ARCH_DMA_MINALIGN);
 395
 396         flush_dcache_range(start, end);
 397 #endif
 398 }
 399
 400 static void eqos_inval_buffer_tegra186(void *buf, size_t size)
 401 {
 402         unsigned long start = (unsigned long)buf & ~(ARCH_DMA_MINALIGN - 1);
 403         unsigned long end = ALIGN(start + size, ARCH_DMA_MINALIGN);
 404
 405         invalidate_dcache_range(start, end);
 406 }
 407
 408 static void eqos_inval_buffer_stm32(void *buf, size_t size)
 409 {
 410         unsigned long start = rounddown((unsigned long)buf, ARCH_DMA_MINALIGN);
 411         unsigned long end = roundup((unsigned long)buf + size,
 412                                     ARCH_DMA_MINALIGN);
 413
 414         invalidate_dcache_range(start, end);
 415 }
 416
 417 static void eqos_flush_buffer_tegra186(void *buf, size_t size)
 418 {
 419         flush_cache((unsigned long)buf, size);
 420 }
 421
 422 static void eqos_flush_buffer_stm32(void *buf, size_t size)
 423 {
 424         unsigned long start = rounddown((unsigned long)buf, ARCH_DMA_MINALIGN);
 425         unsigned long end = roundup((unsigned long)buf + size,
 426                                     ARCH_DMA_MINALIGN);
 427
 428         flush_dcache_range(start, end);
 429 }
 430
 431 static int eqos_mdio_wait_idle(struct eqos_priv *eqos)
 432 {
 433         return wait_for_bit_le32(&eqos->mac_regs->mdio_address,
 434                                  EQOS_MAC_MDIO_ADDRESS_GB, false,
 435                                  1000000, true);
 436 }
 437
 438 static int eqos_mdio_read(struct mii_dev *bus, int mdio_addr, int mdio_devad,
 439                           int mdio_reg)
 440 {
 441         struct eqos_priv *eqos = bus->priv;
 442         u32 val;
 443         int ret;
 444
 445         debug("%s(dev=%p, addr=%x, reg=%d):\n", __func__, eqos->dev, mdio_addr,
 446               mdio_reg);
 447
 448         ret = eqos_mdio_wait_idle(eqos);
 449         if (ret) {
 450                 pr_err("MDIO not idle at entry");
 451                 return ret;
 452         }
 453
 454         val = readl(&eqos->mac_regs->mdio_address);
 455         val &= EQOS_MAC_MDIO_ADDRESS_SKAP |
 456                 EQOS_MAC_MDIO_ADDRESS_C45E;
 457         val |= (mdio_addr << EQOS_MAC_MDIO_ADDRESS_PA_SHIFT) |
 458                 (mdio_reg << EQOS_MAC_MDIO_ADDRESS_RDA_SHIFT) |
 459                 (eqos->config->config_mac_mdio <<
 460                  EQOS_MAC_MDIO_ADDRESS_CR_SHIFT) |
 461                 (EQOS_MAC_MDIO_ADDRESS_GOC_READ <<
 462                  EQOS_MAC_MDIO_ADDRESS_GOC_SHIFT) |
 463                 EQOS_MAC_MDIO_ADDRESS_GB;
 464         writel(val, &eqos->mac_regs->mdio_address);
 465
 466         udelay(eqos->config->mdio_wait);
 467
 468         ret = eqos_mdio_wait_idle(eqos);
 469         if (ret) {
 470                 pr_err("MDIO read didn't complete");
 471                 return ret;
 472         }
 473
 474         val = readl(&eqos->mac_regs->mdio_data);
 475         val &= EQOS_MAC_MDIO_DATA_GD_MASK;
 476
 477         debug("%s: val=%x\n", __func__, val);
 478
 479         return val;
 480 }
 481
 482 static int eqos_mdio_write(struct mii_dev *bus, int mdio_addr, int mdio_devad,
 483                            int mdio_reg, u16 mdio_val)
 484 {
 485         struct eqos_priv *eqos = bus->priv;
 486         u32 val;
 487         int ret;
 488
 489         debug("%s(dev=%p, addr=%x, reg=%d, val=%x):\n", __func__, eqos->dev,
 490               mdio_addr, mdio_reg, mdio_val);
 491
 492         ret = eqos_mdio_wait_idle(eqos);
 493         if (ret) {
 494                 pr_err("MDIO not idle at entry");
 495                 return ret;
 496         }
 497
 498         writel(mdio_val, &eqos->mac_regs->mdio_data);
 499
 500         val = readl(&eqos->mac_regs->mdio_address);
 501         val &= EQOS_MAC_MDIO_ADDRESS_SKAP |
 502                 EQOS_MAC_MDIO_ADDRESS_C45E;
 503         val |= (mdio_addr << EQOS_MAC_MDIO_ADDRESS_PA_SHIFT) |
 504                 (mdio_reg << EQOS_MAC_MDIO_ADDRESS_RDA_SHIFT) |
 505                 (eqos->config->config_mac_mdio <<
 506                  EQOS_MAC_MDIO_ADDRESS_CR_SHIFT) |
 507                 (EQOS_MAC_MDIO_ADDRESS_GOC_WRITE <<
 508                  EQOS_MAC_MDIO_ADDRESS_GOC_SHIFT) |
 509                 EQOS_MAC_MDIO_ADDRESS_GB;
 510         writel(val, &eqos->mac_regs->mdio_address);
 511
 512         udelay(eqos->config->mdio_wait);
 513
 514         ret = eqos_mdio_wait_idle(eqos);
 515         if (ret) {
 516                 pr_err("MDIO read didn't complete");
 517                 return ret;
 518         }
 519
 520         return 0;
 521 }
 522
 523 static int eqos_start_clks_tegra186(struct udevice *dev)
 524 {
 525         struct eqos_priv *eqos = dev_get_priv(dev);
 526         int ret;
 527
 528         debug("%s(dev=%p):\n", __func__, dev);
 529
 530         ret = clk_enable(&eqos->clk_slave_bus);
 531         if (ret < 0) {
 532                 pr_err("clk_enable(clk_slave_bus) failed: %d", ret);
 533                 goto err;
 534         }
 535
 536         ret = clk_enable(&eqos->clk_master_bus);
 537         if (ret < 0) {
 538                 pr_err("clk_enable(clk_master_bus) failed: %d", ret);
 539                 goto err_disable_clk_slave_bus;
 540         }
 541
 542         ret = clk_enable(&eqos->clk_rx);
 543         if (ret < 0) {
 544                 pr_err("clk_enable(clk_rx) failed: %d", ret);
 545                 goto err_disable_clk_master_bus;
 546         }
 547
 548         ret = clk_enable(&eqos->clk_ptp_ref);
 549         if (ret < 0) {
 550                 pr_err("clk_enable(clk_ptp_ref) failed: %d", ret);
 551                 goto err_disable_clk_rx;
 552         }
 553
 554         ret = clk_set_rate(&eqos->clk_ptp_ref, 125 * 1000 * 1000);
 555         if (ret < 0) {
 556                 pr_err("clk_set_rate(clk_ptp_ref) failed: %d", ret);
 557                 goto err_disable_clk_ptp_ref;
 558         }
 559
 560         ret = clk_enable(&eqos->clk_tx);
 561         if (ret < 0) {
 562                 pr_err("clk_enable(clk_tx) failed: %d", ret);
 563                 goto err_disable_clk_ptp_ref;
 564         }
 565
 566         debug("%s: OK\n", __func__);
 567         return 0;
 568
 569 err_disable_clk_ptp_ref:
 570         clk_disable(&eqos->clk_ptp_ref);
 571 err_disable_clk_rx:
 572         clk_disable(&eqos->clk_rx);
 573 err_disable_clk_master_bus:
 574         clk_disable(&eqos->clk_master_bus);
 575 err_disable_clk_slave_bus:
 576         clk_disable(&eqos->clk_slave_bus);
 577 err:
 578         debug("%s: FAILED: %d\n", __func__, ret);
 579         return ret;
 580 }
 581
 582 static int eqos_start_clks_stm32(struct udevice *dev)
 583 {
 584         struct eqos_priv *eqos = dev_get_priv(dev);
 585         int ret;
 586
 587         debug("%s(dev=%p):\n", __func__, dev);
 588
 589         ret = clk_enable(&eqos->clk_master_bus);
 590         if (ret < 0) {
 591                 pr_err("clk_enable(clk_master_bus) failed: %d", ret);
 592                 goto err;
 593         }
 594
 595         ret = clk_enable(&eqos->clk_rx);
 596         if (ret < 0) {
 597                 pr_err("clk_enable(clk_rx) failed: %d", ret);
 598                 goto err_disable_clk_master_bus;
 599         }
 600
 601         ret = clk_enable(&eqos->clk_tx);
 602         if (ret < 0) {
 603                 pr_err("clk_enable(clk_tx) failed: %d", ret);
 604                 goto err_disable_clk_rx;
 605         }
 606
 607         if (clk_valid(&eqos->clk_ck)) {
 608                 ret = clk_enable(&eqos->clk_ck);
 609                 if (ret < 0) {
 610                         pr_err("clk_enable(clk_ck) failed: %d", ret);
 611                         goto err_disable_clk_tx;
 612                 }
 613         }
 614
 615         debug("%s: OK\n", __func__);
 616         return 0;
 617
 618 err_disable_clk_tx:
 619         clk_disable(&eqos->clk_tx);
 620 err_disable_clk_rx:
 621         clk_disable(&eqos->clk_rx);
 622 err_disable_clk_master_bus:
 623         clk_disable(&eqos->clk_master_bus);
 624 err:
 625         debug("%s: FAILED: %d\n", __func__, ret);
 626         return ret;
 627 }
 628
 629 static void eqos_stop_clks_tegra186(struct udevice *dev)
 630 {
 631         struct eqos_priv *eqos = dev_get_priv(dev);
 632
 633         debug("%s(dev=%p):\n", __func__, dev);
 634
 635         clk_disable(&eqos->clk_tx);
 636         clk_disable(&eqos->clk_ptp_ref);
 637         clk_disable(&eqos->clk_rx);
 638         clk_disable(&eqos->clk_master_bus);
 639         clk_disable(&eqos->clk_slave_bus);
 640
 641         debug("%s: OK\n", __func__);
 642 }
 643
 644 static void eqos_stop_clks_stm32(struct udevice *dev)
 645 {
 646         struct eqos_priv *eqos = dev_get_priv(dev);
 647
 648         debug("%s(dev=%p):\n", __func__, dev);
 649
 650         clk_disable(&eqos->clk_tx);
 651         clk_disable(&eqos->clk_rx);
 652         clk_disable(&eqos->clk_master_bus);
 653         if (clk_valid(&eqos->clk_ck))
 654                 clk_disable(&eqos->clk_ck);
 655
 656         debug("%s: OK\n", __func__);
 657 }
 658
 659 static int eqos_start_resets_tegra186(struct udevice *dev)
 660 {
 661         struct eqos_priv *eqos = dev_get_priv(dev);
 662         int ret;
 663
 664         debug("%s(dev=%p):\n", __func__, dev);
 665
 666         ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 1);
 667         if (ret < 0) {
 668                 pr_err("dm_gpio_set_value(phy_reset, assert) failed: %d", ret);
 669                 return ret;
 670         }
 671
 672         udelay(2);
 673
 674         ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 0);
 675         if (ret < 0) {
 676                 pr_err("dm_gpio_set_value(phy_reset, deassert) failed: %d", ret);
 677                 return ret;
 678         }
 679
 680         ret = reset_assert(&eqos->reset_ctl);
 681         if (ret < 0) {
 682                 pr_err("reset_assert() failed: %d", ret);
 683                 return ret;
 684         }
 685
 686         udelay(2);
 687
 688         ret = reset_deassert(&eqos->reset_ctl);
 689         if (ret < 0) {
 690                 pr_err("reset_deassert() failed: %d", ret);
 691                 return ret;
 692         }
 693
 694         debug("%s: OK\n", __func__);
 695         return 0;
 696 }
 697
 698 static int eqos_start_resets_stm32(struct udevice *dev)
 699 {
 700         struct eqos_priv *eqos = dev_get_priv(dev);
 701         int ret;
 702
 703         debug("%s(dev=%p):\n", __func__, dev);
 704         if (dm_gpio_is_valid(&eqos->phy_reset_gpio)) {
 705                 ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 1);
 706                 if (ret < 0) {
 707                         pr_err("dm_gpio_set_value(phy_reset, assert) failed: %d",
 708                                ret);
 709                         return ret;
 710                 }
 711
 712                 udelay(2);
 713
 714                 ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 0);
 715                 if (ret < 0) {
 716                         pr_err("dm_gpio_set_value(phy_reset, deassert) failed: %d",
 717                                ret);
 718                         return ret;
 719                 }
 720         }
 721         debug("%s: OK\n", __func__);
 722
 723         return 0;
 724 }
 725
 726 static int eqos_stop_resets_tegra186(struct udevice *dev)
 727 {
 728         struct eqos_priv *eqos = dev_get_priv(dev);
 729
 730         reset_assert(&eqos->reset_ctl);
 731         dm_gpio_set_value(&eqos->phy_reset_gpio, 1);
 732
 733         return 0;
 734 }
 735
 736 static int eqos_stop_resets_stm32(struct udevice *dev)
 737 {
 738         struct eqos_priv *eqos = dev_get_priv(dev);
 739         int ret;
 740
 741         if (dm_gpio_is_valid(&eqos->phy_reset_gpio)) {
 742                 ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 1);
 743                 if (ret < 0) {
 744                         pr_err("dm_gpio_set_value(phy_reset, assert) failed: %d",
 745                                ret);
 746                         return ret;
 747                 }
 748         }
 749
 750         return 0;
 751 }
 752
 753 static int eqos_calibrate_pads_tegra186(struct udevice *dev)
 754 {
 755         struct eqos_priv *eqos = dev_get_priv(dev);
 756         int ret;
 757
 758         debug("%s(dev=%p):\n", __func__, dev);
 759
 760         setbits_le32(&eqos->tegra186_regs->sdmemcomppadctrl,
 761                      EQOS_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD);
 762
 763         udelay(1);
 764
 765         setbits_le32(&eqos->tegra186_regs->auto_cal_config,
 766                      EQOS_AUTO_CAL_CONFIG_START | EQOS_AUTO_CAL_CONFIG_ENABLE);
 767
 768         ret = wait_for_bit_le32(&eqos->tegra186_regs->auto_cal_status,
 769                                 EQOS_AUTO_CAL_STATUS_ACTIVE, true, 10, false);
 770         if (ret) {
 771                 pr_err("calibrate didn't start");
 772                 goto failed;
 773         }
 774
 775         ret = wait_for_bit_le32(&eqos->tegra186_regs->auto_cal_status,
 776                                 EQOS_AUTO_CAL_STATUS_ACTIVE, false, 10, false);
 777         if (ret) {
 778                 pr_err("calibrate didn't finish");
 779                 goto failed;
 780         }
 781
 782         ret = 0;
 783
 784 failed:
 785         clrbits_le32(&eqos->tegra186_regs->sdmemcomppadctrl,
 786                      EQOS_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD);
 787
 788         debug("%s: returns %d\n", __func__, ret);
 789
 790         return ret;
 791 }
 792
 793 static int eqos_disable_calibration_tegra186(struct udevice *dev)
 794 {
 795         struct eqos_priv *eqos = dev_get_priv(dev);
 796
 797         debug("%s(dev=%p):\n", __func__, dev);
 798
 799         clrbits_le32(&eqos->tegra186_regs->auto_cal_config,
 800                      EQOS_AUTO_CAL_CONFIG_ENABLE);
 801
 802         return 0;
 803 }
 804
 805 static ulong eqos_get_tick_clk_rate_tegra186(struct udevice *dev)
 806 {
 807         struct eqos_priv *eqos = dev_get_priv(dev);
 808
 809         return clk_get_rate(&eqos->clk_slave_bus);
 810 }
 811
 812 static ulong eqos_get_tick_clk_rate_stm32(struct udevice *dev)
 813 {
 814         struct eqos_priv *eqos = dev_get_priv(dev);
 815
 816         return clk_get_rate(&eqos->clk_master_bus);
 817 }
 818
 819 static int eqos_calibrate_pads_stm32(struct udevice *dev)
 820 {
 821         return 0;
 822 }
 823
 824 static int eqos_disable_calibration_stm32(struct udevice *dev)
 825 {
 826         return 0;
 827 }
 828
 829 static int eqos_set_full_duplex(struct udevice *dev)
 830 {
 831         struct eqos_priv *eqos = dev_get_priv(dev);
 832
 833         debug("%s(dev=%p):\n", __func__, dev);
 834
 835         setbits_le32(&eqos->mac_regs->configuration, EQOS_MAC_CONFIGURATION_DM);
 836
 837         return 0;
 838 }
 839
 840 static int eqos_set_half_duplex(struct udevice *dev)
 841 {
 842         struct eqos_priv *eqos = dev_get_priv(dev);
 843
 844         debug("%s(dev=%p):\n", __func__, dev);
 845
 846         clrbits_le32(&eqos->mac_regs->configuration, EQOS_MAC_CONFIGURATION_DM);
 847
 848         /* WAR: Flush TX queue when switching to half-duplex */
 849         setbits_le32(&eqos->mtl_regs->txq0_operation_mode,
 850                      EQOS_MTL_TXQ0_OPERATION_MODE_FTQ);
 851
 852         return 0;
 853 }
 854
 855 static int eqos_set_gmii_speed(struct udevice *dev)
 856 {
 857         struct eqos_priv *eqos = dev_get_priv(dev);
 858
 859         debug("%s(dev=%p):\n", __func__, dev);
 860
 861         clrbits_le32(&eqos->mac_regs->configuration,
 862                      EQOS_MAC_CONFIGURATION_PS | EQOS_MAC_CONFIGURATION_FES);
 863
 864         return 0;
 865 }
 866
 867 static int eqos_set_mii_speed_100(struct udevice *dev)
 868 {
 869         struct eqos_priv *eqos = dev_get_priv(dev);
 870
 871         debug("%s(dev=%p):\n", __func__, dev);
 872
 873         setbits_le32(&eqos->mac_regs->configuration,
 874                      EQOS_MAC_CONFIGURATION_PS | EQOS_MAC_CONFIGURATION_FES);
 875
 876         return 0;
 877 }
 878
 879 static int eqos_set_mii_speed_10(struct udevice *dev)
 880 {
 881         struct eqos_priv *eqos = dev_get_priv(dev);
 882
 883         debug("%s(dev=%p):\n", __func__, dev);
 884
 885         clrsetbits_le32(&eqos->mac_regs->configuration,
 886                         EQOS_MAC_CONFIGURATION_FES, EQOS_MAC_CONFIGURATION_PS);
 887
 888         return 0;
 889 }
 890
 891 static int eqos_set_tx_clk_speed_tegra186(struct udevice *dev)
 892 {
 893         struct eqos_priv *eqos = dev_get_priv(dev);
 894         ulong rate;
 895         int ret;
 896
 897         debug("%s(dev=%p):\n", __func__, dev);
 898
 899         switch (eqos->phy->speed) {
 900         case SPEED_1000:
 901                 rate = 125 * 1000 * 1000;
 902                 break;
 903         case SPEED_100:
 904                 rate = 25 * 1000 * 1000;
 905                 break;
 906         case SPEED_10:
 907                 rate = 2.5 * 1000 * 1000;
 908                 break;
 909         default:
 910                 pr_err("invalid speed %d", eqos->phy->speed);
 911                 return -EINVAL;
 912         }
 913
 914         ret = clk_set_rate(&eqos->clk_tx, rate);
 915         if (ret < 0) {
 916                 pr_err("clk_set_rate(tx_clk, %lu) failed: %d", rate, ret);
 917                 return ret;
 918         }
 919
 920         return 0;
 921 }
 922
 923 static int eqos_set_tx_clk_speed_stm32(struct udevice *dev)
 924 {
 925         return 0;
 926 }
 927
 928 static int eqos_adjust_link(struct udevice *dev)
 929 {
 930         struct eqos_priv *eqos = dev_get_priv(dev);
 931         int ret;
 932         bool en_calibration;
 933
 934         debug("%s(dev=%p):\n", __func__, dev);
 935
 936         if (eqos->phy->duplex)
 937                 ret = eqos_set_full_duplex(dev);
 938         else
 939                 ret = eqos_set_half_duplex(dev);
 940         if (ret < 0) {
 941                 pr_err("eqos_set_*_duplex() failed: %d", ret);
 942                 return ret;
 943         }
 944
 945         switch (eqos->phy->speed) {
 946         case SPEED_1000:
 947                 en_calibration = true;
 948                 ret = eqos_set_gmii_speed(dev);
 949                 break;
 950         case SPEED_100:
 951                 en_calibration = true;
 952                 ret = eqos_set_mii_speed_100(dev);
 953                 break;
 954         case SPEED_10:
 955                 en_calibration = false;
 956                 ret = eqos_set_mii_speed_10(dev);
 957                 break;
 958         default:
 959                 pr_err("invalid speed %d", eqos->phy->speed);
 960                 return -EINVAL;
 961         }
 962         if (ret < 0) {
 963                 pr_err("eqos_set_*mii_speed*() failed: %d", ret);
 964                 return ret;
 965         }
 966
 967         if (en_calibration) {
 968                 ret = eqos->config->ops->eqos_calibrate_pads(dev);
 969                 if (ret < 0) {
 970                         pr_err("eqos_calibrate_pads() failed: %d",
 971                                ret);
 972                         return ret;
 973                 }
 974         } else {
 975                 ret = eqos->config->ops->eqos_disable_calibration(dev);
 976                 if (ret < 0) {
 977                         pr_err("eqos_disable_calibration() failed: %d",
 978                                ret);
 979                         return ret;
 980                 }
 981         }
 982         ret = eqos->config->ops->eqos_set_tx_clk_speed(dev);
 983         if (ret < 0) {
 984                 pr_err("eqos_set_tx_clk_speed() failed: %d", ret);
 985                 return ret;
 986         }
 987
 988         return 0;
 989 }
 990
 991 static int eqos_write_hwaddr(struct udevice *dev)
 992 {
 993         struct eth_pdata *plat = dev_get_platdata(dev);
 994         struct eqos_priv *eqos = dev_get_priv(dev);
 995         uint32_t val;
 996
 997         /*
 998          * This function may be called before start() or after stop(). At that
 999          * time, on at least some configurations of the EQoS HW, all clocks to
1000          * the EQoS HW block will be stopped, and a reset signal applied. If
1001          * any register access is attempted in this state, bus timeouts or CPU
1002          * hangs may occur. This check prevents that.
1003          *
1004          * A simple solution to this problem would be to not implement
1005          * write_hwaddr(), since start() always writes the MAC address into HW
1006          * anyway. However, it is desirable to implement write_hwaddr() to
1007          * support the case of SW that runs subsequent to U-Boot which expects
1008          * the MAC address to already be programmed into the EQoS registers,
1009          * which must happen irrespective of whether the U-Boot user (or
1010          * scripts) actually made use of the EQoS device, and hence
1011          * irrespective of whether start() was ever called.
1012          *
1013          * Note that this requirement by subsequent SW is not valid for
1014          * Tegra186, and is likely not valid for any non-PCI instantiation of
1015          * the EQoS HW block. This function is implemented solely as
1016          * future-proofing with the expectation the driver will eventually be
1017          * ported to some system where the expectation above is true.
1018          */
1019         if (!eqos->config->reg_access_always_ok && !eqos->reg_access_ok)
1020                 return 0;
1021
1022         /* Update the MAC address */
1023         val = (plat->enetaddr[5] << 8) |
1024                 (plat->enetaddr[4]);
1025         writel(val, &eqos->mac_regs->address0_high);
1026         val = (plat->enetaddr[3] << 24) |
1027                 (plat->enetaddr[2] << 16) |
1028                 (plat->enetaddr[1] << 8) |
1029                 (plat->enetaddr[0]);
1030         writel(val, &eqos->mac_regs->address0_low);
1031
1032         return 0;
1033 }
1034
1035 static int eqos_start(struct udevice *dev)
1036 {
1037         struct eqos_priv *eqos = dev_get_priv(dev);
1038         int ret, i;
1039         ulong rate;
1040         u32 val, tx_fifo_sz, rx_fifo_sz, tqs, rqs, pbl;
1041         ulong last_rx_desc;
1042
1043         debug("%s(dev=%p):\n", __func__, dev);
1044
1045         eqos->tx_desc_idx = 0;
1046         eqos->rx_desc_idx = 0;
1047
1048         ret = eqos->config->ops->eqos_start_clks(dev);
1049         if (ret < 0) {
1050                 pr_err("eqos_start_clks() failed: %d", ret);
1051                 goto err;
1052         }
1053
1054         ret = eqos->config->ops->eqos_start_resets(dev);
1055         if (ret < 0) {
1056                 pr_err("eqos_start_resets() failed: %d", ret);
1057                 goto err_stop_clks;
1058         }
1059
1060         udelay(10);
1061
1062         eqos->reg_access_ok = true;
1063
1064         ret = wait_for_bit_le32(&eqos->dma_regs->mode,
1065                                 EQOS_DMA_MODE_SWR, false,
1066                                 eqos->config->swr_wait, false);
1067         if (ret) {
1068                 pr_err("EQOS_DMA_MODE_SWR stuck");
1069                 goto err_stop_resets;
1070         }
1071
1072         ret = eqos->config->ops->eqos_calibrate_pads(dev);
1073         if (ret < 0) {
1074                 pr_err("eqos_calibrate_pads() failed: %d", ret);
1075                 goto err_stop_resets;
1076         }
1077         rate = eqos->config->ops->eqos_get_tick_clk_rate(dev);
1078
1079         val = (rate / 1000000) - 1;
1080         writel(val, &eqos->mac_regs->us_tic_counter);
1081
1082         /*
1083          * if PHY was already connected and configured,
1084          * don't need to reconnect/reconfigure again
1085          */
1086         if (!eqos->phy) {
1087                 int addr = -1;
1088 #ifdef CONFIG_DM_ETH_PHY
1089                 addr = eth_phy_get_addr(dev);
1090 #endif
1091 #ifdef DWC_NET_PHYADDR
1092                 addr = DWC_NET_PHYADDR;
1093 #endif
1094                 eqos->phy = phy_connect(eqos->mii, addr, dev,
1095                                         eqos->config->interface(dev));
1096                 if (!eqos->phy) {
1097                         pr_err("phy_connect() failed");
1098                         goto err_stop_resets;
1099                 }
1100
1101                 if (eqos->max_speed) {
1102                         ret = phy_set_supported(eqos->phy, eqos->max_speed);
1103                         if (ret) {
1104                                 pr_err("phy_set_supported() failed: %d", ret);
1105                                 goto err_shutdown_phy;
1106                         }
1107                 }
1108
1109                 ret = phy_config(eqos->phy);
1110                 if (ret < 0) {
1111                         pr_err("phy_config() failed: %d", ret);
1112                         goto err_shutdown_phy;
1113                 }
1114         }
1115
1116         ret = phy_startup(eqos->phy);
1117         if (ret < 0) {
1118                 pr_err("phy_startup() failed: %d", ret);
1119                 goto err_shutdown_phy;
1120         }
1121
1122         if (!eqos->phy->link) {
1123                 pr_err("No link");
1124                 goto err_shutdown_phy;
1125         }
1126
1127         ret = eqos_adjust_link(dev);
1128         if (ret < 0) {
1129                 pr_err("eqos_adjust_link() failed: %d", ret);
1130                 goto err_shutdown_phy;
1131         }
1132
1133         /* Configure MTL */
1134
1135         /* Enable Store and Forward mode for TX */
1136         /* Program Tx operating mode */
1137         setbits_le32(&eqos->mtl_regs->txq0_operation_mode,
1138                      EQOS_MTL_TXQ0_OPERATION_MODE_TSF |
1139                      (EQOS_MTL_TXQ0_OPERATION_MODE_TXQEN_ENABLED <<
1140                       EQOS_MTL_TXQ0_OPERATION_MODE_TXQEN_SHIFT));
1141
1142         /* Transmit Queue weight */
1143         writel(0x10, &eqos->mtl_regs->txq0_quantum_weight);
1144
1145         /* Enable Store and Forward mode for RX, since no jumbo frame */
1146         setbits_le32(&eqos->mtl_regs->rxq0_operation_mode,
1147                      EQOS_MTL_RXQ0_OPERATION_MODE_RSF);
1148
1149         /* Transmit/Receive queue fifo size; use all RAM for 1 queue */
1150         val = readl(&eqos->mac_regs->hw_feature1);
1151         tx_fifo_sz = (val >> EQOS_MAC_HW_FEATURE1_TXFIFOSIZE_SHIFT) &
1152                 EQOS_MAC_HW_FEATURE1_TXFIFOSIZE_MASK;
1153         rx_fifo_sz = (val >> EQOS_MAC_HW_FEATURE1_RXFIFOSIZE_SHIFT) &
1154                 EQOS_MAC_HW_FEATURE1_RXFIFOSIZE_MASK;
1155
1156         /*
1157          * r/tx_fifo_sz is encoded as log2(n / 128). Undo that by shifting.
1158          * r/tqs is encoded as (n / 256) - 1.
1159          */
1160         tqs = (128 << tx_fifo_sz) / 256 - 1;
1161         rqs = (128 << rx_fifo_sz) / 256 - 1;
1162
1163         clrsetbits_le32(&eqos->mtl_regs->txq0_operation_mode,
1164                         EQOS_MTL_TXQ0_OPERATION_MODE_TQS_MASK <<
1165                         EQOS_MTL_TXQ0_OPERATION_MODE_TQS_SHIFT,
1166                         tqs << EQOS_MTL_TXQ0_OPERATION_MODE_TQS_SHIFT);
1167         clrsetbits_le32(&eqos->mtl_regs->rxq0_operation_mode,
1168                         EQOS_MTL_RXQ0_OPERATION_MODE_RQS_MASK <<
1169                         EQOS_MTL_RXQ0_OPERATION_MODE_RQS_SHIFT,
1170                         rqs << EQOS_MTL_RXQ0_OPERATION_MODE_RQS_SHIFT);
1171
1172         /* Flow control used only if each channel gets 4KB or more FIFO */
1173         if (rqs >= ((4096 / 256) - 1)) {
1174                 u32 rfd, rfa;
1175
1176                 setbits_le32(&eqos->mtl_regs->rxq0_operation_mode,
1177                              EQOS_MTL_RXQ0_OPERATION_MODE_EHFC);
1178
1179                 /*
1180                  * Set Threshold for Activating Flow Contol space for min 2
1181                  * frames ie, (1500 * 1) = 1500 bytes.
1182                  *
1183                  * Set Threshold for Deactivating Flow Contol for space of
1184                  * min 1 frame (frame size 1500bytes) in receive fifo
1185                  */
1186                 if (rqs == ((4096 / 256) - 1)) {
1187                         /*
1188                          * This violates the above formula because of FIFO size
1189                          * limit therefore overflow may occur inspite of this.
1190                          */
1191                         rfd = 0x3;      /* Full-3K */
1192                         rfa = 0x1;      /* Full-1.5K */
1193                 } else if (rqs == ((8192 / 256) - 1)) {
1194                         rfd = 0x6;      /* Full-4K */
1195                         rfa = 0xa;      /* Full-6K */
1196                 } else if (rqs == ((16384 / 256) - 1)) {
1197                         rfd = 0x6;      /* Full-4K */
1198                         rfa = 0x12;     /* Full-10K */
1199                 } else {
1200                         rfd = 0x6;      /* Full-4K */
1201                         rfa = 0x1E;     /* Full-16K */
1202                 }
1203
1204                 clrsetbits_le32(&eqos->mtl_regs->rxq0_operation_mode,
1205                                 (EQOS_MTL_RXQ0_OPERATION_MODE_RFD_MASK <<
1206                                  EQOS_MTL_RXQ0_OPERATION_MODE_RFD_SHIFT) |
1207                                 (EQOS_MTL_RXQ0_OPERATION_MODE_RFA_MASK <<
1208                                  EQOS_MTL_RXQ0_OPERATION_MODE_RFA_SHIFT),
1209                                 (rfd <<
1210                                  EQOS_MTL_RXQ0_OPERATION_MODE_RFD_SHIFT) |
1211                                 (rfa <<
1212                                  EQOS_MTL_RXQ0_OPERATION_MODE_RFA_SHIFT));
1213         }
1214
1215         /* Configure MAC */
1216
1217         clrsetbits_le32(&eqos->mac_regs->rxq_ctrl0,
1218                         EQOS_MAC_RXQ_CTRL0_RXQ0EN_MASK <<
1219                         EQOS_MAC_RXQ_CTRL0_RXQ0EN_SHIFT,
1220                         eqos->config->config_mac <<
1221                         EQOS_MAC_RXQ_CTRL0_RXQ0EN_SHIFT);
1222
1223         /* Set TX flow control parameters */
1224         /* Set Pause Time */
1225         setbits_le32(&eqos->mac_regs->q0_tx_flow_ctrl,
1226                      0xffff << EQOS_MAC_Q0_TX_FLOW_CTRL_PT_SHIFT);
1227         /* Assign priority for TX flow control */
1228         clrbits_le32(&eqos->mac_regs->txq_prty_map0,
1229                      EQOS_MAC_TXQ_PRTY_MAP0_PSTQ0_MASK <<
1230                      EQOS_MAC_TXQ_PRTY_MAP0_PSTQ0_SHIFT);
1231         /* Assign priority for RX flow control */
1232         clrbits_le32(&eqos->mac_regs->rxq_ctrl2,
1233                      EQOS_MAC_RXQ_CTRL2_PSRQ0_MASK <<
1234                      EQOS_MAC_RXQ_CTRL2_PSRQ0_SHIFT);
1235         /* Enable flow control */
1236         setbits_le32(&eqos->mac_regs->q0_tx_flow_ctrl,
1237                      EQOS_MAC_Q0_TX_FLOW_CTRL_TFE);
1238         setbits_le32(&eqos->mac_regs->rx_flow_ctrl,
1239                      EQOS_MAC_RX_FLOW_CTRL_RFE);
1240
1241         clrsetbits_le32(&eqos->mac_regs->configuration,
1242                         EQOS_MAC_CONFIGURATION_GPSLCE |
1243                         EQOS_MAC_CONFIGURATION_WD |
1244                         EQOS_MAC_CONFIGURATION_JD |
1245                         EQOS_MAC_CONFIGURATION_JE,
1246                         EQOS_MAC_CONFIGURATION_CST |
1247                         EQOS_MAC_CONFIGURATION_ACS);
1248
1249         eqos_write_hwaddr(dev);
1250
1251         /* Configure DMA */
1252
1253         /* Enable OSP mode */
1254         setbits_le32(&eqos->dma_regs->ch0_tx_control,
1255                      EQOS_DMA_CH0_TX_CONTROL_OSP);
1256
1257         /* RX buffer size. Must be a multiple of bus width */
1258         clrsetbits_le32(&eqos->dma_regs->ch0_rx_control,
1259                         EQOS_DMA_CH0_RX_CONTROL_RBSZ_MASK <<
1260                         EQOS_DMA_CH0_RX_CONTROL_RBSZ_SHIFT,
1261                         EQOS_MAX_PACKET_SIZE <<
1262                         EQOS_DMA_CH0_RX_CONTROL_RBSZ_SHIFT);
1263
1264         setbits_le32(&eqos->dma_regs->ch0_control,
1265                      EQOS_DMA_CH0_CONTROL_PBLX8);
1266
1267         /*
1268          * Burst length must be < 1/2 FIFO size.
1269          * FIFO size in tqs is encoded as (n / 256) - 1.
1270          * Each burst is n * 8 (PBLX8) * 16 (AXI width) == 128 bytes.
1271          * Half of n * 256 is n * 128, so pbl == tqs, modulo the -1.
1272          */
1273         pbl = tqs + 1;
1274         if (pbl > 32)
1275                 pbl = 32;
1276         clrsetbits_le32(&eqos->dma_regs->ch0_tx_control,
1277                         EQOS_DMA_CH0_TX_CONTROL_TXPBL_MASK <<
1278                         EQOS_DMA_CH0_TX_CONTROL_TXPBL_SHIFT,
1279                         pbl << EQOS_DMA_CH0_TX_CONTROL_TXPBL_SHIFT);
1280
1281         clrsetbits_le32(&eqos->dma_regs->ch0_rx_control,
1282                         EQOS_DMA_CH0_RX_CONTROL_RXPBL_MASK <<
1283                         EQOS_DMA_CH0_RX_CONTROL_RXPBL_SHIFT,
1284                         8 << EQOS_DMA_CH0_RX_CONTROL_RXPBL_SHIFT);
1285
1286         /* DMA performance configuration */
1287         val = (2 << EQOS_DMA_SYSBUS_MODE_RD_OSR_LMT_SHIFT) |
1288                 EQOS_DMA_SYSBUS_MODE_EAME | EQOS_DMA_SYSBUS_MODE_BLEN16 |
1289                 EQOS_DMA_SYSBUS_MODE_BLEN8 | EQOS_DMA_SYSBUS_MODE_BLEN4;
1290         writel(val, &eqos->dma_regs->sysbus_mode);
1291
1292         /* Set up descriptors */
1293
1294         memset(eqos->descs, 0, EQOS_DESCRIPTORS_SIZE);
1295         for (i = 0; i < EQOS_DESCRIPTORS_RX; i++) {
1296                 struct eqos_desc *rx_desc = &(eqos->rx_descs[i]);
1297                 rx_desc->des0 = (u32)(ulong)(eqos->rx_dma_buf +
1298                                              (i * EQOS_MAX_PACKET_SIZE));
1299                 rx_desc->des3 = EQOS_DESC3_OWN | EQOS_DESC3_BUF1V;
1300                 eqos->config->ops->eqos_flush_desc(rx_desc);
1301         }
1302
1303         writel(0, &eqos->dma_regs->ch0_txdesc_list_haddress);
1304         writel((ulong)eqos->tx_descs, &eqos->dma_regs->ch0_txdesc_list_address);
1305         writel(EQOS_DESCRIPTORS_TX - 1,
1306                &eqos->dma_regs->ch0_txdesc_ring_length);
1307
1308         writel(0, &eqos->dma_regs->ch0_rxdesc_list_haddress);
1309         writel((ulong)eqos->rx_descs, &eqos->dma_regs->ch0_rxdesc_list_address);
1310         writel(EQOS_DESCRIPTORS_RX - 1,
1311                &eqos->dma_regs->ch0_rxdesc_ring_length);
1312
1313         /* Enable everything */
1314
1315         setbits_le32(&eqos->mac_regs->configuration,
1316                      EQOS_MAC_CONFIGURATION_TE | EQOS_MAC_CONFIGURATION_RE);
1317
1318         setbits_le32(&eqos->dma_regs->ch0_tx_control,
1319                      EQOS_DMA_CH0_TX_CONTROL_ST);
1320         setbits_le32(&eqos->dma_regs->ch0_rx_control,
1321                      EQOS_DMA_CH0_RX_CONTROL_SR);
1322
1323         /* TX tail pointer not written until we need to TX a packet */
1324         /*
1325          * Point RX tail pointer at last descriptor. Ideally, we'd point at the
1326          * first descriptor, implying all descriptors were available. However,
1327          * that's not distinguishable from none of the descriptors being
1328          * available.
1329          */
1330         last_rx_desc = (ulong)&(eqos->rx_descs[(EQOS_DESCRIPTORS_RX - 1)]);
1331         writel(last_rx_desc, &eqos->dma_regs->ch0_rxdesc_tail_pointer);
1332
1333         eqos->started = true;
1334
1335         debug("%s: OK\n", __func__);
1336         return 0;
1337
1338 err_shutdown_phy:
1339         phy_shutdown(eqos->phy);
1340 err_stop_resets:
1341         eqos->config->ops->eqos_stop_resets(dev);
1342 err_stop_clks:
1343         eqos->config->ops->eqos_stop_clks(dev);
1344 err:
1345         pr_err("FAILED: %d", ret);
1346         return ret;
1347 }
1348
1349 static void eqos_stop(struct udevice *dev)
1350 {
1351         struct eqos_priv *eqos = dev_get_priv(dev);
1352         int i;
1353
1354         debug("%s(dev=%p):\n", __func__, dev);
1355
1356         if (!eqos->started)
1357                 return;
1358         eqos->started = false;
1359         eqos->reg_access_ok = false;
1360
1361         /* Disable TX DMA */
1362         clrbits_le32(&eqos->dma_regs->ch0_tx_control,
1363                      EQOS_DMA_CH0_TX_CONTROL_ST);
1364
1365         /* Wait for TX all packets to drain out of MTL */
1366         for (i = 0; i < 1000000; i++) {
1367                 u32 val = readl(&eqos->mtl_regs->txq0_debug);
1368                 u32 trcsts = (val >> EQOS_MTL_TXQ0_DEBUG_TRCSTS_SHIFT) &
1369                         EQOS_MTL_TXQ0_DEBUG_TRCSTS_MASK;
1370                 u32 txqsts = val & EQOS_MTL_TXQ0_DEBUG_TXQSTS;
1371                 if ((trcsts != 1) && (!txqsts))
1372                         break;
1373         }
1374
1375         /* Turn off MAC TX and RX */
1376         clrbits_le32(&eqos->mac_regs->configuration,
1377                      EQOS_MAC_CONFIGURATION_TE | EQOS_MAC_CONFIGURATION_RE);
1378
1379         /* Wait for all RX packets to drain out of MTL */
1380         for (i = 0; i < 1000000; i++) {
1381                 u32 val = readl(&eqos->mtl_regs->rxq0_debug);
1382                 u32 prxq = (val >> EQOS_MTL_RXQ0_DEBUG_PRXQ_SHIFT) &
1383                         EQOS_MTL_RXQ0_DEBUG_PRXQ_MASK;
1384                 u32 rxqsts = (val >> EQOS_MTL_RXQ0_DEBUG_RXQSTS_SHIFT) &
1385                         EQOS_MTL_RXQ0_DEBUG_RXQSTS_MASK;
1386                 if ((!prxq) && (!rxqsts))
1387                         break;
1388         }
1389
1390         /* Turn off RX DMA */
1391         clrbits_le32(&eqos->dma_regs->ch0_rx_control,
1392                      EQOS_DMA_CH0_RX_CONTROL_SR);
1393
1394         if (eqos->phy) {
1395                 phy_shutdown(eqos->phy);
1396         }
1397         eqos->config->ops->eqos_stop_resets(dev);
1398         eqos->config->ops->eqos_stop_clks(dev);
1399
1400         debug("%s: OK\n", __func__);
1401 }
1402
1403 static int eqos_send(struct udevice *dev, void *packet, int length)
1404 {
1405         struct eqos_priv *eqos = dev_get_priv(dev);
1406         struct eqos_desc *tx_desc;
1407         int i;
1408
1409         debug("%s(dev=%p, packet=%p, length=%d):\n", __func__, dev, packet,
1410               length);
1411
1412         memcpy(eqos->tx_dma_buf, packet, length);
1413         eqos->config->ops->eqos_flush_buffer(eqos->tx_dma_buf, length);
1414
1415         tx_desc = &(eqos->tx_descs[eqos->tx_desc_idx]);
1416         eqos->tx_desc_idx++;
1417         eqos->tx_desc_idx %= EQOS_DESCRIPTORS_TX;
1418
1419         tx_desc->des0 = (ulong)eqos->tx_dma_buf;
1420         tx_desc->des1 = 0;
1421         tx_desc->des2 = length;
1422         /*
1423          * Make sure that if HW sees the _OWN write below, it will see all the
1424          * writes to the rest of the descriptor too.
1425          */
1426         mb();
1427         tx_desc->des3 = EQOS_DESC3_OWN | EQOS_DESC3_FD | EQOS_DESC3_LD | length;
1428         eqos->config->ops->eqos_flush_desc(tx_desc);
1429
1430         writel((ulong)(&(eqos->tx_descs[eqos->tx_desc_idx])),
1431                 &eqos->dma_regs->ch0_txdesc_tail_pointer);
1432
1433         for (i = 0; i < 1000000; i++) {
1434                 eqos->config->ops->eqos_inval_desc(tx_desc);
1435                 if (!(readl(&tx_desc->des3) & EQOS_DESC3_OWN))
1436                         return 0;
1437                 udelay(1);
1438         }
1439
1440         debug("%s: TX timeout\n", __func__);
1441
1442         return -ETIMEDOUT;
1443 }
1444
1445 static int eqos_recv(struct udevice *dev, int flags, uchar **packetp)
1446 {
1447         struct eqos_priv *eqos = dev_get_priv(dev);
1448         struct eqos_desc *rx_desc;
1449         int length;
1450
1451         debug("%s(dev=%p, flags=%x):\n", __func__, dev, flags);
1452
1453         rx_desc = &(eqos->rx_descs[eqos->rx_desc_idx]);
1454         eqos->config->ops->eqos_inval_desc(rx_desc);
1455         if (rx_desc->des3 & EQOS_DESC3_OWN) {
1456                 debug("%s: RX packet not available\n", __func__);
1457                 return -EAGAIN;
1458         }
1459
1460         *packetp = eqos->rx_dma_buf +
1461                 (eqos->rx_desc_idx * EQOS_MAX_PACKET_SIZE);
1462         length = rx_desc->des3 & 0x7fff;
1463         debug("%s: *packetp=%p, length=%d\n", __func__, *packetp, length);
1464
1465         eqos->config->ops->eqos_inval_buffer(*packetp, length);
1466
1467         return length;
1468 }
1469
1470 static int eqos_free_pkt(struct udevice *dev, uchar *packet, int length)
1471 {
1472         struct eqos_priv *eqos = dev_get_priv(dev);
1473         uchar *packet_expected;
1474         struct eqos_desc *rx_desc;
1475
1476         debug("%s(packet=%p, length=%d)\n", __func__, packet, length);
1477
1478         packet_expected = eqos->rx_dma_buf +
1479                 (eqos->rx_desc_idx * EQOS_MAX_PACKET_SIZE);
1480         if (packet != packet_expected) {
1481                 debug("%s: Unexpected packet (expected %p)\n", __func__,
1482                       packet_expected);
1483                 return -EINVAL;
1484         }
1485
1486         rx_desc = &(eqos->rx_descs[eqos->rx_desc_idx]);
1487
1488         rx_desc->des0 = 0;
1489         mb();
1490         eqos->config->ops->eqos_flush_desc(rx_desc);
1491         eqos->config->ops->eqos_inval_buffer(packet, length);
1492         rx_desc->des0 = (u32)(ulong)packet;
1493         rx_desc->des1 = 0;
1494         rx_desc->des2 = 0;
1495         /*
1496          * Make sure that if HW sees the _OWN write below, it will see all the
1497          * writes to the rest of the descriptor too.
1498          */
1499         mb();
1500         rx_desc->des3 = EQOS_DESC3_OWN | EQOS_DESC3_BUF1V;
1501         eqos->config->ops->eqos_flush_desc(rx_desc);
1502
1503         writel((ulong)rx_desc, &eqos->dma_regs->ch0_rxdesc_tail_pointer);
1504
1505         eqos->rx_desc_idx++;
1506         eqos->rx_desc_idx %= EQOS_DESCRIPTORS_RX;
1507
1508         return 0;
1509 }
1510
1511 static int eqos_probe_resources_core(struct udevice *dev)
1512 {
1513         struct eqos_priv *eqos = dev_get_priv(dev);
1514         int ret;
1515
1516         debug("%s(dev=%p):\n", __func__, dev);
1517
1518         eqos->descs = eqos_alloc_descs(EQOS_DESCRIPTORS_TX +
1519                                        EQOS_DESCRIPTORS_RX);
1520         if (!eqos->descs) {
1521                 debug("%s: eqos_alloc_descs() failed\n", __func__);
1522                 ret = -ENOMEM;
1523                 goto err;
1524         }
1525         eqos->tx_descs = (struct eqos_desc *)eqos->descs;
1526         eqos->rx_descs = (eqos->tx_descs + EQOS_DESCRIPTORS_TX);
1527         debug("%s: tx_descs=%p, rx_descs=%p\n", __func__, eqos->tx_descs,
1528               eqos->rx_descs);
1529
1530         eqos->tx_dma_buf = memalign(EQOS_BUFFER_ALIGN, EQOS_MAX_PACKET_SIZE);
1531         if (!eqos->tx_dma_buf) {
1532                 debug("%s: memalign(tx_dma_buf) failed\n", __func__);
1533                 ret = -ENOMEM;
1534                 goto err_free_descs;
1535         }
1536         debug("%s: tx_dma_buf=%p\n", __func__, eqos->tx_dma_buf);
1537
1538         eqos->rx_dma_buf = memalign(EQOS_BUFFER_ALIGN, EQOS_RX_BUFFER_SIZE);
1539         if (!eqos->rx_dma_buf) {
1540                 debug("%s: memalign(rx_dma_buf) failed\n", __func__);
1541                 ret = -ENOMEM;
1542                 goto err_free_tx_dma_buf;
1543         }
1544         debug("%s: rx_dma_buf=%p\n", __func__, eqos->rx_dma_buf);
1545
1546         eqos->rx_pkt = malloc(EQOS_MAX_PACKET_SIZE);
1547         if (!eqos->rx_pkt) {
1548                 debug("%s: malloc(rx_pkt) failed\n", __func__);
1549                 ret = -ENOMEM;
1550                 goto err_free_rx_dma_buf;
1551         }
1552         debug("%s: rx_pkt=%p\n", __func__, eqos->rx_pkt);
1553
1554         eqos->config->ops->eqos_inval_buffer(eqos->rx_dma_buf,
1555                         EQOS_MAX_PACKET_SIZE * EQOS_DESCRIPTORS_RX);
1556
1557         debug("%s: OK\n", __func__);
1558         return 0;
1559
1560 err_free_rx_dma_buf:
1561         free(eqos->rx_dma_buf);
1562 err_free_tx_dma_buf:
1563         free(eqos->tx_dma_buf);
1564 err_free_descs:
1565         eqos_free_descs(eqos->descs);
1566 err:
1567
1568         debug("%s: returns %d\n", __func__, ret);
1569         return ret;
1570 }
1571
1572 static int eqos_remove_resources_core(struct udevice *dev)
1573 {
1574         struct eqos_priv *eqos = dev_get_priv(dev);
1575
1576         debug("%s(dev=%p):\n", __func__, dev);
1577
1578         free(eqos->rx_pkt);
1579         free(eqos->rx_dma_buf);
1580         free(eqos->tx_dma_buf);
1581         eqos_free_descs(eqos->descs);
1582
1583         debug("%s: OK\n", __func__);
1584         return 0;
1585 }
1586
1587 static int eqos_probe_resources_tegra186(struct udevice *dev)
1588 {
1589         struct eqos_priv *eqos = dev_get_priv(dev);
1590         int ret;
1591
1592         debug("%s(dev=%p):\n", __func__, dev);
1593
1594         ret = reset_get_by_name(dev, "eqos", &eqos->reset_ctl);
1595         if (ret) {
1596                 pr_err("reset_get_by_name(rst) failed: %d", ret);
1597                 return ret;
1598         }
1599
1600         ret = gpio_request_by_name(dev, "phy-reset-gpios", 0,
1601                                    &eqos->phy_reset_gpio,
1602                                    GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE);
1603         if (ret) {
1604                 pr_err("gpio_request_by_name(phy reset) failed: %d", ret);
1605                 goto err_free_reset_eqos;
1606         }
1607
1608         ret = clk_get_by_name(dev, "slave_bus", &eqos->clk_slave_bus);
1609         if (ret) {
1610                 pr_err("clk_get_by_name(slave_bus) failed: %d", ret);
1611                 goto err_free_gpio_phy_reset;
1612         }
1613
1614         ret = clk_get_by_name(dev, "master_bus", &eqos->clk_master_bus);
1615         if (ret) {
1616                 pr_err("clk_get_by_name(master_bus) failed: %d", ret);
1617                 goto err_free_clk_slave_bus;
1618         }
1619
1620         ret = clk_get_by_name(dev, "rx", &eqos->clk_rx);
1621         if (ret) {
1622                 pr_err("clk_get_by_name(rx) failed: %d", ret);
1623                 goto err_free_clk_master_bus;
1624         }
1625
1626         ret = clk_get_by_name(dev, "ptp_ref", &eqos->clk_ptp_ref);
1627         if (ret) {
1628                 pr_err("clk_get_by_name(ptp_ref) failed: %d", ret);
1629                 goto err_free_clk_rx;
1630                 return ret;
1631         }
1632
1633         ret = clk_get_by_name(dev, "tx", &eqos->clk_tx);
1634         if (ret) {
1635                 pr_err("clk_get_by_name(tx) failed: %d", ret);
1636                 goto err_free_clk_ptp_ref;
1637         }
1638
1639         debug("%s: OK\n", __func__);
1640         return 0;
1641
1642 err_free_clk_ptp_ref:
1643         clk_free(&eqos->clk_ptp_ref);
1644 err_free_clk_rx:
1645         clk_free(&eqos->clk_rx);
1646 err_free_clk_master_bus:
1647         clk_free(&eqos->clk_master_bus);
1648 err_free_clk_slave_bus:
1649         clk_free(&eqos->clk_slave_bus);
1650 err_free_gpio_phy_reset:
1651         dm_gpio_free(dev, &eqos->phy_reset_gpio);
1652 err_free_reset_eqos:
1653         reset_free(&eqos->reset_ctl);
1654
1655         debug("%s: returns %d\n", __func__, ret);
1656         return ret;
1657 }
1658
1659 /* board-specific Ethernet Interface initializations. */
1660 __weak int board_interface_eth_init(struct udevice *dev,
1661                                     phy_interface_t interface_type)
1662 {
1663         return 0;
1664 }
1665
1666 static int eqos_probe_resources_stm32(struct udevice *dev)
1667 {
1668         struct eqos_priv *eqos = dev_get_priv(dev);
1669         int ret;
1670         phy_interface_t interface;
1671         struct ofnode_phandle_args phandle_args;
1672
1673         debug("%s(dev=%p):\n", __func__, dev);
1674
1675         interface = eqos->config->interface(dev);
1676
1677         if (interface == PHY_INTERFACE_MODE_NONE) {
1678                 pr_err("Invalid PHY interface\n");
1679                 return -EINVAL;
1680         }
1681
1682         ret = board_interface_eth_init(dev, interface);
1683         if (ret)
1684                 return -EINVAL;
1685
1686         eqos->max_speed = dev_read_u32_default(dev, "max-speed", 0);
1687
1688         ret = clk_get_by_name(dev, "stmmaceth", &eqos->clk_master_bus);
1689         if (ret) {
1690                 pr_err("clk_get_by_name(master_bus) failed: %d", ret);
1691                 goto err_probe;
1692         }
1693
1694         ret = clk_get_by_name(dev, "mac-clk-rx", &eqos->clk_rx);
1695         if (ret) {
1696                 pr_err("clk_get_by_name(rx) failed: %d", ret);
1697                 goto err_free_clk_master_bus;
1698         }
1699
1700         ret = clk_get_by_name(dev, "mac-clk-tx", &eqos->clk_tx);
1701         if (ret) {
1702                 pr_err("clk_get_by_name(tx) failed: %d", ret);
1703                 goto err_free_clk_rx;
1704         }
1705
1706         /*  Get ETH_CLK clocks (optional) */
1707         ret = clk_get_by_name(dev, "eth-ck", &eqos->clk_ck);
1708         if (ret)
1709                 pr_warn("No phy clock provided %d", ret);
1710
1711         eqos->phyaddr = -1;
1712         ret = dev_read_phandle_with_args(dev, "phy-handle", NULL, 0, 0,
1713                                          &phandle_args);
1714         if (!ret) {
1715                 /* search "reset-gpios" in phy node */
1716                 ret = gpio_request_by_name_nodev(phandle_args.node,
1717                                                  "reset-gpios", 0,
1718                                                  &eqos->phy_reset_gpio,
1719                                                  GPIOD_IS_OUT |
1720                                                  GPIOD_IS_OUT_ACTIVE);
1721                 if (ret)
1722                         pr_warn("gpio_request_by_name(phy reset) not provided %d",
1723                                 ret);
1724
1725                 eqos->phyaddr = ofnode_read_u32_default(phandle_args.node,
1726                                                         "reg", -1);
1727         }
1728
1729         debug("%s: OK\n", __func__);
1730         return 0;
1731
1732 err_free_clk_rx:
1733         clk_free(&eqos->clk_rx);
1734 err_free_clk_master_bus:
1735         clk_free(&eqos->clk_master_bus);
1736 err_probe:
1737
1738         debug("%s: returns %d\n", __func__, ret);
1739         return ret;
1740 }
1741
1742 static phy_interface_t eqos_get_interface_stm32(struct udevice *dev)
1743 {
1744         const char *phy_mode;
1745         phy_interface_t interface = PHY_INTERFACE_MODE_NONE;
1746
1747         debug("%s(dev=%p):\n", __func__, dev);
1748
1749         phy_mode = fdt_getprop(gd->fdt_blob, dev_of_offset(dev), "phy-mode",
1750                                NULL);
1751         if (phy_mode)
1752                 interface = phy_get_interface_by_name(phy_mode);
1753
1754         return interface;
1755 }
1756
1757 static phy_interface_t eqos_get_interface_tegra186(struct udevice *dev)
1758 {
1759         return PHY_INTERFACE_MODE_MII;
1760 }
1761
1762 static int eqos_remove_resources_tegra186(struct udevice *dev)
1763 {
1764         struct eqos_priv *eqos = dev_get_priv(dev);
1765
1766         debug("%s(dev=%p):\n", __func__, dev);
1767
1768         clk_free(&eqos->clk_tx);
1769         clk_free(&eqos->clk_ptp_ref);
1770         clk_free(&eqos->clk_rx);
1771         clk_free(&eqos->clk_slave_bus);
1772         clk_free(&eqos->clk_master_bus);
1773         dm_gpio_free(dev, &eqos->phy_reset_gpio);
1774         reset_free(&eqos->reset_ctl);
1775
1776         debug("%s: OK\n", __func__);
1777         return 0;
1778 }
1779
1780 static int eqos_remove_resources_stm32(struct udevice *dev)
1781 {
1782         struct eqos_priv *eqos = dev_get_priv(dev);
1783
1784         debug("%s(dev=%p):\n", __func__, dev);
1785
1786         clk_free(&eqos->clk_tx);
1787         clk_free(&eqos->clk_rx);
1788         clk_free(&eqos->clk_master_bus);
1789         if (clk_valid(&eqos->clk_ck))
1790                 clk_free(&eqos->clk_ck);
1791
1792         if (dm_gpio_is_valid(&eqos->phy_reset_gpio))
1793                 dm_gpio_free(dev, &eqos->phy_reset_gpio);
1794
1795         debug("%s: OK\n", __func__);
1796         return 0;
1797 }
1798
1799 static int eqos_probe(struct udevice *dev)
1800 {
1801         struct eqos_priv *eqos = dev_get_priv(dev);
1802         int ret;
1803
1804         debug("%s(dev=%p):\n", __func__, dev);
1805
1806         eqos->dev = dev;
1807         eqos->config = (void *)dev_get_driver_data(dev);
1808
1809         eqos->regs = devfdt_get_addr(dev);
1810         if (eqos->regs == FDT_ADDR_T_NONE) {
1811                 pr_err("devfdt_get_addr() failed");
1812                 return -ENODEV;
1813         }
1814         eqos->mac_regs = (void *)(eqos->regs + EQOS_MAC_REGS_BASE);
1815         eqos->mtl_regs = (void *)(eqos->regs + EQOS_MTL_REGS_BASE);
1816         eqos->dma_regs = (void *)(eqos->regs + EQOS_DMA_REGS_BASE);
1817         eqos->tegra186_regs = (void *)(eqos->regs + EQOS_TEGRA186_REGS_BASE);
1818
1819         ret = eqos_probe_resources_core(dev);
1820         if (ret < 0) {
1821                 pr_err("eqos_probe_resources_core() failed: %d", ret);
1822                 return ret;
1823         }
1824
1825         ret = eqos->config->ops->eqos_probe_resources(dev);
1826         if (ret < 0) {
1827                 pr_err("eqos_probe_resources() failed: %d", ret);
1828                 goto err_remove_resources_core;
1829         }
1830
1831 #ifdef CONFIG_DM_ETH_PHY
1832         eqos->mii = eth_phy_get_mdio_bus(dev);
1833 #endif
1834         if (!eqos->mii) {
1835                 eqos->mii = mdio_alloc();
1836                 if (!eqos->mii) {
1837                         pr_err("mdio_alloc() failed");
1838                         ret = -ENOMEM;
1839                         goto err_remove_resources_tegra;
1840                 }
1841                 eqos->mii->read = eqos_mdio_read;
1842                 eqos->mii->write = eqos_mdio_write;
1843                 eqos->mii->priv = eqos;
1844                 strcpy(eqos->mii->name, dev->name);
1845
1846                 ret = mdio_register(eqos->mii);
1847                 if (ret < 0) {
1848                         pr_err("mdio_register() failed: %d", ret);
1849                         goto err_free_mdio;
1850                 }
1851         }
1852
1853 #ifdef CONFIG_DM_ETH_PHY
1854         eth_phy_set_mdio_bus(dev, eqos->mii);
1855 #endif
1856
1857         debug("%s: OK\n", __func__);
1858         return 0;
1859
1860 err_free_mdio:
1861         mdio_free(eqos->mii);
1862 err_remove_resources_tegra:
1863         eqos->config->ops->eqos_remove_resources(dev);
1864 err_remove_resources_core:
1865         eqos_remove_resources_core(dev);
1866
1867         debug("%s: returns %d\n", __func__, ret);
1868         return ret;
1869 }
1870
1871 static int eqos_remove(struct udevice *dev)
1872 {
1873         struct eqos_priv *eqos = dev_get_priv(dev);
1874
1875         debug("%s(dev=%p):\n", __func__, dev);
1876
1877         mdio_unregister(eqos->mii);
1878         mdio_free(eqos->mii);
1879         eqos->config->ops->eqos_remove_resources(dev);
1880
1881         eqos_probe_resources_core(dev);
1882
1883         debug("%s: OK\n", __func__);
1884         return 0;
1885 }
1886
1887 static const struct eth_ops eqos_ops = {
1888         .start = eqos_start,
1889         .stop = eqos_stop,
1890         .send = eqos_send,
1891         .recv = eqos_recv,
1892         .free_pkt = eqos_free_pkt,
1893         .write_hwaddr = eqos_write_hwaddr,
1894 };
1895
1896 static struct eqos_ops eqos_tegra186_ops = {
1897         .eqos_inval_desc = eqos_inval_desc_tegra186,
1898         .eqos_flush_desc = eqos_flush_desc_tegra186,
1899         .eqos_inval_buffer = eqos_inval_buffer_tegra186,
1900         .eqos_flush_buffer = eqos_flush_buffer_tegra186,
1901         .eqos_probe_resources = eqos_probe_resources_tegra186,
1902         .eqos_remove_resources = eqos_remove_resources_tegra186,
1903         .eqos_stop_resets = eqos_stop_resets_tegra186,
1904         .eqos_start_resets = eqos_start_resets_tegra186,
1905         .eqos_stop_clks = eqos_stop_clks_tegra186,
1906         .eqos_start_clks = eqos_start_clks_tegra186,
1907         .eqos_calibrate_pads = eqos_calibrate_pads_tegra186,
1908         .eqos_disable_calibration = eqos_disable_calibration_tegra186,
1909         .eqos_set_tx_clk_speed = eqos_set_tx_clk_speed_tegra186,
1910         .eqos_get_tick_clk_rate = eqos_get_tick_clk_rate_tegra186
1911 };
1912
1913 static const struct eqos_config eqos_tegra186_config = {
1914         .reg_access_always_ok = false,
1915         .mdio_wait = 10,
1916         .swr_wait = 10,
1917         .config_mac = EQOS_MAC_RXQ_CTRL0_RXQ0EN_ENABLED_DCB,
1918         .config_mac_mdio = EQOS_MAC_MDIO_ADDRESS_CR_20_35,
1919         .interface = eqos_get_interface_tegra186,
1920         .ops = &eqos_tegra186_ops
1921 };
1922
1923 static struct eqos_ops eqos_stm32_ops = {
1924         .eqos_inval_desc = eqos_inval_desc_stm32,
1925         .eqos_flush_desc = eqos_flush_desc_stm32,
1926         .eqos_inval_buffer = eqos_inval_buffer_stm32,
1927         .eqos_flush_buffer = eqos_flush_buffer_stm32,
1928         .eqos_probe_resources = eqos_probe_resources_stm32,
1929         .eqos_remove_resources = eqos_remove_resources_stm32,
1930         .eqos_stop_resets = eqos_stop_resets_stm32,
1931         .eqos_start_resets = eqos_start_resets_stm32,
1932         .eqos_stop_clks = eqos_stop_clks_stm32,
1933         .eqos_start_clks = eqos_start_clks_stm32,
1934         .eqos_calibrate_pads = eqos_calibrate_pads_stm32,
1935         .eqos_disable_calibration = eqos_disable_calibration_stm32,
1936         .eqos_set_tx_clk_speed = eqos_set_tx_clk_speed_stm32,
1937         .eqos_get_tick_clk_rate = eqos_get_tick_clk_rate_stm32
1938 };
1939
1940 static const struct eqos_config eqos_stm32_config = {
1941         .reg_access_always_ok = false,
1942         .mdio_wait = 10000,
1943         .swr_wait = 50,
1944         .config_mac = EQOS_MAC_RXQ_CTRL0_RXQ0EN_ENABLED_AV,
1945         .config_mac_mdio = EQOS_MAC_MDIO_ADDRESS_CR_250_300,
1946         .interface = eqos_get_interface_stm32,
1947         .ops = &eqos_stm32_ops
1948 };
1949
1950 static const struct udevice_id eqos_ids[] = {
1951         {
1952                 .compatible = "nvidia,tegra186-eqos",
1953                 .data = (ulong)&eqos_tegra186_config
1954         },
1955         {
1956                 .compatible = "snps,dwmac-4.20a",
1957                 .data = (ulong)&eqos_stm32_config
1958         },
1959
1960         { }
1961 };
1962
1963 U_BOOT_DRIVER(eth_eqos) = {
1964         .name = "eth_eqos",
1965         .id = UCLASS_ETH,
1966         .of_match = eqos_ids,
1967         .probe = eqos_probe,
1968         .remove = eqos_remove,
1969         .ops = &eqos_ops,
1970         .priv_auto_alloc_size = sizeof(struct eqos_priv),
1971         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
1972 };