target/linux/ramips/files-4.14/drivers/net/ethernet/mediatek/mtk_eth_soc.c

   1 /*   This program is free software; you can redistribute it and/or modify
   2  *   it under the terms of the GNU General Public License as published by
   3  *   the Free Software Foundation; version 2 of the License
   4  *
   5  *   This program is distributed in the hope that it will be useful,
   6  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   7  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   8  *   GNU General Public License for more details.
   9  *
  10  *   Copyright (C) 2009-2015 John Crispin <blogic@openwrt.org>
  11  *   Copyright (C) 2009-2015 Felix Fietkau <nbd@nbd.name>
  12  *   Copyright (C) 2013-2015 Michael Lee <igvtee@gmail.com>
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/types.h>
  18 #include <linux/dma-mapping.h>
  19 #include <linux/init.h>
  20 #include <linux/skbuff.h>
  21 #include <linux/etherdevice.h>
  22 #include <linux/ethtool.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/of_device.h>
  25 #include <linux/clk.h>
  26 #include <linux/of_net.h>
  27 #include <linux/of_mdio.h>
  28 #include <linux/if_vlan.h>
  29 #include <linux/reset.h>
  30 #include <linux/tcp.h>
  31 #include <linux/io.h>
  32 #include <linux/bug.h>
  33 #include <linux/netfilter.h>
  34 #include <net/netfilter/nf_flow_table.h>
  35
  36 #include <asm/mach-ralink/ralink_regs.h>
  37
  38 #include "mtk_eth_soc.h"
  39 #include "mdio.h"
  40 #include "ethtool.h"
  41
  42 #define MAX_RX_LENGTH           1536
  43 #define FE_RX_ETH_HLEN          (VLAN_ETH_HLEN + VLAN_HLEN + ETH_FCS_LEN)
  44 #define FE_RX_HLEN              (NET_SKB_PAD + FE_RX_ETH_HLEN + NET_IP_ALIGN)
  45 #define DMA_DUMMY_DESC          0xffffffff
  46 #define FE_DEFAULT_MSG_ENABLE \
  47                 (NETIF_MSG_DRV | \
  48                 NETIF_MSG_PROBE | \
  49                 NETIF_MSG_LINK | \
  50                 NETIF_MSG_TIMER | \
  51                 NETIF_MSG_IFDOWN | \
  52                 NETIF_MSG_IFUP | \
  53                 NETIF_MSG_RX_ERR | \
  54                 NETIF_MSG_TX_ERR)
  55
  56 #define TX_DMA_DESP2_DEF        (TX_DMA_LS0 | TX_DMA_DONE)
  57 #define TX_DMA_DESP4_DEF        (TX_DMA_QN(3) | TX_DMA_PN(1))
  58 #define NEXT_TX_DESP_IDX(X)     (((X) + 1) & (ring->tx_ring_size - 1))
  59 #define NEXT_RX_DESP_IDX(X)     (((X) + 1) & (ring->rx_ring_size - 1))
  60
  61 #define SYSC_REG_RSTCTRL        0x34
  62
  63 static int fe_msg_level = -1;
  64 module_param_named(msg_level, fe_msg_level, int, 0);
  65 MODULE_PARM_DESC(msg_level, "Message level (-1=defaults,0=none,...,16=all)");
  66
  67 static const u16 fe_reg_table_default[FE_REG_COUNT] = {
  68         [FE_REG_PDMA_GLO_CFG] = FE_PDMA_GLO_CFG,
  69         [FE_REG_PDMA_RST_CFG] = FE_PDMA_RST_CFG,
  70         [FE_REG_DLY_INT_CFG] = FE_DLY_INT_CFG,
  71         [FE_REG_TX_BASE_PTR0] = FE_TX_BASE_PTR0,
  72         [FE_REG_TX_MAX_CNT0] = FE_TX_MAX_CNT0,
  73         [FE_REG_TX_CTX_IDX0] = FE_TX_CTX_IDX0,
  74         [FE_REG_TX_DTX_IDX0] = FE_TX_DTX_IDX0,
  75         [FE_REG_RX_BASE_PTR0] = FE_RX_BASE_PTR0,
  76         [FE_REG_RX_MAX_CNT0] = FE_RX_MAX_CNT0,
  77         [FE_REG_RX_CALC_IDX0] = FE_RX_CALC_IDX0,
  78         [FE_REG_RX_DRX_IDX0] = FE_RX_DRX_IDX0,
  79         [FE_REG_FE_INT_ENABLE] = FE_FE_INT_ENABLE,
  80         [FE_REG_FE_INT_STATUS] = FE_FE_INT_STATUS,
  81         [FE_REG_FE_DMA_VID_BASE] = FE_DMA_VID0,
  82         [FE_REG_FE_COUNTER_BASE] = FE_GDMA1_TX_GBCNT,
  83         [FE_REG_FE_RST_GL] = FE_FE_RST_GL,
  84 };
  85
  86 static const u16 *fe_reg_table = fe_reg_table_default;
  87
  88 struct fe_work_t {
  89         int bitnr;
  90         void (*action)(struct fe_priv *);
  91 };
  92
  93 static void __iomem *fe_base;
  94
  95 void fe_w32(u32 val, unsigned reg)
  96 {
  97         __raw_writel(val, fe_base + reg);
  98 }
  99
 100 u32 fe_r32(unsigned reg)
 101 {
 102         return __raw_readl(fe_base + reg);
 103 }
 104
 105 void fe_reg_w32(u32 val, enum fe_reg reg)
 106 {
 107         fe_w32(val, fe_reg_table[reg]);
 108 }
 109
 110 u32 fe_reg_r32(enum fe_reg reg)
 111 {
 112         return fe_r32(fe_reg_table[reg]);
 113 }
 114
 115 void fe_m32(struct fe_priv *eth, u32 clear, u32 set, unsigned reg)
 116 {
 117         u32 val;
 118
 119         spin_lock(&eth->page_lock);
 120         val = __raw_readl(fe_base + reg);
 121         val &= ~clear;
 122         val |= set;
 123         __raw_writel(val, fe_base + reg);
 124         spin_unlock(&eth->page_lock);
 125 }
 126
 127 void fe_reset(u32 reset_bits)
 128 {
 129         u32 t;
 130
 131         t = rt_sysc_r32(SYSC_REG_RSTCTRL);
 132         t |= reset_bits;
 133         rt_sysc_w32(t, SYSC_REG_RSTCTRL);
 134         usleep_range(10, 20);
 135
 136         t &= ~reset_bits;
 137         rt_sysc_w32(t, SYSC_REG_RSTCTRL);
 138         usleep_range(10, 20);
 139 }
 140
 141 static inline void fe_int_disable(u32 mask)
 142 {
 143         fe_reg_w32(fe_reg_r32(FE_REG_FE_INT_ENABLE) & ~mask,
 144                    FE_REG_FE_INT_ENABLE);
 145         /* flush write */
 146         fe_reg_r32(FE_REG_FE_INT_ENABLE);
 147 }
 148
 149 static inline void fe_int_enable(u32 mask)
 150 {
 151         fe_reg_w32(fe_reg_r32(FE_REG_FE_INT_ENABLE) | mask,
 152                    FE_REG_FE_INT_ENABLE);
 153         /* flush write */
 154         fe_reg_r32(FE_REG_FE_INT_ENABLE);
 155 }
 156
 157 static inline void fe_hw_set_macaddr(struct fe_priv *priv, unsigned char *mac)
 158 {
 159         unsigned long flags;
 160
 161         spin_lock_irqsave(&priv->page_lock, flags);
 162         fe_w32((mac[0] << 8) | mac[1], FE_GDMA1_MAC_ADRH);
 163         fe_w32((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
 164                FE_GDMA1_MAC_ADRL);
 165         spin_unlock_irqrestore(&priv->page_lock, flags);
 166 }
 167
 168 static int fe_set_mac_address(struct net_device *dev, void *p)
 169 {
 170         int ret = eth_mac_addr(dev, p);
 171
 172         if (!ret) {
 173                 struct fe_priv *priv = netdev_priv(dev);
 174
 175                 if (priv->soc->set_mac)
 176                         priv->soc->set_mac(priv, dev->dev_addr);
 177                 else
 178                         fe_hw_set_macaddr(priv, p);
 179         }
 180
 181         return ret;
 182 }
 183
 184 static inline int fe_max_frag_size(int mtu)
 185 {
 186         /* make sure buf_size will be at least MAX_RX_LENGTH */
 187         if (mtu + FE_RX_ETH_HLEN < MAX_RX_LENGTH)
 188                 mtu = MAX_RX_LENGTH - FE_RX_ETH_HLEN;
 189
 190         return SKB_DATA_ALIGN(FE_RX_HLEN + mtu) +
 191                 SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 192 }
 193
 194 static inline int fe_max_buf_size(int frag_size)
 195 {
 196         int buf_size = frag_size - NET_SKB_PAD - NET_IP_ALIGN -
 197                        SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 198
 199         BUG_ON(buf_size < MAX_RX_LENGTH);
 200         return buf_size;
 201 }
 202
 203 static inline void fe_get_rxd(struct fe_rx_dma *rxd, struct fe_rx_dma *dma_rxd)
 204 {
 205         rxd->rxd1 = dma_rxd->rxd1;
 206         rxd->rxd2 = dma_rxd->rxd2;
 207         rxd->rxd3 = dma_rxd->rxd3;
 208         rxd->rxd4 = dma_rxd->rxd4;
 209 }
 210
 211 static inline void fe_set_txd(struct fe_tx_dma *txd, struct fe_tx_dma *dma_txd)
 212 {
 213         dma_txd->txd1 = txd->txd1;
 214         dma_txd->txd3 = txd->txd3;
 215         dma_txd->txd4 = txd->txd4;
 216         /* clean dma done flag last */
 217         dma_txd->txd2 = txd->txd2;
 218 }
 219
 220 static void fe_clean_rx(struct fe_priv *priv)
 221 {
 222         struct fe_rx_ring *ring = &priv->rx_ring;
 223         struct page *page;
 224         int i;
 225
 226         if (ring->rx_data) {
 227                 for (i = 0; i < ring->rx_ring_size; i++)
 228                         if (ring->rx_data[i]) {
 229                                 if (ring->rx_dma && ring->rx_dma[i].rxd1)
 230                                         dma_unmap_single(&priv->netdev->dev,
 231                                                          ring->rx_dma[i].rxd1,
 232                                                          ring->rx_buf_size,
 233                                                          DMA_FROM_DEVICE);
 234                                 skb_free_frag(ring->rx_data[i]);
 235                         }
 236
 237                 kfree(ring->rx_data);
 238                 ring->rx_data = NULL;
 239         }
 240
 241         if (ring->rx_dma) {
 242                 dma_free_coherent(&priv->netdev->dev,
 243                                   ring->rx_ring_size * sizeof(*ring->rx_dma),
 244                                   ring->rx_dma,
 245                                   ring->rx_phys);
 246                 ring->rx_dma = NULL;
 247         }
 248
 249         if (!ring->frag_cache.va)
 250             return;
 251
 252         page = virt_to_page(ring->frag_cache.va);
 253         __page_frag_cache_drain(page, ring->frag_cache.pagecnt_bias);
 254         memset(&ring->frag_cache, 0, sizeof(ring->frag_cache));
 255 }
 256
 257 static int fe_alloc_rx(struct fe_priv *priv)
 258 {
 259         struct net_device *netdev = priv->netdev;
 260         struct fe_rx_ring *ring = &priv->rx_ring;
 261         int i, pad;
 262
 263         ring->rx_data = kcalloc(ring->rx_ring_size, sizeof(*ring->rx_data),
 264                         GFP_KERNEL);
 265         if (!ring->rx_data)
 266                 goto no_rx_mem;
 267
 268         for (i = 0; i < ring->rx_ring_size; i++) {
 269                 ring->rx_data[i] = page_frag_alloc(&ring->frag_cache,
 270                                                    ring->frag_size,
 271                                                    GFP_KERNEL);
 272                 if (!ring->rx_data[i])
 273                         goto no_rx_mem;
 274         }
 275
 276         ring->rx_dma = dma_alloc_coherent(&netdev->dev,
 277                         ring->rx_ring_size * sizeof(*ring->rx_dma),
 278                         &ring->rx_phys,
 279                         GFP_ATOMIC | __GFP_ZERO);
 280         if (!ring->rx_dma)
 281                 goto no_rx_mem;
 282
 283         if (priv->flags & FE_FLAG_RX_2B_OFFSET)
 284                 pad = 0;
 285         else
 286                 pad = NET_IP_ALIGN;
 287         for (i = 0; i < ring->rx_ring_size; i++) {
 288                 dma_addr_t dma_addr = dma_map_single(&netdev->dev,
 289                                 ring->rx_data[i] + NET_SKB_PAD + pad,
 290                                 ring->rx_buf_size,
 291                                 DMA_FROM_DEVICE);
 292                 if (unlikely(dma_mapping_error(&netdev->dev, dma_addr)))
 293                         goto no_rx_mem;
 294                 ring->rx_dma[i].rxd1 = (unsigned int)dma_addr;
 295
 296                 if (priv->flags & FE_FLAG_RX_SG_DMA)
 297                         ring->rx_dma[i].rxd2 = RX_DMA_PLEN0(ring->rx_buf_size);
 298                 else
 299                         ring->rx_dma[i].rxd2 = RX_DMA_LSO;
 300         }
 301         ring->rx_calc_idx = ring->rx_ring_size - 1;
 302         /* make sure that all changes to the dma ring are flushed before we
 303          * continue
 304          */
 305         wmb();
 306
 307         fe_reg_w32(ring->rx_phys, FE_REG_RX_BASE_PTR0);
 308         fe_reg_w32(ring->rx_ring_size, FE_REG_RX_MAX_CNT0);
 309         fe_reg_w32(ring->rx_calc_idx, FE_REG_RX_CALC_IDX0);
 310         fe_reg_w32(FE_PST_DRX_IDX0, FE_REG_PDMA_RST_CFG);
 311
 312         return 0;
 313
 314 no_rx_mem:
 315         return -ENOMEM;
 316 }
 317
 318 static void fe_txd_unmap(struct device *dev, struct fe_tx_buf *tx_buf)
 319 {
 320         if (dma_unmap_len(tx_buf, dma_len0))
 321                 dma_unmap_page(dev,
 322                                dma_unmap_addr(tx_buf, dma_addr0),
 323                                dma_unmap_len(tx_buf, dma_len0),
 324                                DMA_TO_DEVICE);
 325
 326         if (dma_unmap_len(tx_buf, dma_len1))
 327                 dma_unmap_page(dev,
 328                                dma_unmap_addr(tx_buf, dma_addr1),
 329                                dma_unmap_len(tx_buf, dma_len1),
 330                                DMA_TO_DEVICE);
 331
 332         dma_unmap_len_set(tx_buf, dma_addr0, 0);
 333         dma_unmap_len_set(tx_buf, dma_addr1, 0);
 334         if (tx_buf->skb && (tx_buf->skb != (struct sk_buff *)DMA_DUMMY_DESC))
 335                 dev_kfree_skb_any(tx_buf->skb);
 336         tx_buf->skb = NULL;
 337 }
 338
 339 static void fe_clean_tx(struct fe_priv *priv)
 340 {
 341         int i;
 342         struct device *dev = &priv->netdev->dev;
 343         struct fe_tx_ring *ring = &priv->tx_ring;
 344
 345         if (ring->tx_buf) {
 346                 for (i = 0; i < ring->tx_ring_size; i++)
 347                         fe_txd_unmap(dev, &ring->tx_buf[i]);
 348                 kfree(ring->tx_buf);
 349                 ring->tx_buf = NULL;
 350         }
 351
 352         if (ring->tx_dma) {
 353                 dma_free_coherent(dev,
 354                                   ring->tx_ring_size * sizeof(*ring->tx_dma),
 355                                   ring->tx_dma,
 356                                   ring->tx_phys);
 357                 ring->tx_dma = NULL;
 358         }
 359
 360         netdev_reset_queue(priv->netdev);
 361 }
 362
 363 static int fe_alloc_tx(struct fe_priv *priv)
 364 {
 365         int i;
 366         struct fe_tx_ring *ring = &priv->tx_ring;
 367
 368         ring->tx_free_idx = 0;
 369         ring->tx_next_idx = 0;
 370         ring->tx_thresh = max((unsigned long)ring->tx_ring_size >> 2,
 371                               MAX_SKB_FRAGS);
 372
 373         ring->tx_buf = kcalloc(ring->tx_ring_size, sizeof(*ring->tx_buf),
 374                         GFP_KERNEL);
 375         if (!ring->tx_buf)
 376                 goto no_tx_mem;
 377
 378         ring->tx_dma = dma_alloc_coherent(&priv->netdev->dev,
 379                         ring->tx_ring_size * sizeof(*ring->tx_dma),
 380                         &ring->tx_phys,
 381                         GFP_ATOMIC | __GFP_ZERO);
 382         if (!ring->tx_dma)
 383                 goto no_tx_mem;
 384
 385         for (i = 0; i < ring->tx_ring_size; i++) {
 386                 if (priv->soc->tx_dma)
 387                         priv->soc->tx_dma(&ring->tx_dma[i]);
 388                 ring->tx_dma[i].txd2 = TX_DMA_DESP2_DEF;
 389         }
 390         /* make sure that all changes to the dma ring are flushed before we
 391          * continue
 392          */
 393         wmb();
 394
 395         fe_reg_w32(ring->tx_phys, FE_REG_TX_BASE_PTR0);
 396         fe_reg_w32(ring->tx_ring_size, FE_REG_TX_MAX_CNT0);
 397         fe_reg_w32(0, FE_REG_TX_CTX_IDX0);
 398         fe_reg_w32(FE_PST_DTX_IDX0, FE_REG_PDMA_RST_CFG);
 399
 400         return 0;
 401
 402 no_tx_mem:
 403         return -ENOMEM;
 404 }
 405
 406 static int fe_init_dma(struct fe_priv *priv)
 407 {
 408         int err;
 409
 410         err = fe_alloc_tx(priv);
 411         if (err)
 412                 return err;
 413
 414         err = fe_alloc_rx(priv);
 415         if (err)
 416                 return err;
 417
 418         return 0;
 419 }
 420
 421 static void fe_free_dma(struct fe_priv *priv)
 422 {
 423         fe_clean_tx(priv);
 424         fe_clean_rx(priv);
 425 }
 426
 427 void fe_stats_update(struct fe_priv *priv)
 428 {
 429         struct fe_hw_stats *hwstats = priv->hw_stats;
 430         unsigned int base = fe_reg_table[FE_REG_FE_COUNTER_BASE];
 431         u64 stats;
 432
 433         u64_stats_update_begin(&hwstats->syncp);
 434
 435         if (IS_ENABLED(CONFIG_SOC_MT7621)) {
 436                 hwstats->rx_bytes                       += fe_r32(base);
 437                 stats                                   =  fe_r32(base + 0x04);
 438                 if (stats)
 439                         hwstats->rx_bytes               += (stats << 32);
 440                 hwstats->rx_packets                     += fe_r32(base + 0x08);
 441                 hwstats->rx_overflow                    += fe_r32(base + 0x10);
 442                 hwstats->rx_fcs_errors                  += fe_r32(base + 0x14);
 443                 hwstats->rx_short_errors                += fe_r32(base + 0x18);
 444                 hwstats->rx_long_errors                 += fe_r32(base + 0x1c);
 445                 hwstats->rx_checksum_errors             += fe_r32(base + 0x20);
 446                 hwstats->rx_flow_control_packets        += fe_r32(base + 0x24);
 447                 hwstats->tx_skip                        += fe_r32(base + 0x28);
 448                 hwstats->tx_collisions                  += fe_r32(base + 0x2c);
 449                 hwstats->tx_bytes                       += fe_r32(base + 0x30);
 450                 stats                                   =  fe_r32(base + 0x34);
 451                 if (stats)
 452                         hwstats->tx_bytes               += (stats << 32);
 453                 hwstats->tx_packets                     += fe_r32(base + 0x38);
 454         } else {
 455                 hwstats->tx_bytes                       += fe_r32(base);
 456                 hwstats->tx_packets                     += fe_r32(base + 0x04);
 457                 hwstats->tx_skip                        += fe_r32(base + 0x08);
 458                 hwstats->tx_collisions                  += fe_r32(base + 0x0c);
 459                 hwstats->rx_bytes                       += fe_r32(base + 0x20);
 460                 hwstats->rx_packets                     += fe_r32(base + 0x24);
 461                 hwstats->rx_overflow                    += fe_r32(base + 0x28);
 462                 hwstats->rx_fcs_errors                  += fe_r32(base + 0x2c);
 463                 hwstats->rx_short_errors                += fe_r32(base + 0x30);
 464                 hwstats->rx_long_errors                 += fe_r32(base + 0x34);
 465                 hwstats->rx_checksum_errors             += fe_r32(base + 0x38);
 466                 hwstats->rx_flow_control_packets        += fe_r32(base + 0x3c);
 467         }
 468
 469         u64_stats_update_end(&hwstats->syncp);
 470 }
 471
 472 static void fe_get_stats64(struct net_device *dev,
 473                                 struct rtnl_link_stats64 *storage)
 474 {
 475         struct fe_priv *priv = netdev_priv(dev);
 476         struct fe_hw_stats *hwstats = priv->hw_stats;
 477         unsigned int base = fe_reg_table[FE_REG_FE_COUNTER_BASE];
 478         unsigned int start;
 479
 480         if (!base) {
 481                 netdev_stats_to_stats64(storage, &dev->stats);
 482                 return;
 483         }
 484
 485         if (netif_running(dev) && netif_device_present(dev)) {
 486                 if (spin_trylock_bh(&hwstats->stats_lock)) {
 487                         fe_stats_update(priv);
 488                         spin_unlock_bh(&hwstats->stats_lock);
 489                 }
 490         }
 491
 492         do {
 493                 start = u64_stats_fetch_begin_irq(&hwstats->syncp);
 494                 storage->rx_packets = hwstats->rx_packets;
 495                 storage->tx_packets = hwstats->tx_packets;
 496                 storage->rx_bytes = hwstats->rx_bytes;
 497                 storage->tx_bytes = hwstats->tx_bytes;
 498                 storage->collisions = hwstats->tx_collisions;
 499                 storage->rx_length_errors = hwstats->rx_short_errors +
 500                         hwstats->rx_long_errors;
 501                 storage->rx_over_errors = hwstats->rx_overflow;
 502                 storage->rx_crc_errors = hwstats->rx_fcs_errors;
 503                 storage->rx_errors = hwstats->rx_checksum_errors;
 504                 storage->tx_aborted_errors = hwstats->tx_skip;
 505         } while (u64_stats_fetch_retry_irq(&hwstats->syncp, start));
 506
 507         storage->tx_errors = priv->netdev->stats.tx_errors;
 508         storage->rx_dropped = priv->netdev->stats.rx_dropped;
 509         storage->tx_dropped = priv->netdev->stats.tx_dropped;
 510 }
 511
 512 static int fe_vlan_rx_add_vid(struct net_device *dev,
 513                               __be16 proto, u16 vid)
 514 {
 515         struct fe_priv *priv = netdev_priv(dev);
 516         u32 idx = (vid & 0xf);
 517         u32 vlan_cfg;
 518
 519         if (!((fe_reg_table[FE_REG_FE_DMA_VID_BASE]) &&
 520               (dev->features & NETIF_F_HW_VLAN_CTAG_TX)))
 521                 return 0;
 522
 523         if (test_bit(idx, &priv->vlan_map)) {
 524                 netdev_warn(dev, "disable tx vlan offload\n");
 525                 dev->wanted_features &= ~NETIF_F_HW_VLAN_CTAG_TX;
 526                 netdev_update_features(dev);
 527         } else {
 528                 vlan_cfg = fe_r32(fe_reg_table[FE_REG_FE_DMA_VID_BASE] +
 529                                 ((idx >> 1) << 2));
 530                 if (idx & 0x1) {
 531                         vlan_cfg &= 0xffff;
 532                         vlan_cfg |= (vid << 16);
 533                 } else {
 534                         vlan_cfg &= 0xffff0000;
 535                         vlan_cfg |= vid;
 536                 }
 537                 fe_w32(vlan_cfg, fe_reg_table[FE_REG_FE_DMA_VID_BASE] +
 538                                 ((idx >> 1) << 2));
 539                 set_bit(idx, &priv->vlan_map);
 540         }
 541
 542         return 0;
 543 }
 544
 545 static int fe_vlan_rx_kill_vid(struct net_device *dev,
 546                                __be16 proto, u16 vid)
 547 {
 548         struct fe_priv *priv = netdev_priv(dev);
 549         u32 idx = (vid & 0xf);
 550
 551         if (!((fe_reg_table[FE_REG_FE_DMA_VID_BASE]) &&
 552               (dev->features & NETIF_F_HW_VLAN_CTAG_TX)))
 553                 return 0;
 554
 555         clear_bit(idx, &priv->vlan_map);
 556
 557         return 0;
 558 }
 559
 560 static inline u32 fe_empty_txd(struct fe_tx_ring *ring)
 561 {
 562         barrier();
 563         return (u32)(ring->tx_ring_size -
 564                         ((ring->tx_next_idx - ring->tx_free_idx) &
 565                          (ring->tx_ring_size - 1)));
 566 }
 567
 568 struct fe_map_state {
 569         struct device *dev;
 570         struct fe_tx_dma txd;
 571         u32 def_txd4;
 572         int ring_idx;
 573         int i;
 574 };
 575
 576 static void fe_tx_dma_write_desc(struct fe_tx_ring *ring, struct fe_map_state *st)
 577 {
 578         fe_set_txd(&st->txd, &ring->tx_dma[st->ring_idx]);
 579         memset(&st->txd, 0, sizeof(st->txd));
 580         st->txd.txd4 = st->def_txd4;
 581         st->ring_idx = NEXT_TX_DESP_IDX(st->ring_idx);
 582 }
 583
 584 static int __fe_tx_dma_map_page(struct fe_tx_ring *ring, struct fe_map_state *st,
 585                                 struct page *page, size_t offset, size_t size)
 586 {
 587         struct device *dev = st->dev;
 588         struct fe_tx_buf *tx_buf;
 589         dma_addr_t mapped_addr;
 590
 591         mapped_addr = dma_map_page(dev, page, offset, size, DMA_TO_DEVICE);
 592         if (unlikely(dma_mapping_error(dev, mapped_addr)))
 593                 return -EIO;
 594
 595         if (st->i && !(st->i & 1))
 596             fe_tx_dma_write_desc(ring, st);
 597
 598         tx_buf = &ring->tx_buf[st->ring_idx];
 599         if (st->i & 1) {
 600                 st->txd.txd3 = mapped_addr;
 601                 st->txd.txd2 |= TX_DMA_PLEN1(size);
 602                 dma_unmap_addr_set(tx_buf, dma_addr1, mapped_addr);
 603                 dma_unmap_len_set(tx_buf, dma_len1, size);
 604         } else {
 605                 tx_buf->skb = (struct sk_buff *)DMA_DUMMY_DESC;
 606                 st->txd.txd1 = mapped_addr;
 607                 st->txd.txd2 = TX_DMA_PLEN0(size);
 608                 dma_unmap_addr_set(tx_buf, dma_addr0, mapped_addr);
 609                 dma_unmap_len_set(tx_buf, dma_len0, size);
 610         }
 611         st->i++;
 612
 613         return 0;
 614 }
 615
 616 static int fe_tx_dma_map_page(struct fe_tx_ring *ring, struct fe_map_state *st,
 617                               struct page *page, size_t offset, size_t size)
 618 {
 619         int cur_size;
 620         int ret;
 621
 622         while (size > 0) {
 623                 cur_size = min_t(size_t, size, TX_DMA_BUF_LEN);
 624
 625                 ret = __fe_tx_dma_map_page(ring, st, page, offset, cur_size);
 626                 if (ret)
 627                         return ret;
 628
 629                 size -= cur_size;
 630                 offset += cur_size;
 631         }
 632
 633         return 0;
 634 }
 635
 636 static int fe_tx_dma_map_skb(struct fe_tx_ring *ring, struct fe_map_state *st,
 637                              struct sk_buff *skb)
 638 {
 639         struct page *page = virt_to_page(skb->data);
 640         size_t offset = offset_in_page(skb->data);
 641         size_t size = skb_headlen(skb);
 642
 643         return fe_tx_dma_map_page(ring, st, page, offset, size);
 644 }
 645
 646 static inline struct sk_buff *
 647 fe_next_frag(struct sk_buff *head, struct sk_buff *skb)
 648 {
 649         if (skb != head)
 650                 return skb->next;
 651
 652         if (skb_has_frag_list(skb))
 653                 return skb_shinfo(skb)->frag_list;
 654
 655         return NULL;
 656 }
 657
 658
 659 static int fe_tx_map_dma(struct sk_buff *skb, struct net_device *dev,
 660                          int tx_num, struct fe_tx_ring *ring)
 661 {
 662         struct fe_priv *priv = netdev_priv(dev);
 663         struct fe_map_state st = {
 664                 .dev = &dev->dev,
 665                 .ring_idx = ring->tx_next_idx,
 666         };
 667         struct sk_buff *head = skb;
 668         struct fe_tx_buf *tx_buf;
 669         unsigned int nr_frags;
 670         int i, j;
 671
 672         /* init tx descriptor */
 673         if (priv->soc->tx_dma)
 674                 priv->soc->tx_dma(&st.txd);
 675         else
 676                 st.txd.txd4 = TX_DMA_DESP4_DEF;
 677         st.def_txd4 = st.txd.txd4;
 678
 679         /* TX Checksum offload */
 680         if (skb->ip_summed == CHECKSUM_PARTIAL)
 681                 st.txd.txd4 |= TX_DMA_CHKSUM;
 682
 683         /* VLAN header offload */
 684         if (skb_vlan_tag_present(skb)) {
 685                 u16 tag = skb_vlan_tag_get(skb);
 686
 687                 if (IS_ENABLED(CONFIG_SOC_MT7621))
 688                         st.txd.txd4 |= TX_DMA_INS_VLAN_MT7621 | tag;
 689                 else
 690                         st.txd.txd4 |= TX_DMA_INS_VLAN |
 691                                 ((tag >> VLAN_PRIO_SHIFT) << 4) |
 692                                 (tag & 0xF);
 693         }
 694
 695         /* TSO: fill MSS info in tcp checksum field */
 696         if (skb_is_gso(skb)) {
 697                 if (skb_cow_head(skb, 0)) {
 698                         netif_warn(priv, tx_err, dev,
 699                                    "GSO expand head fail.\n");
 700                         goto err_out;
 701                 }
 702                 if (skb_shinfo(skb)->gso_type &
 703                                 (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)) {
 704                         st.txd.txd4 |= TX_DMA_TSO;
 705                         tcp_hdr(skb)->check = htons(skb_shinfo(skb)->gso_size);
 706                 }
 707         }
 708
 709 next_frag:
 710         if (skb_headlen(skb) && fe_tx_dma_map_skb(ring, &st, skb))
 711                 goto err_dma;
 712
 713         /* TX SG offload */
 714         nr_frags = skb_shinfo(skb)->nr_frags;
 715         for (i = 0; i < nr_frags; i++) {
 716                 struct skb_frag_struct *frag;
 717
 718                 frag = &skb_shinfo(skb)->frags[i];
 719                 if (fe_tx_dma_map_page(ring, &st, skb_frag_page(frag),
 720                                        frag->page_offset, skb_frag_size(frag)))
 721                         goto err_dma;
 722         }
 723
 724         skb = fe_next_frag(head, skb);
 725         if (skb)
 726                 goto next_frag;
 727
 728         /* set last segment */
 729         if (st.i & 0x1)
 730                 st.txd.txd2 |= TX_DMA_LS0;
 731         else
 732                 st.txd.txd2 |= TX_DMA_LS1;
 733
 734         /* store skb to cleanup */
 735         tx_buf = &ring->tx_buf[st.ring_idx];
 736         tx_buf->skb = head;
 737
 738         netdev_sent_queue(dev, head->len);
 739         skb_tx_timestamp(head);
 740
 741         fe_tx_dma_write_desc(ring, &st);
 742         ring->tx_next_idx = st.ring_idx;
 743
 744         /* make sure that all changes to the dma ring are flushed before we
 745          * continue
 746          */
 747         wmb();
 748         if (unlikely(fe_empty_txd(ring) <= ring->tx_thresh)) {
 749                 netif_stop_queue(dev);
 750                 smp_mb();
 751                 if (unlikely(fe_empty_txd(ring) > ring->tx_thresh))
 752                         netif_wake_queue(dev);
 753         }
 754
 755         if (netif_xmit_stopped(netdev_get_tx_queue(dev, 0)) || !head->xmit_more)
 756                 fe_reg_w32(ring->tx_next_idx, FE_REG_TX_CTX_IDX0);
 757
 758         return 0;
 759
 760 err_dma:
 761         j = ring->tx_next_idx;
 762         for (i = 0; i < tx_num; i++) {
 763                 /* unmap dma */
 764                 fe_txd_unmap(&dev->dev, &ring->tx_buf[j]);
 765                 ring->tx_dma[j].txd2 = TX_DMA_DESP2_DEF;
 766
 767                 j = NEXT_TX_DESP_IDX(j);
 768         }
 769         /* make sure that all changes to the dma ring are flushed before we
 770          * continue
 771          */
 772         wmb();
 773
 774 err_out:
 775         return -1;
 776 }
 777
 778 static inline int fe_skb_padto(struct sk_buff *skb, struct fe_priv *priv)
 779 {
 780         unsigned int len;
 781         int ret;
 782
 783         ret = 0;
 784         if (unlikely(skb->len < VLAN_ETH_ZLEN)) {
 785                 if ((priv->flags & FE_FLAG_PADDING_64B) &&
 786                     !(priv->flags & FE_FLAG_PADDING_BUG))
 787                         return ret;
 788
 789                 if (skb_vlan_tag_present(skb))
 790                         len = ETH_ZLEN;
 791                 else if (skb->protocol == cpu_to_be16(ETH_P_8021Q))
 792                         len = VLAN_ETH_ZLEN;
 793                 else if (!(priv->flags & FE_FLAG_PADDING_64B))
 794                         len = ETH_ZLEN;
 795                 else
 796                         return ret;
 797
 798                 if (skb->len < len) {
 799                         ret = skb_pad(skb, len - skb->len);
 800                         if (ret < 0)
 801                                 return ret;
 802                         skb->len = len;
 803                         skb_set_tail_pointer(skb, len);
 804                 }
 805         }
 806
 807         return ret;
 808 }
 809
 810 static inline int fe_cal_txd_req(struct sk_buff *skb)
 811 {
 812         struct sk_buff *head = skb;
 813         int i, nfrags = 0;
 814         struct skb_frag_struct *frag;
 815
 816 next_frag:
 817         nfrags++;
 818         if (skb_is_gso(skb)) {
 819                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 820                         frag = &skb_shinfo(skb)->frags[i];
 821                         nfrags += DIV_ROUND_UP(frag->size, TX_DMA_BUF_LEN);
 822                 }
 823         } else {
 824                 nfrags += skb_shinfo(skb)->nr_frags;
 825         }
 826
 827         skb = fe_next_frag(head, skb);
 828         if (skb)
 829                 goto next_frag;
 830
 831         return DIV_ROUND_UP(nfrags, 2);
 832 }
 833
 834 static int fe_start_xmit(struct sk_buff *skb, struct net_device *dev)
 835 {
 836         struct fe_priv *priv = netdev_priv(dev);
 837         struct fe_tx_ring *ring = &priv->tx_ring;
 838         struct net_device_stats *stats = &dev->stats;
 839         int tx_num;
 840         int len = skb->len;
 841
 842         if (fe_skb_padto(skb, priv)) {
 843                 netif_warn(priv, tx_err, dev, "tx padding failed!\n");
 844                 return NETDEV_TX_OK;
 845         }
 846
 847         tx_num = fe_cal_txd_req(skb);
 848         if (unlikely(fe_empty_txd(ring) <= tx_num)) {
 849                 netif_stop_queue(dev);
 850                 netif_err(priv, tx_queued, dev,
 851                           "Tx Ring full when queue awake!\n");
 852                 return NETDEV_TX_BUSY;
 853         }
 854
 855         if (fe_tx_map_dma(skb, dev, tx_num, ring) < 0) {
 856                 stats->tx_dropped++;
 857         } else {
 858                 stats->tx_packets++;
 859                 stats->tx_bytes += len;
 860         }
 861
 862         return NETDEV_TX_OK;
 863 }
 864
 865 static int fe_poll_rx(struct napi_struct *napi, int budget,
 866                       struct fe_priv *priv, u32 rx_intr)
 867 {
 868         struct net_device *netdev = priv->netdev;
 869         struct net_device_stats *stats = &netdev->stats;
 870         struct fe_soc_data *soc = priv->soc;
 871         struct fe_rx_ring *ring = &priv->rx_ring;
 872         int idx = ring->rx_calc_idx;
 873         u32 checksum_bit;
 874         struct sk_buff *skb;
 875         u8 *data, *new_data;
 876         struct fe_rx_dma *rxd, trxd;
 877         int done = 0, pad;
 878
 879         if (netdev->features & NETIF_F_RXCSUM)
 880                 checksum_bit = soc->checksum_bit;
 881         else
 882                 checksum_bit = 0;
 883
 884         if (priv->flags & FE_FLAG_RX_2B_OFFSET)
 885                 pad = 0;
 886         else
 887                 pad = NET_IP_ALIGN;
 888
 889         while (done < budget) {
 890                 unsigned int pktlen;
 891                 dma_addr_t dma_addr;
 892
 893                 idx = NEXT_RX_DESP_IDX(idx);
 894                 rxd = &ring->rx_dma[idx];
 895                 data = ring->rx_data[idx];
 896
 897                 fe_get_rxd(&trxd, rxd);
 898                 if (!(trxd.rxd2 & RX_DMA_DONE))
 899                         break;
 900
 901                 /* alloc new buffer */
 902                 new_data = page_frag_alloc(&ring->frag_cache, ring->frag_size,
 903                                            GFP_ATOMIC);
 904                 if (unlikely(!new_data)) {
 905                         stats->rx_dropped++;
 906                         goto release_desc;
 907                 }
 908                 dma_addr = dma_map_single(&netdev->dev,
 909                                           new_data + NET_SKB_PAD + pad,
 910                                           ring->rx_buf_size,
 911                                           DMA_FROM_DEVICE);
 912                 if (unlikely(dma_mapping_error(&netdev->dev, dma_addr))) {
 913                         skb_free_frag(new_data);
 914                         goto release_desc;
 915                 }
 916
 917                 /* receive data */
 918                 skb = build_skb(data, ring->frag_size);
 919                 if (unlikely(!skb)) {
 920                         skb_free_frag(new_data);
 921                         goto release_desc;
 922                 }
 923                 skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
 924
 925                 dma_unmap_single(&netdev->dev, trxd.rxd1,
 926                                  ring->rx_buf_size, DMA_FROM_DEVICE);
 927                 pktlen = RX_DMA_GET_PLEN0(trxd.rxd2);
 928                 skb->dev = netdev;
 929                 skb_put(skb, pktlen);
 930                 if (trxd.rxd4 & checksum_bit)
 931                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 932                 else
 933                         skb_checksum_none_assert(skb);
 934                 skb->protocol = eth_type_trans(skb, netdev);
 935
 936                 if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX &&
 937                     RX_DMA_VID(trxd.rxd3))
 938                         __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
 939                                                RX_DMA_VID(trxd.rxd3));
 940
 941 #ifdef CONFIG_NET_MEDIATEK_OFFLOAD
 942                 if (mtk_offload_check_rx(priv, skb, trxd.rxd4) == 0) {
 943 #endif
 944                         stats->rx_packets++;
 945                         stats->rx_bytes += pktlen;
 946
 947                         napi_gro_receive(napi, skb);
 948 #ifdef CONFIG_NET_MEDIATEK_OFFLOAD
 949                 } else {
 950                         dev_kfree_skb(skb);
 951                 }
 952 #endif
 953                 ring->rx_data[idx] = new_data;
 954                 rxd->rxd1 = (unsigned int)dma_addr;
 955
 956 release_desc:
 957                 if (priv->flags & FE_FLAG_RX_SG_DMA)
 958                         rxd->rxd2 = RX_DMA_PLEN0(ring->rx_buf_size);
 959                 else
 960                         rxd->rxd2 = RX_DMA_LSO;
 961
 962                 ring->rx_calc_idx = idx;
 963                 /* make sure that all changes to the dma ring are flushed before
 964                  * we continue
 965                  */
 966                 wmb();
 967                 fe_reg_w32(ring->rx_calc_idx, FE_REG_RX_CALC_IDX0);
 968                 done++;
 969         }
 970
 971         if (done < budget)
 972                 fe_reg_w32(rx_intr, FE_REG_FE_INT_STATUS);
 973
 974         return done;
 975 }
 976
 977 static int fe_poll_tx(struct fe_priv *priv, int budget, u32 tx_intr,
 978                       int *tx_again)
 979 {
 980         struct net_device *netdev = priv->netdev;
 981         struct device *dev = &netdev->dev;
 982         unsigned int bytes_compl = 0;
 983         struct sk_buff *skb;
 984         struct fe_tx_buf *tx_buf;
 985         int done = 0;
 986         u32 idx, hwidx;
 987         struct fe_tx_ring *ring = &priv->tx_ring;
 988
 989         idx = ring->tx_free_idx;
 990         hwidx = fe_reg_r32(FE_REG_TX_DTX_IDX0);
 991
 992         while ((idx != hwidx) && budget) {
 993                 tx_buf = &ring->tx_buf[idx];
 994                 skb = tx_buf->skb;
 995
 996                 if (!skb)
 997                         break;
 998
 999                 if (skb != (struct sk_buff *)DMA_DUMMY_DESC) {
1000                         bytes_compl += skb->len;
1001                         done++;
1002                         budget--;
1003                 }
1004                 fe_txd_unmap(dev, tx_buf);
1005                 idx = NEXT_TX_DESP_IDX(idx);
1006         }
1007         ring->tx_free_idx = idx;
1008
1009         if (idx == hwidx) {
1010                 /* read hw index again make sure no new tx packet */
1011                 hwidx = fe_reg_r32(FE_REG_TX_DTX_IDX0);
1012                 if (idx == hwidx)
1013                         fe_reg_w32(tx_intr, FE_REG_FE_INT_STATUS);
1014                 else
1015                         *tx_again = 1;
1016         } else {
1017                 *tx_again = 1;
1018         }
1019
1020         if (done) {
1021                 netdev_completed_queue(netdev, done, bytes_compl);
1022                 smp_mb();
1023                 if (unlikely(netif_queue_stopped(netdev) &&
1024                              (fe_empty_txd(ring) > ring->tx_thresh)))
1025                         netif_wake_queue(netdev);
1026         }
1027
1028         return done;
1029 }
1030
1031 static int fe_poll(struct napi_struct *napi, int budget)
1032 {
1033         struct fe_priv *priv = container_of(napi, struct fe_priv, rx_napi);
1034         struct fe_hw_stats *hwstat = priv->hw_stats;
1035         int tx_done, rx_done, tx_again;
1036         u32 status, fe_status, status_reg, mask;
1037         u32 tx_intr, rx_intr, status_intr;
1038
1039         status = fe_reg_r32(FE_REG_FE_INT_STATUS);
1040         fe_status = status;
1041         tx_intr = priv->soc->tx_int;
1042         rx_intr = priv->soc->rx_int;
1043         status_intr = priv->soc->status_int;
1044         tx_done = 0;
1045         rx_done = 0;
1046         tx_again = 0;
1047
1048         if (fe_reg_table[FE_REG_FE_INT_STATUS2]) {
1049                 fe_status = fe_reg_r32(FE_REG_FE_INT_STATUS2);
1050                 status_reg = FE_REG_FE_INT_STATUS2;
1051         } else {
1052                 status_reg = FE_REG_FE_INT_STATUS;
1053         }
1054
1055         if (status & tx_intr)
1056                 tx_done = fe_poll_tx(priv, budget, tx_intr, &tx_again);
1057
1058         if (status & rx_intr)
1059                 rx_done = fe_poll_rx(napi, budget, priv, rx_intr);
1060
1061         if (unlikely(fe_status & status_intr)) {
1062                 if (hwstat && spin_trylock(&hwstat->stats_lock)) {
1063                         fe_stats_update(priv);
1064                         spin_unlock(&hwstat->stats_lock);
1065                 }
1066                 fe_reg_w32(status_intr, status_reg);
1067         }
1068
1069         if (unlikely(netif_msg_intr(priv))) {
1070                 mask = fe_reg_r32(FE_REG_FE_INT_ENABLE);
1071                 netdev_info(priv->netdev,
1072                             "done tx %d, rx %d, intr 0x%08x/0x%x\n",
1073                             tx_done, rx_done, status, mask);
1074         }
1075
1076         if (!tx_again && (rx_done < budget)) {
1077                 status = fe_reg_r32(FE_REG_FE_INT_STATUS);
1078                 if (status & (tx_intr | rx_intr)) {
1079                         /* let napi poll again */
1080                         rx_done = budget;
1081                         goto poll_again;
1082                 }
1083
1084                 napi_complete_done(napi, rx_done);
1085                 fe_int_enable(tx_intr | rx_intr);
1086         } else {
1087                 rx_done = budget;
1088         }
1089
1090 poll_again:
1091         return rx_done;
1092 }
1093
1094 static void fe_tx_timeout(struct net_device *dev)
1095 {
1096         struct fe_priv *priv = netdev_priv(dev);
1097         struct fe_tx_ring *ring = &priv->tx_ring;
1098
1099         priv->netdev->stats.tx_errors++;
1100         netif_err(priv, tx_err, dev,
1101                   "transmit timed out\n");
1102         netif_info(priv, drv, dev, "dma_cfg:%08x\n",
1103                    fe_reg_r32(FE_REG_PDMA_GLO_CFG));
1104         netif_info(priv, drv, dev, "tx_ring=%d, "
1105                    "base=%08x, max=%u, ctx=%u, dtx=%u, fdx=%hu, next=%hu\n",
1106                    0, fe_reg_r32(FE_REG_TX_BASE_PTR0),
1107                    fe_reg_r32(FE_REG_TX_MAX_CNT0),
1108                    fe_reg_r32(FE_REG_TX_CTX_IDX0),
1109                    fe_reg_r32(FE_REG_TX_DTX_IDX0),
1110                    ring->tx_free_idx,
1111                    ring->tx_next_idx);
1112         netif_info(priv, drv, dev,
1113                    "rx_ring=%d, base=%08x, max=%u, calc=%u, drx=%u\n",
1114                    0, fe_reg_r32(FE_REG_RX_BASE_PTR0),
1115                    fe_reg_r32(FE_REG_RX_MAX_CNT0),
1116                    fe_reg_r32(FE_REG_RX_CALC_IDX0),
1117                    fe_reg_r32(FE_REG_RX_DRX_IDX0));
1118
1119         if (!test_and_set_bit(FE_FLAG_RESET_PENDING, priv->pending_flags))
1120                 schedule_work(&priv->pending_work);
1121 }
1122
1123 static irqreturn_t fe_handle_irq(int irq, void *dev)
1124 {
1125         struct fe_priv *priv = netdev_priv(dev);
1126         u32 status, int_mask;
1127
1128         status = fe_reg_r32(FE_REG_FE_INT_STATUS);
1129
1130         if (unlikely(!status))
1131                 return IRQ_NONE;
1132
1133         int_mask = (priv->soc->rx_int | priv->soc->tx_int);
1134         if (likely(status & int_mask)) {
1135                 if (likely(napi_schedule_prep(&priv->rx_napi))) {
1136                         fe_int_disable(int_mask);
1137                         __napi_schedule(&priv->rx_napi);
1138                 }
1139         } else {
1140                 fe_reg_w32(status, FE_REG_FE_INT_STATUS);
1141         }
1142
1143         return IRQ_HANDLED;
1144 }
1145
1146 #ifdef CONFIG_NET_POLL_CONTROLLER
1147 static void fe_poll_controller(struct net_device *dev)
1148 {
1149         struct fe_priv *priv = netdev_priv(dev);
1150         u32 int_mask = priv->soc->tx_int | priv->soc->rx_int;
1151
1152         fe_int_disable(int_mask);
1153         fe_handle_irq(dev->irq, dev);
1154         fe_int_enable(int_mask);
1155 }
1156 #endif
1157
1158 int fe_set_clock_cycle(struct fe_priv *priv)
1159 {
1160         unsigned long sysclk = priv->sysclk;
1161
1162         sysclk /= FE_US_CYC_CNT_DIVISOR;
1163         sysclk <<= FE_US_CYC_CNT_SHIFT;
1164
1165         fe_w32((fe_r32(FE_FE_GLO_CFG) &
1166                         ~(FE_US_CYC_CNT_MASK << FE_US_CYC_CNT_SHIFT)) |
1167                         sysclk,
1168                         FE_FE_GLO_CFG);
1169         return 0;
1170 }
1171
1172 void fe_fwd_config(struct fe_priv *priv)
1173 {
1174         u32 fwd_cfg;
1175
1176         fwd_cfg = fe_r32(FE_GDMA1_FWD_CFG);
1177
1178         /* disable jumbo frame */
1179         if (priv->flags & FE_FLAG_JUMBO_FRAME)
1180                 fwd_cfg &= ~FE_GDM1_JMB_EN;
1181
1182         /* set unicast/multicast/broadcast frame to cpu */
1183         fwd_cfg &= ~0xffff;
1184
1185         fe_w32(fwd_cfg, FE_GDMA1_FWD_CFG);
1186 }
1187
1188 static void fe_rxcsum_config(bool enable)
1189 {
1190         if (enable)
1191                 fe_w32(fe_r32(FE_GDMA1_FWD_CFG) | (FE_GDM1_ICS_EN |
1192                                         FE_GDM1_TCS_EN | FE_GDM1_UCS_EN),
1193                                 FE_GDMA1_FWD_CFG);
1194         else
1195                 fe_w32(fe_r32(FE_GDMA1_FWD_CFG) & ~(FE_GDM1_ICS_EN |
1196                                         FE_GDM1_TCS_EN | FE_GDM1_UCS_EN),
1197                                 FE_GDMA1_FWD_CFG);
1198 }
1199
1200 static void fe_txcsum_config(bool enable)
1201 {
1202         if (enable)
1203                 fe_w32(fe_r32(FE_CDMA_CSG_CFG) | (FE_ICS_GEN_EN |
1204                                         FE_TCS_GEN_EN | FE_UCS_GEN_EN),
1205                                 FE_CDMA_CSG_CFG);
1206         else
1207                 fe_w32(fe_r32(FE_CDMA_CSG_CFG) & ~(FE_ICS_GEN_EN |
1208                                         FE_TCS_GEN_EN | FE_UCS_GEN_EN),
1209                                 FE_CDMA_CSG_CFG);
1210 }
1211
1212 void fe_csum_config(struct fe_priv *priv)
1213 {
1214         struct net_device *dev = priv_netdev(priv);
1215
1216         fe_txcsum_config((dev->features & NETIF_F_IP_CSUM));
1217         fe_rxcsum_config((dev->features & NETIF_F_RXCSUM));
1218 }
1219
1220 static int fe_hw_init(struct net_device *dev)
1221 {
1222         struct fe_priv *priv = netdev_priv(dev);
1223         int i, err;
1224
1225         err = devm_request_irq(priv->dev, dev->irq, fe_handle_irq, 0,
1226                                dev_name(priv->dev), dev);
1227         if (err)
1228                 return err;
1229
1230         if (priv->soc->set_mac)
1231                 priv->soc->set_mac(priv, dev->dev_addr);
1232         else
1233                 fe_hw_set_macaddr(priv, dev->dev_addr);
1234
1235         /* disable delay interrupt */
1236         fe_reg_w32(0, FE_REG_DLY_INT_CFG);
1237
1238         fe_int_disable(priv->soc->tx_int | priv->soc->rx_int);
1239
1240         /* frame engine will push VLAN tag regarding to VIDX feild in Tx desc */
1241         if (fe_reg_table[FE_REG_FE_DMA_VID_BASE])
1242                 for (i = 0; i < 16; i += 2)
1243                         fe_w32(((i + 1) << 16) + i,
1244                                fe_reg_table[FE_REG_FE_DMA_VID_BASE] +
1245                                (i * 2));
1246
1247         if (priv->soc->fwd_config(priv))
1248                 netdev_err(dev, "unable to get clock\n");
1249
1250         if (fe_reg_table[FE_REG_FE_RST_GL]) {
1251                 fe_reg_w32(1, FE_REG_FE_RST_GL);
1252                 fe_reg_w32(0, FE_REG_FE_RST_GL);
1253         }
1254
1255         return 0;
1256 }
1257
1258 static int fe_open(struct net_device *dev)
1259 {
1260         struct fe_priv *priv = netdev_priv(dev);
1261         unsigned long flags;
1262         u32 val;
1263         int err;
1264
1265         err = fe_init_dma(priv);
1266         if (err) {
1267                 fe_free_dma(priv);
1268                 return err;
1269         }
1270
1271         spin_lock_irqsave(&priv->page_lock, flags);
1272
1273         val = FE_TX_WB_DDONE | FE_RX_DMA_EN | FE_TX_DMA_EN;
1274         if (priv->flags & FE_FLAG_RX_2B_OFFSET)
1275                 val |= FE_RX_2B_OFFSET;
1276         val |= priv->soc->pdma_glo_cfg;
1277         fe_reg_w32(val, FE_REG_PDMA_GLO_CFG);
1278
1279         spin_unlock_irqrestore(&priv->page_lock, flags);
1280
1281         if (priv->phy)
1282                 priv->phy->start(priv);
1283
1284         if (priv->soc->has_carrier && priv->soc->has_carrier(priv))
1285                 netif_carrier_on(dev);
1286
1287         napi_enable(&priv->rx_napi);
1288         fe_int_enable(priv->soc->tx_int | priv->soc->rx_int);
1289         netif_start_queue(dev);
1290 #ifdef CONFIG_NET_MEDIATEK_OFFLOAD
1291         mtk_ppe_probe(priv);
1292 #endif
1293
1294         return 0;
1295 }
1296
1297 static int fe_stop(struct net_device *dev)
1298 {
1299         struct fe_priv *priv = netdev_priv(dev);
1300         unsigned long flags;
1301         int i;
1302
1303         netif_tx_disable(dev);
1304         fe_int_disable(priv->soc->tx_int | priv->soc->rx_int);
1305         napi_disable(&priv->rx_napi);
1306
1307         if (priv->phy)
1308                 priv->phy->stop(priv);
1309
1310         spin_lock_irqsave(&priv->page_lock, flags);
1311
1312         fe_reg_w32(fe_reg_r32(FE_REG_PDMA_GLO_CFG) &
1313                      ~(FE_TX_WB_DDONE | FE_RX_DMA_EN | FE_TX_DMA_EN),
1314                      FE_REG_PDMA_GLO_CFG);
1315         spin_unlock_irqrestore(&priv->page_lock, flags);
1316
1317         /* wait dma stop */
1318         for (i = 0; i < 10; i++) {
1319                 if (fe_reg_r32(FE_REG_PDMA_GLO_CFG) &
1320                                 (FE_TX_DMA_BUSY | FE_RX_DMA_BUSY)) {
1321                         msleep(20);
1322                         continue;
1323                 }
1324                 break;
1325         }
1326
1327         fe_free_dma(priv);
1328
1329 #ifdef CONFIG_NET_MEDIATEK_OFFLOAD
1330         mtk_ppe_remove(priv);
1331 #endif
1332
1333         return 0;
1334 }
1335
1336 static int __init fe_init(struct net_device *dev)
1337 {
1338         struct fe_priv *priv = netdev_priv(dev);
1339         struct device_node *port;
1340         const char *mac_addr;
1341         int err;
1342
1343         priv->soc->reset_fe();
1344
1345         if (priv->soc->switch_init)
1346                 if (priv->soc->switch_init(priv)) {
1347                         netdev_err(dev, "failed to initialize switch core\n");
1348                         return -ENODEV;
1349                 }
1350
1351         mac_addr = of_get_mac_address(priv->dev->of_node);
1352         if (mac_addr)
1353                 ether_addr_copy(dev->dev_addr, mac_addr);
1354
1355         /* If the mac address is invalid, use random mac address  */
1356         if (!is_valid_ether_addr(dev->dev_addr)) {
1357                 random_ether_addr(dev->dev_addr);
1358                 dev_err(priv->dev, "generated random MAC address %pM\n",
1359                         dev->dev_addr);
1360         }
1361
1362         err = fe_mdio_init(priv);
1363         if (err)
1364                 return err;
1365
1366         if (priv->soc->port_init)
1367                 for_each_child_of_node(priv->dev->of_node, port)
1368                         if (of_device_is_compatible(port, "mediatek,eth-port") &&
1369                             of_device_is_available(port))
1370                                 priv->soc->port_init(priv, port);
1371
1372         if (priv->phy) {
1373                 err = priv->phy->connect(priv);
1374                 if (err)
1375                         goto err_phy_disconnect;
1376         }
1377
1378         err = fe_hw_init(dev);
1379         if (err)
1380                 goto err_phy_disconnect;
1381
1382         if ((priv->flags & FE_FLAG_HAS_SWITCH) && priv->soc->switch_config)
1383                 priv->soc->switch_config(priv);
1384
1385         return 0;
1386
1387 err_phy_disconnect:
1388         if (priv->phy)
1389                 priv->phy->disconnect(priv);
1390         fe_mdio_cleanup(priv);
1391
1392         return err;
1393 }
1394
1395 static void fe_uninit(struct net_device *dev)
1396 {
1397         struct fe_priv *priv = netdev_priv(dev);
1398
1399         if (priv->phy)
1400                 priv->phy->disconnect(priv);
1401         fe_mdio_cleanup(priv);
1402
1403         fe_reg_w32(0, FE_REG_FE_INT_ENABLE);
1404         free_irq(dev->irq, dev);
1405 }
1406
1407 static int fe_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1408 {
1409         struct fe_priv *priv = netdev_priv(dev);
1410
1411         if (!priv->phy_dev)
1412                 return -ENODEV;
1413
1414
1415         return phy_mii_ioctl(priv->phy_dev, ifr, cmd);
1416 }
1417
1418 static int fe_change_mtu(struct net_device *dev, int new_mtu)
1419 {
1420         struct fe_priv *priv = netdev_priv(dev);
1421         int frag_size, old_mtu;
1422         u32 fwd_cfg;
1423
1424         old_mtu = dev->mtu;
1425         dev->mtu = new_mtu;
1426
1427         if (!(priv->flags & FE_FLAG_JUMBO_FRAME))
1428                 return 0;
1429
1430         /* return early if the buffer sizes will not change */
1431         if (old_mtu <= ETH_DATA_LEN && new_mtu <= ETH_DATA_LEN)
1432                 return 0;
1433         if (old_mtu > ETH_DATA_LEN && new_mtu > ETH_DATA_LEN)
1434                 return 0;
1435
1436         if (new_mtu <= ETH_DATA_LEN)
1437                 priv->rx_ring.frag_size = fe_max_frag_size(ETH_DATA_LEN);
1438         else
1439                 priv->rx_ring.frag_size = PAGE_SIZE;
1440         priv->rx_ring.rx_buf_size = fe_max_buf_size(priv->rx_ring.frag_size);
1441
1442         if (!netif_running(dev))
1443                 return 0;
1444
1445         fe_stop(dev);
1446         if (!IS_ENABLED(CONFIG_SOC_MT7621)) {
1447                 fwd_cfg = fe_r32(FE_GDMA1_FWD_CFG);
1448                 if (new_mtu <= ETH_DATA_LEN) {
1449                         fwd_cfg &= ~FE_GDM1_JMB_EN;
1450                 } else {
1451                         frag_size = fe_max_frag_size(new_mtu);
1452                         fwd_cfg &= ~(FE_GDM1_JMB_LEN_MASK << FE_GDM1_JMB_LEN_SHIFT);
1453                         fwd_cfg |= (DIV_ROUND_UP(frag_size, 1024) <<
1454                         FE_GDM1_JMB_LEN_SHIFT) | FE_GDM1_JMB_EN;
1455                 }
1456                 fe_w32(fwd_cfg, FE_GDMA1_FWD_CFG);
1457         }
1458
1459         return fe_open(dev);
1460 }
1461
1462 #ifdef CONFIG_NET_MEDIATEK_OFFLOAD
1463 static int
1464 fe_flow_offload(enum flow_offload_type type, struct flow_offload *flow,
1465                 struct flow_offload_hw_path *src,
1466                 struct flow_offload_hw_path *dest)
1467 {
1468         struct fe_priv *priv;
1469
1470         if (src->dev != dest->dev)
1471                 return -EINVAL;
1472
1473         priv = netdev_priv(src->dev);
1474
1475         return mtk_flow_offload(priv, type, flow, src, dest);
1476 }
1477 #endif
1478
1479 static const struct net_device_ops fe_netdev_ops = {
1480         .ndo_init               = fe_init,
1481         .ndo_uninit             = fe_uninit,
1482         .ndo_open               = fe_open,
1483         .ndo_stop               = fe_stop,
1484         .ndo_start_xmit         = fe_start_xmit,
1485         .ndo_set_mac_address    = fe_set_mac_address,
1486         .ndo_validate_addr      = eth_validate_addr,
1487         .ndo_do_ioctl           = fe_do_ioctl,
1488         .ndo_change_mtu         = fe_change_mtu,
1489         .ndo_tx_timeout         = fe_tx_timeout,
1490         .ndo_get_stats64        = fe_get_stats64,
1491         .ndo_vlan_rx_add_vid    = fe_vlan_rx_add_vid,
1492         .ndo_vlan_rx_kill_vid   = fe_vlan_rx_kill_vid,
1493 #ifdef CONFIG_NET_POLL_CONTROLLER
1494         .ndo_poll_controller    = fe_poll_controller,
1495 #endif
1496 #ifdef CONFIG_NET_MEDIATEK_OFFLOAD
1497         .ndo_flow_offload       = fe_flow_offload,
1498 #endif
1499 };
1500
1501 static void fe_reset_pending(struct fe_priv *priv)
1502 {
1503         struct net_device *dev = priv->netdev;
1504         int err;
1505
1506         rtnl_lock();
1507         fe_stop(dev);
1508
1509         err = fe_open(dev);
1510         if (err) {
1511                 netif_alert(priv, ifup, dev,
1512                             "Driver up/down cycle failed, closing device.\n");
1513                 dev_close(dev);
1514         }
1515         rtnl_unlock();
1516 }
1517
1518 static const struct fe_work_t fe_work[] = {
1519         {FE_FLAG_RESET_PENDING, fe_reset_pending},
1520 };
1521
1522 static void fe_pending_work(struct work_struct *work)
1523 {
1524         struct fe_priv *priv = container_of(work, struct fe_priv, pending_work);
1525         int i;
1526         bool pending;
1527
1528         for (i = 0; i < ARRAY_SIZE(fe_work); i++) {
1529                 pending = test_and_clear_bit(fe_work[i].bitnr,
1530                                              priv->pending_flags);
1531                 if (pending)
1532                         fe_work[i].action(priv);
1533         }
1534 }
1535
1536 static int fe_probe(struct platform_device *pdev)
1537 {
1538         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1539         const struct of_device_id *match;
1540         struct fe_soc_data *soc;
1541         struct net_device *netdev;
1542         struct fe_priv *priv;
1543         struct clk *sysclk;
1544         int err, napi_weight;
1545
1546         device_reset(&pdev->dev);
1547
1548         match = of_match_device(of_fe_match, &pdev->dev);
1549         soc = (struct fe_soc_data *)match->data;
1550
1551         if (soc->reg_table)
1552                 fe_reg_table = soc->reg_table;
1553         else
1554                 soc->reg_table = fe_reg_table;
1555
1556         fe_base = devm_ioremap_resource(&pdev->dev, res);
1557         if (IS_ERR(fe_base)) {
1558                 err = -EADDRNOTAVAIL;
1559                 goto err_out;
1560         }
1561
1562         netdev = alloc_etherdev(sizeof(*priv));
1563         if (!netdev) {
1564                 dev_err(&pdev->dev, "alloc_etherdev failed\n");
1565                 err = -ENOMEM;
1566                 goto err_iounmap;
1567         }
1568
1569         SET_NETDEV_DEV(netdev, &pdev->dev);
1570         netdev->netdev_ops = &fe_netdev_ops;
1571         netdev->base_addr = (unsigned long)fe_base;
1572
1573         netdev->irq = platform_get_irq(pdev, 0);
1574         if (netdev->irq < 0) {
1575                 dev_err(&pdev->dev, "no IRQ resource found\n");
1576                 err = -ENXIO;
1577                 goto err_free_dev;
1578         }
1579
1580         if (soc->init_data)
1581                 soc->init_data(soc, netdev);
1582         netdev->vlan_features = netdev->hw_features &
1583                                 ~(NETIF_F_HW_VLAN_CTAG_TX |
1584                                   NETIF_F_HW_VLAN_CTAG_RX);
1585         netdev->features |= netdev->hw_features;
1586
1587         if (IS_ENABLED(CONFIG_SOC_MT7621))
1588                 netdev->max_mtu = 2048;
1589
1590         /* fake rx vlan filter func. to support tx vlan offload func */
1591         if (fe_reg_table[FE_REG_FE_DMA_VID_BASE])
1592                 netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1593
1594         priv = netdev_priv(netdev);
1595         spin_lock_init(&priv->page_lock);
1596         if (fe_reg_table[FE_REG_FE_COUNTER_BASE]) {
1597                 priv->hw_stats = kzalloc(sizeof(*priv->hw_stats), GFP_KERNEL);
1598                 if (!priv->hw_stats) {
1599                         err = -ENOMEM;
1600                         goto err_free_dev;
1601                 }
1602                 spin_lock_init(&priv->hw_stats->stats_lock);
1603         }
1604
1605         sysclk = devm_clk_get(&pdev->dev, NULL);
1606         if (!IS_ERR(sysclk)) {
1607                 priv->sysclk = clk_get_rate(sysclk);
1608         } else if ((priv->flags & FE_FLAG_CALIBRATE_CLK)) {
1609                 dev_err(&pdev->dev, "this soc needs a clk for calibration\n");
1610                 err = -ENXIO;
1611                 goto err_free_dev;
1612         }
1613
1614         priv->switch_np = of_parse_phandle(pdev->dev.of_node, "mediatek,switch", 0);
1615         if ((priv->flags & FE_FLAG_HAS_SWITCH) && !priv->switch_np) {
1616                 dev_err(&pdev->dev, "failed to read switch phandle\n");
1617                 err = -ENODEV;
1618                 goto err_free_dev;
1619         }
1620
1621         priv->netdev = netdev;
1622         priv->dev = &pdev->dev;
1623         priv->soc = soc;
1624         priv->msg_enable = netif_msg_init(fe_msg_level, FE_DEFAULT_MSG_ENABLE);
1625         priv->rx_ring.frag_size = fe_max_frag_size(ETH_DATA_LEN);
1626         priv->rx_ring.rx_buf_size = fe_max_buf_size(priv->rx_ring.frag_size);
1627         priv->tx_ring.tx_ring_size = NUM_DMA_DESC;
1628         priv->rx_ring.rx_ring_size = NUM_DMA_DESC;
1629         INIT_WORK(&priv->pending_work, fe_pending_work);
1630         u64_stats_init(&priv->hw_stats->syncp);
1631
1632         napi_weight = 16;
1633         if (priv->flags & FE_FLAG_NAPI_WEIGHT) {
1634                 napi_weight *= 4;
1635                 priv->tx_ring.tx_ring_size *= 4;
1636                 priv->rx_ring.rx_ring_size *= 4;
1637         }
1638         netif_napi_add(netdev, &priv->rx_napi, fe_poll, napi_weight);
1639         fe_set_ethtool_ops(netdev);
1640
1641         err = register_netdev(netdev);
1642         if (err) {
1643                 dev_err(&pdev->dev, "error bringing up device\n");
1644                 goto err_free_dev;
1645         }
1646
1647         platform_set_drvdata(pdev, netdev);
1648
1649         netif_info(priv, probe, netdev, "mediatek frame engine at 0x%08lx, irq %d\n",
1650                    netdev->base_addr, netdev->irq);
1651
1652         return 0;
1653
1654 err_free_dev:
1655         free_netdev(netdev);
1656 err_iounmap:
1657         devm_iounmap(&pdev->dev, fe_base);
1658 err_out:
1659         return err;
1660 }
1661
1662 static int fe_remove(struct platform_device *pdev)
1663 {
1664         struct net_device *dev = platform_get_drvdata(pdev);
1665         struct fe_priv *priv = netdev_priv(dev);
1666
1667         netif_napi_del(&priv->rx_napi);
1668         kfree(priv->hw_stats);
1669
1670         cancel_work_sync(&priv->pending_work);
1671
1672         unregister_netdev(dev);
1673         free_netdev(dev);
1674         platform_set_drvdata(pdev, NULL);
1675
1676         return 0;
1677 }
1678
1679 static struct platform_driver fe_driver = {
1680         .probe = fe_probe,
1681         .remove = fe_remove,
1682         .driver = {
1683                 .name = "mtk_soc_eth",
1684                 .owner = THIS_MODULE,
1685                 .of_match_table = of_fe_match,
1686         },
1687 };
1688
1689 module_platform_driver(fe_driver);
1690
1691 MODULE_LICENSE("GPL");
1692 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
1693 MODULE_DESCRIPTION("Ethernet driver for Ralink SoC");
1694 MODULE_VERSION(MTK_FE_DRV_VERSION);