target/linux/ramips/files/drivers/net/ethernet/ralink/ralink_soc_eth.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; version 2 of the License
   5  *
   6  *   This program is distributed in the hope that it will be useful,
   7  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *   GNU General Public License for more details.
  10  *
  11  *   You should have received a copy of the GNU General Public License
  12  *   along with this program; if not, write to the Free Software
  13  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  14  *
  15  *   Copyright (C) 2009-2013 John Crispin <blogic@openwrt.org>
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/types.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/init.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/etherdevice.h>
  25 #include <linux/ethtool.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/of_device.h>
  28 #include <linux/clk.h>
  29 #include <linux/of_net.h>
  30 #include <linux/of_mdio.h>
  31 #include <linux/if_vlan.h>
  32 #include <linux/reset.h>
  33 #include <linux/tcp.h>
  34 #include <linux/io.h>
  35
  36 #include <asm/mach-ralink/ralink_regs.h>
  37
  38 #include "ralink_soc_eth.h"
  39 #include "esw_rt3052.h"
  40 #include "mdio.h"
  41 #include "ralink_ethtool.h"
  42
  43 #define TX_TIMEOUT              (2 * HZ)
  44 #define MAX_RX_LENGTH           1536
  45 #define FE_RX_OFFSET            (NET_SKB_PAD + NET_IP_ALIGN)
  46 #define FE_RX_HLEN              (FE_RX_OFFSET + VLAN_ETH_HLEN + VLAN_HLEN + \
  47                 ETH_FCS_LEN)
  48 #define DMA_DUMMY_DESC          0xffffffff
  49 #define FE_DEFAULT_MSG_ENABLE    \
  50         (NETIF_MSG_DRV      | \
  51          NETIF_MSG_PROBE    | \
  52          NETIF_MSG_LINK     | \
  53          NETIF_MSG_TIMER    | \
  54          NETIF_MSG_IFDOWN   | \
  55          NETIF_MSG_IFUP     | \
  56          NETIF_MSG_RX_ERR   | \
  57          NETIF_MSG_TX_ERR)
  58
  59 #define TX_DMA_DESP2_DEF        (TX_DMA_LS0 | TX_DMA_DONE)
  60 #define TX_DMA_DESP4_DEF        (TX_DMA_QN(3) | TX_DMA_PN(1))
  61 #define NEXT_TX_DESP_IDX(X)     (((X) + 1) & (NUM_DMA_DESC - 1))
  62 #define NEXT_RX_DESP_IDX(X)     (((X) + 1) & (NUM_DMA_DESC - 1))
  63
  64 static int fe_msg_level = -1;
  65 module_param_named(msg_level, fe_msg_level, int, 0);
  66 MODULE_PARM_DESC(msg_level, "Message level (-1=defaults,0=none,...,16=all)");
  67
  68 static const u32 fe_reg_table_default[FE_REG_COUNT] = {
  69         [FE_REG_PDMA_GLO_CFG] = FE_PDMA_GLO_CFG,
  70         [FE_REG_PDMA_RST_CFG] = FE_PDMA_RST_CFG,
  71         [FE_REG_DLY_INT_CFG] = FE_DLY_INT_CFG,
  72         [FE_REG_TX_BASE_PTR0] = FE_TX_BASE_PTR0,
  73         [FE_REG_TX_MAX_CNT0] = FE_TX_MAX_CNT0,
  74         [FE_REG_TX_CTX_IDX0] = FE_TX_CTX_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_FE_INT_ENABLE] = FE_FE_INT_ENABLE,
  79         [FE_REG_FE_INT_STATUS] = FE_FE_INT_STATUS,
  80         [FE_REG_FE_DMA_VID_BASE] = FE_DMA_VID0,
  81         [FE_REG_FE_COUNTER_BASE] = FE_GDMA1_TX_GBCNT,
  82         [FE_REG_FE_RST_GL] = FE_FE_RST_GL,
  83 };
  84
  85 static const u32 *fe_reg_table = fe_reg_table_default;
  86
  87 static void __iomem *fe_base = 0;
  88
  89 void fe_w32(u32 val, unsigned reg)
  90 {
  91         __raw_writel(val, fe_base + reg);
  92 }
  93
  94 u32 fe_r32(unsigned reg)
  95 {
  96         return __raw_readl(fe_base + reg);
  97 }
  98
  99 void fe_reg_w32(u32 val, enum fe_reg reg)
 100 {
 101         fe_w32(val, fe_reg_table[reg]);
 102 }
 103
 104 u32 fe_reg_r32(enum fe_reg reg)
 105 {
 106         return fe_r32(fe_reg_table[reg]);
 107 }
 108
 109 static inline void fe_int_disable(u32 mask)
 110 {
 111         fe_reg_w32(fe_reg_r32(FE_REG_FE_INT_ENABLE) & ~mask,
 112                      FE_REG_FE_INT_ENABLE);
 113         /* flush write */
 114         fe_reg_r32(FE_REG_FE_INT_ENABLE);
 115 }
 116
 117 static inline void fe_int_enable(u32 mask)
 118 {
 119         fe_reg_w32(fe_reg_r32(FE_REG_FE_INT_ENABLE) | mask,
 120                      FE_REG_FE_INT_ENABLE);
 121         /* flush write */
 122         fe_reg_r32(FE_REG_FE_INT_ENABLE);
 123 }
 124
 125 static inline void fe_hw_set_macaddr(struct fe_priv *priv, unsigned char *mac)
 126 {
 127         unsigned long flags;
 128
 129         spin_lock_irqsave(&priv->page_lock, flags);
 130         fe_w32((mac[0] << 8) | mac[1], FE_GDMA1_MAC_ADRH);
 131         fe_w32((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
 132                      FE_GDMA1_MAC_ADRL);
 133         spin_unlock_irqrestore(&priv->page_lock, flags);
 134 }
 135
 136 static int fe_set_mac_address(struct net_device *dev, void *p)
 137 {
 138         int ret = eth_mac_addr(dev, p);
 139
 140         if (!ret) {
 141                 struct fe_priv *priv = netdev_priv(dev);
 142
 143                 if (priv->soc->set_mac)
 144                         priv->soc->set_mac(priv, dev->dev_addr);
 145                 else
 146                         fe_hw_set_macaddr(priv, p);
 147         }
 148
 149         return ret;
 150 }
 151
 152 static inline int fe_max_frag_size(int mtu)
 153 {
 154         return SKB_DATA_ALIGN(FE_RX_HLEN + mtu) +
 155                 SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 156 }
 157
 158 static inline int fe_max_buf_size(int frag_size)
 159 {
 160         return frag_size - FE_RX_HLEN -
 161                 SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 162 }
 163
 164 static void fe_clean_rx(struct fe_priv *priv)
 165 {
 166         int i;
 167
 168         if (priv->rx_data) {
 169                 for (i = 0; i < NUM_DMA_DESC; i++)
 170                         if (priv->rx_data[i]) {
 171                                 if (priv->rx_dma && priv->rx_dma[i].rxd1)
 172                                         dma_unmap_single(&priv->netdev->dev,
 173                                                         priv->rx_dma[i].rxd1,
 174                                                         priv->rx_buf_size,
 175                                                         DMA_FROM_DEVICE);
 176                                 put_page(virt_to_head_page(priv->rx_data[i]));
 177                         }
 178
 179                 kfree(priv->rx_data);
 180                 priv->rx_data = NULL;
 181         }
 182
 183         if (priv->rx_dma) {
 184                 dma_free_coherent(&priv->netdev->dev,
 185                                 NUM_DMA_DESC * sizeof(*priv->rx_dma),
 186                                 priv->rx_dma,
 187                                 priv->rx_phys);
 188                 priv->rx_dma = NULL;
 189         }
 190 }
 191
 192 static int fe_alloc_rx(struct fe_priv *priv)
 193 {
 194         struct net_device *netdev = priv->netdev;
 195         int i;
 196
 197         priv->rx_data = kcalloc(NUM_DMA_DESC, sizeof(*priv->rx_data),
 198                         GFP_KERNEL);
 199         if (!priv->rx_data)
 200                 goto no_rx_mem;
 201
 202         for (i = 0; i < NUM_DMA_DESC; i++) {
 203                 priv->rx_data[i] = netdev_alloc_frag(priv->frag_size);
 204                 if (!priv->rx_data[i])
 205                         goto no_rx_mem;
 206         }
 207
 208         priv->rx_dma = dma_alloc_coherent(&netdev->dev,
 209                         NUM_DMA_DESC * sizeof(*priv->rx_dma),
 210                         &priv->rx_phys,
 211                         GFP_ATOMIC | __GFP_ZERO);
 212         if (!priv->rx_dma)
 213                 goto no_rx_mem;
 214
 215         for (i = 0; i < NUM_DMA_DESC; i++) {
 216                 dma_addr_t dma_addr = dma_map_single(&netdev->dev,
 217                                 priv->rx_data[i] + FE_RX_OFFSET,
 218                                 priv->rx_buf_size,
 219                                 DMA_FROM_DEVICE);
 220                 if (unlikely(dma_mapping_error(&netdev->dev, dma_addr)))
 221                         goto no_rx_mem;
 222                 priv->rx_dma[i].rxd1 = (unsigned int) dma_addr;
 223
 224                 if (priv->soc->rx_dma)
 225                         priv->soc->rx_dma(priv, i, priv->rx_buf_size);
 226                 else
 227                         priv->rx_dma[i].rxd2 = RX_DMA_LSO;
 228         }
 229         wmb();
 230
 231         fe_reg_w32(priv->rx_phys, FE_REG_RX_BASE_PTR0);
 232         fe_reg_w32(NUM_DMA_DESC, FE_REG_RX_MAX_CNT0);
 233         fe_reg_w32((NUM_DMA_DESC - 1), FE_REG_RX_CALC_IDX0);
 234         fe_reg_w32(FE_PST_DRX_IDX0, FE_REG_PDMA_RST_CFG);
 235
 236         return 0;
 237
 238 no_rx_mem:
 239         return -ENOMEM;
 240 }
 241
 242 static void fe_clean_tx(struct fe_priv *priv)
 243 {
 244         int i;
 245
 246         if (priv->tx_skb) {
 247                 for (i = 0; i < NUM_DMA_DESC; i++) {
 248                         if (priv->tx_skb[i])
 249                                 dev_kfree_skb_any(priv->tx_skb[i]);
 250                 }
 251                 kfree(priv->tx_skb);
 252                 priv->tx_skb = NULL;
 253         }
 254
 255         if (priv->tx_dma) {
 256                 dma_free_coherent(&priv->netdev->dev,
 257                                 NUM_DMA_DESC * sizeof(*priv->tx_dma),
 258                                 priv->tx_dma,
 259                                 priv->tx_phys);
 260                 priv->tx_dma = NULL;
 261         }
 262 }
 263
 264 static int fe_alloc_tx(struct fe_priv *priv)
 265 {
 266         int i;
 267
 268         priv->tx_free_idx = 0;
 269
 270         priv->tx_skb = kcalloc(NUM_DMA_DESC, sizeof(*priv->tx_skb),
 271                         GFP_KERNEL);
 272         if (!priv->tx_skb)
 273                 goto no_tx_mem;
 274
 275         priv->tx_dma = dma_alloc_coherent(&priv->netdev->dev,
 276                         NUM_DMA_DESC * sizeof(*priv->tx_dma),
 277                         &priv->tx_phys,
 278                         GFP_ATOMIC | __GFP_ZERO);
 279         if (!priv->tx_dma)
 280                 goto no_tx_mem;
 281
 282         for (i = 0; i < NUM_DMA_DESC; i++) {
 283                 if (priv->soc->tx_dma) {
 284                         priv->soc->tx_dma(priv, i, NULL);
 285                         continue;
 286                 }
 287                 priv->tx_dma[i].txd2 = TX_DMA_DESP2_DEF;
 288         }
 289         wmb();
 290
 291         fe_reg_w32(priv->tx_phys, FE_REG_TX_BASE_PTR0);
 292         fe_reg_w32(NUM_DMA_DESC, FE_REG_TX_MAX_CNT0);
 293         fe_reg_w32(0, FE_REG_TX_CTX_IDX0);
 294         fe_reg_w32(FE_PST_DTX_IDX0, FE_REG_PDMA_RST_CFG);
 295
 296         return 0;
 297
 298 no_tx_mem:
 299         return -ENOMEM;
 300 }
 301
 302 static int fe_init_dma(struct fe_priv *priv)
 303 {
 304         int err;
 305
 306         err = fe_alloc_tx(priv);
 307         if (err)
 308                 return err;
 309
 310         err = fe_alloc_rx(priv);
 311         if (err)
 312                 return err;
 313
 314         return 0;
 315 }
 316
 317 static void fe_free_dma(struct fe_priv *priv)
 318 {
 319         fe_clean_tx(priv);
 320         fe_clean_rx(priv);
 321
 322         netdev_reset_queue(priv->netdev);
 323 }
 324
 325 static inline void txd_unmap_single(struct device *dev, struct fe_tx_dma *txd)
 326 {
 327         if (txd->txd1 && TX_DMA_GET_PLEN0(txd->txd2))
 328                 dma_unmap_single(dev, txd->txd1,
 329                                 TX_DMA_GET_PLEN0(txd->txd2),
 330                                 DMA_TO_DEVICE);
 331 }
 332
 333 static inline void txd_unmap_page0(struct device *dev, struct fe_tx_dma *txd)
 334 {
 335         if (txd->txd1 && TX_DMA_GET_PLEN0(txd->txd2))
 336                 dma_unmap_page(dev, txd->txd1,
 337                                 TX_DMA_GET_PLEN0(txd->txd2),
 338                                 DMA_TO_DEVICE);
 339 }
 340
 341 static inline void txd_unmap_page1(struct device *dev, struct fe_tx_dma *txd)
 342 {
 343         if (txd->txd3 && TX_DMA_GET_PLEN1(txd->txd2))
 344                 dma_unmap_page(dev, txd->txd3,
 345                                 TX_DMA_GET_PLEN1(txd->txd2),
 346                                 DMA_TO_DEVICE);
 347 }
 348
 349 void fe_stats_update(struct fe_priv *priv)
 350 {
 351         struct fe_hw_stats *hwstats = priv->hw_stats;
 352         unsigned int base = fe_reg_table[FE_REG_FE_COUNTER_BASE];
 353
 354         u64_stats_update_begin(&hwstats->syncp);
 355
 356         if (IS_ENABLED(CONFIG_SOC_MT7621)) {
 357                 hwstats->rx_bytes                       += fe_r32(base);
 358                 hwstats->rx_packets                     += fe_r32(base + 0x08);
 359                 hwstats->rx_overflow                    += fe_r32(base + 0x10);
 360                 hwstats->rx_fcs_errors                  += fe_r32(base + 0x14);
 361                 hwstats->rx_short_errors                += fe_r32(base + 0x18);
 362                 hwstats->rx_long_errors                 += fe_r32(base + 0x1c);
 363                 hwstats->rx_checksum_errors             += fe_r32(base + 0x20);
 364                 hwstats->rx_flow_control_packets        += fe_r32(base + 0x24);
 365                 hwstats->tx_skip                        += fe_r32(base + 0x28);
 366                 hwstats->tx_collisions                  += fe_r32(base + 0x2c);
 367                 hwstats->tx_bytes                       += fe_r32(base + 0x30);
 368                 hwstats->tx_packets                     += fe_r32(base + 0x38);
 369         } else {
 370                 hwstats->tx_bytes                       += fe_r32(base);
 371                 hwstats->tx_packets                     += fe_r32(base + 0x04);
 372                 hwstats->tx_skip                        += fe_r32(base + 0x08);
 373                 hwstats->tx_collisions                  += fe_r32(base + 0x0c);
 374                 hwstats->rx_bytes                       += fe_r32(base + 0x20);
 375                 hwstats->rx_packets                     += fe_r32(base + 0x24);
 376                 hwstats->rx_overflow                    += fe_r32(base + 0x28);
 377                 hwstats->rx_fcs_errors                  += fe_r32(base + 0x2c);
 378                 hwstats->rx_short_errors                += fe_r32(base + 0x30);
 379                 hwstats->rx_long_errors                 += fe_r32(base + 0x34);
 380                 hwstats->rx_checksum_errors             += fe_r32(base + 0x38);
 381                 hwstats->rx_flow_control_packets        += fe_r32(base + 0x3c);
 382         }
 383
 384         u64_stats_update_end(&hwstats->syncp);
 385 }
 386
 387 static struct rtnl_link_stats64 *fe_get_stats64(struct net_device *dev,
 388                 struct rtnl_link_stats64 *storage)
 389 {
 390         struct fe_priv *priv = netdev_priv(dev);
 391         struct fe_hw_stats *hwstats = priv->hw_stats;
 392         unsigned int base = fe_reg_table[FE_REG_FE_COUNTER_BASE];
 393         unsigned int start;
 394
 395         if (!base) {
 396                 netdev_stats_to_stats64(storage, &dev->stats);
 397                 return storage;
 398         }
 399
 400         if (netif_running(dev) && netif_device_present(dev)) {
 401                 if (spin_trylock(&hwstats->stats_lock)) {
 402                         fe_stats_update(priv);
 403                         spin_unlock(&hwstats->stats_lock);
 404                 }
 405         }
 406
 407         do {
 408                 start = u64_stats_fetch_begin_bh(&hwstats->syncp);
 409                 storage->rx_packets = hwstats->rx_packets;
 410                 storage->tx_packets = hwstats->tx_packets;
 411                 storage->rx_bytes = hwstats->rx_bytes;
 412                 storage->tx_bytes = hwstats->tx_bytes;
 413                 storage->collisions = hwstats->tx_collisions;
 414                 storage->rx_length_errors = hwstats->rx_short_errors +
 415                         hwstats->rx_long_errors;
 416                 storage->rx_over_errors = hwstats->rx_overflow;
 417                 storage->rx_crc_errors = hwstats->rx_fcs_errors;
 418                 storage->rx_errors = hwstats->rx_checksum_errors;
 419                 storage->tx_aborted_errors = hwstats->tx_skip;
 420         } while (u64_stats_fetch_retry_bh(&hwstats->syncp, start));
 421
 422         storage->tx_errors = priv->netdev->stats.tx_errors;
 423         storage->rx_dropped = priv->netdev->stats.rx_dropped;
 424         storage->tx_dropped = priv->netdev->stats.tx_dropped;
 425
 426         return storage;
 427 }
 428
 429 static int fe_vlan_rx_add_vid(struct net_device *dev,
 430                 __be16 proto, u16 vid)
 431 {
 432         struct fe_priv *priv = netdev_priv(dev);
 433         u32 idx = (vid & 0xf);
 434         u32 vlan_cfg;
 435
 436         if (!((fe_reg_table[FE_REG_FE_DMA_VID_BASE]) &&
 437                         (dev->features | NETIF_F_HW_VLAN_CTAG_TX)))
 438                 return 0;
 439
 440         if (test_bit(idx, &priv->vlan_map)) {
 441                 netdev_warn(dev, "disable tx vlan offload\n");
 442                 dev->wanted_features &= ~NETIF_F_HW_VLAN_CTAG_TX;
 443                 netdev_update_features(dev);
 444         } else {
 445                 vlan_cfg = fe_r32(fe_reg_table[FE_REG_FE_DMA_VID_BASE] +
 446                                 ((idx >> 1) << 2));
 447                 if (idx & 0x1) {
 448                         vlan_cfg &= 0xffff;
 449                         vlan_cfg |= (vid << 16);
 450                 } else {
 451                         vlan_cfg &= 0xffff0000;
 452                         vlan_cfg |= vid;
 453                 }
 454                 fe_w32(vlan_cfg, fe_reg_table[FE_REG_FE_DMA_VID_BASE] +
 455                                 ((idx >> 1) << 2));
 456                 set_bit(idx, &priv->vlan_map);
 457         }
 458
 459         return 0;
 460 }
 461
 462 static int fe_vlan_rx_kill_vid(struct net_device *dev,
 463                 __be16 proto, u16 vid)
 464 {
 465         struct fe_priv *priv = netdev_priv(dev);
 466         u32 idx = (vid & 0xf);
 467
 468         if (!((fe_reg_table[FE_REG_FE_DMA_VID_BASE]) &&
 469                                 (dev->features | NETIF_F_HW_VLAN_CTAG_TX)))
 470                 return 0;
 471
 472         clear_bit(idx, &priv->vlan_map);
 473
 474         return 0;
 475 }
 476
 477 static int fe_tx_map_dma(struct sk_buff *skb, struct net_device *dev,
 478                 int idx)
 479 {
 480         struct fe_priv *priv = netdev_priv(dev);
 481         struct skb_frag_struct *frag;
 482         struct fe_tx_dma *txd;
 483         dma_addr_t mapped_addr;
 484         unsigned int nr_frags;
 485         u32 def_txd4, txd2;
 486         int i, j, unmap_idx, tx_num;
 487
 488         txd = &priv->tx_dma[idx];
 489         nr_frags = skb_shinfo(skb)->nr_frags;
 490         tx_num = 1 + (nr_frags >> 1);
 491
 492         /* init tx descriptor */
 493         if (priv->soc->tx_dma)
 494                 priv->soc->tx_dma(priv, idx, skb);
 495         else
 496                 txd->txd4 = TX_DMA_DESP4_DEF;
 497         def_txd4 = txd->txd4;
 498
 499         /* use dma_unmap_single to free it */
 500         txd->txd4 |= priv->soc->tx_udf_bit;
 501
 502         /* TX Checksum offload */
 503         if (skb->ip_summed == CHECKSUM_PARTIAL)
 504                 txd->txd4 |= TX_DMA_CHKSUM;
 505
 506         /* VLAN header offload */
 507         if (vlan_tx_tag_present(skb)) {
 508                 if (IS_ENABLED(CONFIG_SOC_MT7621))
 509                         txd->txd4 |= TX_DMA_INS_VLAN_MT7621 | vlan_tx_tag_get(skb);
 510                 else
 511                         txd->txd4 |= TX_DMA_INS_VLAN |
 512                                 ((vlan_tx_tag_get(skb) >> VLAN_PRIO_SHIFT) << 4) |
 513                                 (vlan_tx_tag_get(skb) & 0xF);
 514         }
 515
 516         /* TSO: fill MSS info in tcp checksum field */
 517         if (skb_is_gso(skb)) {
 518                 if (skb_cow_head(skb, 0)) {
 519                         netif_warn(priv, tx_err, dev,
 520                                         "GSO expand head fail.\n");
 521                         goto err_out;
 522                 }
 523                 if (skb_shinfo(skb)->gso_type &
 524                                 (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)) {
 525                         txd->txd4 |= TX_DMA_TSO;
 526                         tcp_hdr(skb)->check = htons(skb_shinfo(skb)->gso_size);
 527                 }
 528         }
 529
 530         mapped_addr = dma_map_single(&dev->dev, skb->data,
 531                         skb_headlen(skb), DMA_TO_DEVICE);
 532         if (unlikely(dma_mapping_error(&dev->dev, mapped_addr)))
 533                 goto err_out;
 534         txd->txd1 = mapped_addr;
 535         txd2 = TX_DMA_PLEN0(skb_headlen(skb));
 536
 537         /* TX SG offload */
 538         j = idx;
 539         for (i = 0; i < nr_frags; i++) {
 540
 541                 frag = &skb_shinfo(skb)->frags[i];
 542                 mapped_addr = skb_frag_dma_map(&dev->dev, frag, 0,
 543                                 skb_frag_size(frag), DMA_TO_DEVICE);
 544                 if (unlikely(dma_mapping_error(&dev->dev, mapped_addr)))
 545                         goto err_dma;
 546
 547                 if (i & 0x1) {
 548                         j = NEXT_TX_DESP_IDX(j);
 549                         txd = &priv->tx_dma[j];
 550                         txd->txd1 = mapped_addr;
 551                         txd2 = TX_DMA_PLEN0(frag->size);
 552                         txd->txd4 = def_txd4;
 553                 } else {
 554                         txd->txd3 = mapped_addr;
 555                         txd2 |= TX_DMA_PLEN1(frag->size);
 556                         if (i != (nr_frags -1))
 557                                 txd->txd2 = txd2;
 558                         priv->tx_skb[j] = (struct sk_buff *) DMA_DUMMY_DESC;
 559                 }
 560         }
 561
 562         /* set last segment */
 563         if (nr_frags & 0x1)
 564                 txd->txd2 = (txd2 | TX_DMA_LS1);
 565         else
 566                 txd->txd2 = (txd2 | TX_DMA_LS0);
 567
 568         /* store skb to cleanup */
 569         priv->tx_skb[j] = skb;
 570
 571         wmb();
 572         j = NEXT_TX_DESP_IDX(j);
 573         fe_reg_w32(j, FE_REG_TX_CTX_IDX0);
 574
 575         return 0;
 576
 577 err_dma:
 578         /* unmap dma */
 579         txd = &priv->tx_dma[idx];
 580         txd_unmap_single(&dev->dev, txd);
 581
 582         j = idx;
 583         unmap_idx = i;
 584         for (i = 0; i < unmap_idx; i++) {
 585                 if (i & 0x1) {
 586                         j = NEXT_TX_DESP_IDX(j);
 587                         txd = &priv->tx_dma[j];
 588                         txd_unmap_page0(&dev->dev, txd);
 589                 } else {
 590                         txd_unmap_page1(&dev->dev, txd);
 591                 }
 592         }
 593
 594 err_out:
 595         /* reinit descriptors and skb */
 596         j = idx;
 597         for (i = 0; i < tx_num; i++) {
 598                 priv->tx_dma[j].txd2 = TX_DMA_DESP2_DEF;
 599                 priv->tx_skb[j] = NULL;
 600                 j = NEXT_TX_DESP_IDX(j);
 601         }
 602         wmb();
 603
 604         return -1;
 605 }
 606
 607 static inline int fe_skb_padto(struct sk_buff *skb, struct fe_priv *priv) {
 608         unsigned int len;
 609         int ret;
 610
 611         ret = 0;
 612         if (unlikely(skb->len < VLAN_ETH_ZLEN)) {
 613                 if ((priv->flags & FE_FLAG_PADDING_64B) &&
 614                                 !(priv->flags & FE_FLAG_PADDING_BUG))
 615                         return ret;
 616
 617                 if (vlan_tx_tag_present(skb))
 618                         len = ETH_ZLEN;
 619                 else if (skb->protocol == cpu_to_be16(ETH_P_8021Q))
 620                         len = VLAN_ETH_ZLEN;
 621                 else if(!(priv->flags & FE_FLAG_PADDING_64B))
 622                         len = ETH_ZLEN;
 623                 else
 624                         return ret;
 625
 626                 if (skb->len < len) {
 627                         if ((ret = skb_pad(skb, len - skb->len)) < 0)
 628                                 return ret;
 629                         skb->len = len;
 630                         skb_set_tail_pointer(skb, len);
 631                 }
 632         }
 633
 634         return ret;
 635 }
 636
 637 static inline u32 fe_empty_txd(struct fe_priv *priv, u32 tx_fill_idx)
 638 {
 639         return (u32)(NUM_DMA_DESC - ((tx_fill_idx - priv->tx_free_idx) &
 640                                 (NUM_DMA_DESC - 1)));
 641 }
 642
 643 static int fe_start_xmit(struct sk_buff *skb, struct net_device *dev)
 644 {
 645         struct fe_priv *priv = netdev_priv(dev);
 646         struct net_device_stats *stats = &dev->stats;
 647         u32 tx;
 648         int tx_num;
 649
 650         if (fe_skb_padto(skb, priv)) {
 651                 netif_warn(priv, tx_err, dev, "tx padding failed!\n");
 652                 return NETDEV_TX_OK;
 653         }
 654
 655         spin_lock(&priv->page_lock);
 656         tx_num = 1 + (skb_shinfo(skb)->nr_frags >> 1);
 657         tx = fe_reg_r32(FE_REG_TX_CTX_IDX0);
 658         if (unlikely(fe_empty_txd(priv, tx) <= tx_num))
 659         {
 660                 netif_stop_queue(dev);
 661                 spin_unlock(&priv->page_lock);
 662                 netif_err(priv, tx_queued,dev,
 663                                 "Tx Ring full when queue awake!\n");
 664                 return NETDEV_TX_BUSY;
 665         }
 666
 667         if (fe_tx_map_dma(skb, dev, tx) < 0) {
 668                 kfree_skb(skb);
 669
 670                 stats->tx_dropped++;
 671         } else {
 672                 netdev_sent_queue(dev, skb->len);
 673                 skb_tx_timestamp(skb);
 674
 675                 stats->tx_packets++;
 676                 stats->tx_bytes += skb->len;
 677         }
 678
 679         spin_unlock(&priv->page_lock);
 680
 681         return NETDEV_TX_OK;
 682 }
 683
 684 static inline void fe_rx_vlan(struct sk_buff *skb)
 685 {
 686         struct ethhdr *ehdr;
 687         u16 vlanid;
 688
 689         if (!__vlan_get_tag(skb, &vlanid)) {
 690                 /* pop the vlan tag */
 691                 ehdr = (struct ethhdr *)skb->data;
 692                 memmove(skb->data + VLAN_HLEN, ehdr, ETH_ALEN * 2);
 693                 skb_pull(skb, VLAN_HLEN);
 694                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlanid);
 695         }
 696 }
 697
 698 static int fe_poll_rx(struct napi_struct *napi, int budget,
 699                 struct fe_priv *priv)
 700 {
 701         struct net_device *netdev = priv->netdev;
 702         struct net_device_stats *stats = &netdev->stats;
 703         struct fe_soc_data *soc = priv->soc;
 704         u32 checksum_bit;
 705         int idx = fe_reg_r32(FE_REG_RX_CALC_IDX0);
 706         struct sk_buff *skb;
 707         u8 *data, *new_data;
 708         struct fe_rx_dma *rxd;
 709         int done = 0;
 710         bool rx_vlan = netdev->features & NETIF_F_HW_VLAN_CTAG_RX;
 711
 712         if (netdev->features & NETIF_F_RXCSUM)
 713                 checksum_bit = soc->checksum_bit;
 714         else
 715                 checksum_bit = 0;
 716
 717         while (done < budget) {
 718                 unsigned int pktlen;
 719                 dma_addr_t dma_addr;
 720                 idx = NEXT_RX_DESP_IDX(idx);
 721                 rxd = &priv->rx_dma[idx];
 722                 data = priv->rx_data[idx];
 723
 724                 if (!(rxd->rxd2 & RX_DMA_DONE))
 725                         break;
 726
 727                 /* alloc new buffer */
 728                 new_data = netdev_alloc_frag(priv->frag_size);
 729                 if (unlikely(!new_data)) {
 730                         stats->rx_dropped++;
 731                         goto release_desc;
 732                 }
 733                 dma_addr = dma_map_single(&netdev->dev,
 734                                 new_data + FE_RX_OFFSET,
 735                                 priv->rx_buf_size,
 736                                 DMA_FROM_DEVICE);
 737                 if (unlikely(dma_mapping_error(&netdev->dev, dma_addr))) {
 738                         put_page(virt_to_head_page(new_data));
 739                         goto release_desc;
 740                 }
 741
 742                 /* receive data */
 743                 skb = build_skb(data, priv->frag_size);
 744                 if (unlikely(!skb)) {
 745                         put_page(virt_to_head_page(new_data));
 746                         goto release_desc;
 747                 }
 748                 skb_reserve(skb, FE_RX_OFFSET);
 749
 750                 dma_unmap_single(&netdev->dev, rxd->rxd1,
 751                                 priv->rx_buf_size, DMA_FROM_DEVICE);
 752                 pktlen = RX_DMA_PLEN0(rxd->rxd2);
 753                 skb_put(skb, pktlen);
 754                 skb->dev = netdev;
 755                 if (rxd->rxd4 & checksum_bit) {
 756                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 757                 } else {
 758                         skb_checksum_none_assert(skb);
 759                 }
 760                 if (rx_vlan)
 761                         fe_rx_vlan(skb);
 762                 skb->protocol = eth_type_trans(skb, netdev);
 763
 764                 stats->rx_packets++;
 765                 stats->rx_bytes += pktlen;
 766
 767                 napi_gro_receive(napi, skb);
 768
 769                 priv->rx_data[idx] = new_data;
 770                 rxd->rxd1 = (unsigned int) dma_addr;
 771
 772 release_desc:
 773                 if (soc->rx_dma)
 774                         soc->rx_dma(priv, idx, priv->rx_buf_size);
 775                 else
 776                         rxd->rxd2 = RX_DMA_LSO;
 777
 778                 wmb();
 779                 fe_reg_w32(idx, FE_REG_RX_CALC_IDX0);
 780                 done++;
 781         }
 782
 783         return done;
 784 }
 785
 786 static int fe_poll_tx(struct fe_priv *priv, int budget)
 787 {
 788         struct net_device *netdev = priv->netdev;
 789         struct device *dev = &netdev->dev;
 790         unsigned int bytes_compl = 0;
 791         struct sk_buff *skb;
 792         struct fe_tx_dma *txd;
 793         int done = 0, idx;
 794         u32 udf_bit = priv->soc->tx_udf_bit;
 795
 796         idx = priv->tx_free_idx;
 797         while (done < budget) {
 798                 txd = &priv->tx_dma[idx];
 799                 skb = priv->tx_skb[idx];
 800
 801                 if (!(txd->txd2 & TX_DMA_DONE) || !skb)
 802                         break;
 803
 804                 txd_unmap_page1(dev, txd);
 805
 806                 if (txd->txd4 & udf_bit)
 807                         txd_unmap_single(dev, txd);
 808                 else
 809                         txd_unmap_page0(dev, txd);
 810
 811                 if (skb != (struct sk_buff *) DMA_DUMMY_DESC) {
 812                         bytes_compl += skb->len;
 813                         dev_kfree_skb_any(skb);
 814                         done++;
 815                 }
 816                 priv->tx_skb[idx] = NULL;
 817                 idx = NEXT_TX_DESP_IDX(idx);
 818         }
 819         priv->tx_free_idx = idx;
 820
 821         if (!done)
 822                 return 0;
 823
 824         netdev_completed_queue(netdev, done, bytes_compl);
 825         if (unlikely(netif_queue_stopped(netdev) &&
 826                                 netif_carrier_ok(netdev))) {
 827                 netif_wake_queue(netdev);
 828         }
 829
 830         return done;
 831 }
 832
 833 static int fe_poll(struct napi_struct *napi, int budget)
 834 {
 835         struct fe_priv *priv = container_of(napi, struct fe_priv, rx_napi);
 836         struct fe_hw_stats *hwstat = priv->hw_stats;
 837         int tx_done, rx_done;
 838         u32 status, mask;
 839         u32 tx_intr, rx_intr;
 840
 841         status = fe_reg_r32(FE_REG_FE_INT_STATUS);
 842         tx_intr = priv->soc->tx_dly_int;
 843         rx_intr = priv->soc->rx_dly_int;
 844         tx_done = rx_done = 0;
 845
 846 poll_again:
 847         if (status & tx_intr) {
 848                 tx_done += fe_poll_tx(priv, budget - tx_done);
 849                 if (tx_done < budget) {
 850                         fe_reg_w32(tx_intr, FE_REG_FE_INT_STATUS);
 851                 }
 852                 status = fe_reg_r32(FE_REG_FE_INT_STATUS);
 853         }
 854
 855         if (status & rx_intr) {
 856                 rx_done += fe_poll_rx(napi, budget - rx_done, priv);
 857                 if (rx_done < budget) {
 858                         fe_reg_w32(rx_intr, FE_REG_FE_INT_STATUS);
 859                 }
 860         }
 861
 862         if (unlikely(hwstat && (status & FE_CNT_GDM_AF))) {
 863                 if (spin_trylock(&hwstat->stats_lock)) {
 864                         fe_stats_update(priv);
 865                         spin_unlock(&hwstat->stats_lock);
 866                 }
 867                 fe_reg_w32(FE_CNT_GDM_AF, FE_REG_FE_INT_STATUS);
 868         }
 869
 870         if (unlikely(netif_msg_intr(priv))) {
 871                 mask = fe_reg_r32(FE_REG_FE_INT_ENABLE);
 872                 netdev_info(priv->netdev,
 873                                 "done tx %d, rx %d, intr 0x%x/0x%x\n",
 874                                 tx_done, rx_done, status, mask);
 875         }
 876
 877         if ((tx_done < budget) && (rx_done < budget)) {
 878                 status = fe_reg_r32(FE_REG_FE_INT_STATUS);
 879                 if (status & (tx_intr | rx_intr )) {
 880                         goto poll_again;
 881                 }
 882                 napi_complete(napi);
 883                 fe_int_enable(tx_intr | rx_intr);
 884         }
 885
 886         return rx_done;
 887 }
 888
 889 static void fe_tx_timeout(struct net_device *dev)
 890 {
 891         struct fe_priv *priv = netdev_priv(dev);
 892
 893         priv->netdev->stats.tx_errors++;
 894         netif_err(priv, tx_err, dev,
 895                         "transmit timed out, waking up the queue\n");
 896         netif_info(priv, drv, dev, ": dma_cfg:%08x, free_idx:%d, " \
 897                         "dma_ctx_idx=%u, dma_crx_idx=%u\n",
 898                         fe_reg_r32(FE_REG_PDMA_GLO_CFG), priv->tx_free_idx,
 899                         fe_reg_r32(FE_REG_TX_CTX_IDX0),
 900                         fe_reg_r32(FE_REG_RX_CALC_IDX0));
 901         netif_wake_queue(dev);
 902 }
 903
 904 static irqreturn_t fe_handle_irq(int irq, void *dev)
 905 {
 906         struct fe_priv *priv = netdev_priv(dev);
 907         u32 status, dly_int;
 908
 909         status = fe_reg_r32(FE_REG_FE_INT_STATUS);
 910
 911         if (unlikely(!status))
 912                 return IRQ_NONE;
 913
 914         dly_int = (priv->soc->rx_dly_int | priv->soc->tx_dly_int);
 915         if (likely(status & dly_int)) {
 916                 fe_int_disable(dly_int);
 917                 napi_schedule(&priv->rx_napi);
 918         } else {
 919                 fe_reg_w32(status, FE_REG_FE_INT_STATUS);
 920         }
 921
 922         return IRQ_HANDLED;
 923 }
 924
 925 #ifdef CONFIG_NET_POLL_CONTROLLER
 926 static void fe_poll_controller(struct net_device *dev)
 927 {
 928         struct fe_priv *priv = netdev_priv(dev);
 929         u32 dly_int = priv->soc->tx_dly_int | priv->soc->rx_dly_int;
 930
 931         fe_int_disable(dly_int);
 932         fe_handle_irq(dev->irq, dev);
 933         fe_int_enable(dly_int);
 934 }
 935 #endif
 936
 937 int fe_set_clock_cycle(struct fe_priv *priv)
 938 {
 939         unsigned long sysclk = priv->sysclk;
 940
 941         if (!sysclk) {
 942                 return -EINVAL;
 943         }
 944
 945         sysclk /= FE_US_CYC_CNT_DIVISOR;
 946         sysclk <<= FE_US_CYC_CNT_SHIFT;
 947
 948         fe_w32((fe_r32(FE_FE_GLO_CFG) &
 949                                 ~(FE_US_CYC_CNT_MASK << FE_US_CYC_CNT_SHIFT)) |
 950                         sysclk,
 951                         FE_FE_GLO_CFG);
 952         return 0;
 953 }
 954
 955 void fe_fwd_config(struct fe_priv *priv)
 956 {
 957         u32 fwd_cfg;
 958
 959         fwd_cfg = fe_r32(FE_GDMA1_FWD_CFG);
 960
 961         /* disable jumbo frame */
 962         if (priv->flags & FE_FLAG_JUMBO_FRAME)
 963                 fwd_cfg &= ~FE_GDM1_JMB_EN;
 964
 965         /* set unicast/multicast/broadcast frame to cpu */
 966         fwd_cfg &= ~0xffff;
 967
 968         fe_w32(fwd_cfg, FE_GDMA1_FWD_CFG);
 969 }
 970
 971 static void fe_rxcsum_config(bool enable)
 972 {
 973         if (enable)
 974                 fe_w32(fe_r32(FE_GDMA1_FWD_CFG) | (FE_GDM1_ICS_EN |
 975                                         FE_GDM1_TCS_EN | FE_GDM1_UCS_EN),
 976                                 FE_GDMA1_FWD_CFG);
 977         else
 978                 fe_w32(fe_r32(FE_GDMA1_FWD_CFG) & ~(FE_GDM1_ICS_EN |
 979                                         FE_GDM1_TCS_EN | FE_GDM1_UCS_EN),
 980                                 FE_GDMA1_FWD_CFG);
 981 }
 982
 983 static void fe_txcsum_config(bool enable)
 984 {
 985         if (enable)
 986                 fe_w32(fe_r32(FE_CDMA_CSG_CFG) | (FE_ICS_GEN_EN |
 987                                         FE_TCS_GEN_EN | FE_UCS_GEN_EN),
 988                                 FE_CDMA_CSG_CFG);
 989         else
 990                 fe_w32(fe_r32(FE_CDMA_CSG_CFG) & ~(FE_ICS_GEN_EN |
 991                                         FE_TCS_GEN_EN | FE_UCS_GEN_EN),
 992                                 FE_CDMA_CSG_CFG);
 993 }
 994
 995 void fe_csum_config(struct fe_priv *priv)
 996 {
 997         struct net_device *dev = priv_netdev(priv);
 998
 999         fe_txcsum_config((dev->features & NETIF_F_IP_CSUM));
1000         fe_rxcsum_config((dev->features & NETIF_F_RXCSUM));
1001 }
1002
1003 static int fe_hw_init(struct net_device *dev)
1004 {
1005         struct fe_priv *priv = netdev_priv(dev);
1006         int i, err;
1007
1008         err = devm_request_irq(priv->device, dev->irq, fe_handle_irq, 0,
1009                                 dev_name(priv->device), dev);
1010         if (err)
1011                 return err;
1012
1013         if (priv->soc->set_mac)
1014                 priv->soc->set_mac(priv, dev->dev_addr);
1015         else
1016                 fe_hw_set_macaddr(priv, dev->dev_addr);
1017
1018         fe_reg_w32(FE_DELAY_INIT, FE_REG_DLY_INT_CFG);
1019
1020         fe_int_disable(priv->soc->tx_dly_int | priv->soc->rx_dly_int);
1021
1022         /* frame engine will push VLAN tag regarding to VIDX feild in Tx desc. */
1023         if (fe_reg_table[FE_REG_FE_DMA_VID_BASE])
1024                 for (i = 0; i < 16; i += 2)
1025                         fe_w32(((i + 1) << 16) + i,
1026                                         fe_reg_table[FE_REG_FE_DMA_VID_BASE] +
1027                                         (i * 2));
1028
1029         BUG_ON(!priv->soc->fwd_config);
1030         if (priv->soc->fwd_config(priv))
1031                 netdev_err(dev, "unable to get clock\n");
1032
1033         if (fe_reg_table[FE_REG_FE_RST_GL]) {
1034                 fe_reg_w32(1, FE_REG_FE_RST_GL);
1035                 fe_reg_w32(0, FE_REG_FE_RST_GL);
1036         }
1037
1038         return 0;
1039 }
1040
1041 static int fe_open(struct net_device *dev)
1042 {
1043         struct fe_priv *priv = netdev_priv(dev);
1044         unsigned long flags;
1045         u32 val;
1046         int err;
1047
1048         err = fe_init_dma(priv);
1049         if (err)
1050                 goto err_out;
1051
1052         spin_lock_irqsave(&priv->page_lock, flags);
1053         napi_enable(&priv->rx_napi);
1054
1055         val = FE_TX_WB_DDONE | FE_RX_DMA_EN | FE_TX_DMA_EN;
1056         val |= priv->soc->pdma_glo_cfg;
1057         fe_reg_w32(val, FE_REG_PDMA_GLO_CFG);
1058
1059         spin_unlock_irqrestore(&priv->page_lock, flags);
1060
1061         if (priv->phy)
1062                 priv->phy->start(priv);
1063
1064         if (priv->soc->has_carrier && priv->soc->has_carrier(priv))
1065                 netif_carrier_on(dev);
1066
1067         netif_start_queue(dev);
1068         fe_int_enable(priv->soc->tx_dly_int | priv->soc->rx_dly_int);
1069
1070         return 0;
1071
1072 err_out:
1073         fe_free_dma(priv);
1074         return err;
1075 }
1076
1077 static int fe_stop(struct net_device *dev)
1078 {
1079         struct fe_priv *priv = netdev_priv(dev);
1080         unsigned long flags;
1081         int i;
1082
1083         fe_int_disable(priv->soc->tx_dly_int | priv->soc->rx_dly_int);
1084
1085         netif_tx_disable(dev);
1086
1087         if (priv->phy)
1088                 priv->phy->stop(priv);
1089
1090         spin_lock_irqsave(&priv->page_lock, flags);
1091         napi_disable(&priv->rx_napi);
1092
1093         fe_reg_w32(fe_reg_r32(FE_REG_PDMA_GLO_CFG) &
1094                      ~(FE_TX_WB_DDONE | FE_RX_DMA_EN | FE_TX_DMA_EN),
1095                      FE_REG_PDMA_GLO_CFG);
1096         spin_unlock_irqrestore(&priv->page_lock, flags);
1097
1098         /* wait dma stop */
1099         for (i = 0; i < 10; i++) {
1100                 if (fe_reg_r32(FE_REG_PDMA_GLO_CFG) &
1101                                 (FE_TX_DMA_BUSY | FE_RX_DMA_BUSY)) {
1102                         msleep(10);
1103                         continue;
1104                 }
1105                 break;
1106         }
1107
1108         fe_free_dma(priv);
1109
1110         return 0;
1111 }
1112
1113 static int __init fe_init(struct net_device *dev)
1114 {
1115         struct fe_priv *priv = netdev_priv(dev);
1116         struct device_node *port;
1117         int err;
1118
1119         BUG_ON(!priv->soc->reset_fe);
1120         priv->soc->reset_fe();
1121
1122         if (priv->soc->switch_init)
1123                 priv->soc->switch_init(priv);
1124
1125         memcpy(dev->dev_addr, priv->soc->mac, ETH_ALEN);
1126         of_get_mac_address_mtd(priv->device->of_node, dev->dev_addr);
1127
1128         err = fe_mdio_init(priv);
1129         if (err)
1130                 return err;
1131
1132         if (priv->soc->port_init)
1133                 for_each_child_of_node(priv->device->of_node, port)
1134                         if (of_device_is_compatible(port, "ralink,eth-port") && of_device_is_available(port))
1135                                 priv->soc->port_init(priv, port);
1136
1137         if (priv->phy) {
1138                 err = priv->phy->connect(priv);
1139                 if (err)
1140                         goto err_phy_disconnect;
1141         }
1142
1143         err = fe_hw_init(dev);
1144         if (err)
1145                 goto err_phy_disconnect;
1146
1147         if (priv->soc->switch_config)
1148                 priv->soc->switch_config(priv);
1149
1150         return 0;
1151
1152 err_phy_disconnect:
1153         if (priv->phy)
1154                 priv->phy->disconnect(priv);
1155         fe_mdio_cleanup(priv);
1156
1157         return err;
1158 }
1159
1160 static void fe_uninit(struct net_device *dev)
1161 {
1162         struct fe_priv *priv = netdev_priv(dev);
1163
1164         if (priv->phy)
1165                 priv->phy->disconnect(priv);
1166         fe_mdio_cleanup(priv);
1167
1168         fe_reg_w32(0, FE_REG_FE_INT_ENABLE);
1169         free_irq(dev->irq, dev);
1170 }
1171
1172 static int fe_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1173 {
1174         struct fe_priv *priv = netdev_priv(dev);
1175
1176         if (!priv->phy_dev)
1177                 return -ENODEV;
1178
1179         switch (cmd) {
1180         case SIOCETHTOOL:
1181                 return phy_ethtool_ioctl(priv->phy_dev,
1182                                 (void *) ifr->ifr_data);
1183         case SIOCGMIIPHY:
1184         case SIOCGMIIREG:
1185         case SIOCSMIIREG:
1186                 return phy_mii_ioctl(priv->phy_dev, ifr, cmd);
1187         default:
1188                 break;
1189         }
1190
1191         return -EOPNOTSUPP;
1192 }
1193
1194 static int fe_change_mtu(struct net_device *dev, int new_mtu)
1195 {
1196         struct fe_priv *priv = netdev_priv(dev);
1197         int frag_size, old_mtu;
1198         u32 fwd_cfg;
1199
1200         if (!(priv->flags & FE_FLAG_JUMBO_FRAME))
1201                 return eth_change_mtu(dev, new_mtu);
1202
1203         frag_size = fe_max_frag_size(new_mtu);
1204         if (new_mtu < 68 || frag_size > PAGE_SIZE)
1205                 return -EINVAL;
1206
1207         old_mtu = dev->mtu;
1208         dev->mtu = new_mtu;
1209
1210         /* return early if the buffer sizes will not change */
1211         if (old_mtu <= ETH_DATA_LEN && new_mtu <= ETH_DATA_LEN)
1212                 return 0;
1213         if (old_mtu > ETH_DATA_LEN && new_mtu > ETH_DATA_LEN)
1214                 return 0;
1215
1216         if (new_mtu <= ETH_DATA_LEN) {
1217                 priv->frag_size = fe_max_frag_size(ETH_DATA_LEN);
1218                 priv->rx_buf_size = fe_max_buf_size(ETH_DATA_LEN);
1219         } else {
1220                 priv->frag_size = PAGE_SIZE;
1221                 priv->rx_buf_size = fe_max_buf_size(PAGE_SIZE);
1222         }
1223
1224         if (!netif_running(dev))
1225                 return 0;
1226
1227         fe_stop(dev);
1228         fwd_cfg = fe_r32(FE_GDMA1_FWD_CFG);
1229         if (new_mtu <= ETH_DATA_LEN)
1230                 fwd_cfg &= ~FE_GDM1_JMB_EN;
1231         else {
1232                 fwd_cfg &= ~(FE_GDM1_JMB_LEN_MASK << FE_GDM1_JMB_LEN_SHIFT);
1233                 fwd_cfg |= (DIV_ROUND_UP(frag_size, 1024) <<
1234                                 FE_GDM1_JMB_LEN_SHIFT) | FE_GDM1_JMB_EN;
1235         }
1236         fe_w32(fwd_cfg, FE_GDMA1_FWD_CFG);
1237
1238         return fe_open(dev);
1239 }
1240
1241 static const struct net_device_ops fe_netdev_ops = {
1242         .ndo_init               = fe_init,
1243         .ndo_uninit             = fe_uninit,
1244         .ndo_open               = fe_open,
1245         .ndo_stop               = fe_stop,
1246         .ndo_start_xmit         = fe_start_xmit,
1247         .ndo_set_mac_address    = fe_set_mac_address,
1248         .ndo_validate_addr      = eth_validate_addr,
1249         .ndo_do_ioctl           = fe_do_ioctl,
1250         .ndo_change_mtu         = fe_change_mtu,
1251         .ndo_tx_timeout         = fe_tx_timeout,
1252         .ndo_get_stats64        = fe_get_stats64,
1253         .ndo_vlan_rx_add_vid    = fe_vlan_rx_add_vid,
1254         .ndo_vlan_rx_kill_vid   = fe_vlan_rx_kill_vid,
1255 #ifdef CONFIG_NET_POLL_CONTROLLER
1256         .ndo_poll_controller    = fe_poll_controller,
1257 #endif
1258 };
1259
1260 static int fe_probe(struct platform_device *pdev)
1261 {
1262         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1263         const struct of_device_id *match;
1264         struct fe_soc_data *soc;
1265         struct net_device *netdev;
1266         struct fe_priv *priv;
1267         struct clk *sysclk;
1268         int err;
1269
1270         device_reset(&pdev->dev);
1271
1272         match = of_match_device(of_fe_match, &pdev->dev);
1273         soc = (struct fe_soc_data *) match->data;
1274
1275         if (soc->reg_table)
1276                 fe_reg_table = soc->reg_table;
1277         else
1278                 soc->reg_table = fe_reg_table;
1279
1280         fe_base = devm_request_and_ioremap(&pdev->dev, res);
1281         if (!fe_base) {
1282                 err = -EADDRNOTAVAIL;
1283                 goto err_out;
1284         }
1285
1286         netdev = alloc_etherdev(sizeof(*priv));
1287         if (!netdev) {
1288                 dev_err(&pdev->dev, "alloc_etherdev failed\n");
1289                 err = -ENOMEM;
1290                 goto err_iounmap;
1291         }
1292
1293         SET_NETDEV_DEV(netdev, &pdev->dev);
1294         netdev->netdev_ops = &fe_netdev_ops;
1295         netdev->base_addr = (unsigned long) fe_base;
1296         netdev->watchdog_timeo = TX_TIMEOUT;
1297
1298         netdev->irq = platform_get_irq(pdev, 0);
1299         if (netdev->irq < 0) {
1300                 dev_err(&pdev->dev, "no IRQ resource found\n");
1301                 err = -ENXIO;
1302                 goto err_free_dev;
1303         }
1304
1305         if (soc->init_data)
1306                 soc->init_data(soc, netdev);
1307         /* fake NETIF_F_HW_VLAN_CTAG_RX for good GRO performance */
1308         netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX;
1309         netdev->vlan_features = netdev->hw_features &
1310                 ~(NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX);
1311         netdev->features |= netdev->hw_features;
1312
1313         /* fake rx vlan filter func. to support tx vlan offload func */
1314         if (fe_reg_table[FE_REG_FE_DMA_VID_BASE])
1315                 netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1316
1317         priv = netdev_priv(netdev);
1318         spin_lock_init(&priv->page_lock);
1319         if (fe_reg_table[FE_REG_FE_COUNTER_BASE]) {
1320                 priv->hw_stats = kzalloc(sizeof(*priv->hw_stats), GFP_KERNEL);
1321                 if (!priv->hw_stats) {
1322                         err = -ENOMEM;
1323                         goto err_free_dev;
1324                 }
1325                 spin_lock_init(&priv->hw_stats->stats_lock);
1326         }
1327
1328         sysclk = devm_clk_get(&pdev->dev, NULL);
1329         if (!IS_ERR(sysclk))
1330                 priv->sysclk = clk_get_rate(sysclk);
1331
1332         priv->netdev = netdev;
1333         priv->device = &pdev->dev;
1334         priv->soc = soc;
1335         priv->msg_enable = netif_msg_init(fe_msg_level, FE_DEFAULT_MSG_ENABLE);
1336         priv->frag_size = fe_max_frag_size(ETH_DATA_LEN);
1337         priv->rx_buf_size = fe_max_buf_size(ETH_DATA_LEN);
1338         if (priv->frag_size > PAGE_SIZE) {
1339                 dev_err(&pdev->dev, "error frag size.\n");
1340                 err = -EINVAL;
1341                 goto err_free_dev;
1342         }
1343
1344         netif_napi_add(netdev, &priv->rx_napi, fe_poll, 32);
1345         fe_set_ethtool_ops(netdev);
1346
1347         err = register_netdev(netdev);
1348         if (err) {
1349                 dev_err(&pdev->dev, "error bringing up device\n");
1350                 goto err_free_dev;
1351         }
1352
1353         platform_set_drvdata(pdev, netdev);
1354
1355         netif_info(priv, probe, netdev, "ralink at 0x%08lx, irq %d\n",
1356                         netdev->base_addr, netdev->irq);
1357
1358         return 0;
1359
1360 err_free_dev:
1361         free_netdev(netdev);
1362 err_iounmap:
1363         devm_iounmap(&pdev->dev, fe_base);
1364 err_out:
1365         return err;
1366 }
1367
1368 static int fe_remove(struct platform_device *pdev)
1369 {
1370         struct net_device *dev = platform_get_drvdata(pdev);
1371         struct fe_priv *priv = netdev_priv(dev);
1372
1373         netif_napi_del(&priv->rx_napi);
1374         if (priv->hw_stats)
1375                 kfree(priv->hw_stats);
1376
1377         unregister_netdev(dev);
1378         free_netdev(dev);
1379         platform_set_drvdata(pdev, NULL);
1380
1381         return 0;
1382 }
1383
1384 static struct platform_driver fe_driver = {
1385         .probe = fe_probe,
1386         .remove = fe_remove,
1387         .driver = {
1388                 .name = "ralink_soc_eth",
1389                 .owner = THIS_MODULE,
1390                 .of_match_table = of_fe_match,
1391         },
1392 };
1393
1394 static int __init init_rtfe(void)
1395 {
1396         int ret;
1397
1398         ret = rtesw_init();
1399         if (ret)
1400                 return ret;
1401
1402         ret = platform_driver_register(&fe_driver);
1403         if (ret)
1404                 rtesw_exit();
1405
1406         return ret;
1407 }
1408
1409 static void __exit exit_rtfe(void)
1410 {
1411         platform_driver_unregister(&fe_driver);
1412         rtesw_exit();
1413 }
1414
1415 module_init(init_rtfe);
1416 module_exit(exit_rtfe);
1417
1418 MODULE_LICENSE("GPL");
1419 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
1420 MODULE_DESCRIPTION("Ethernet driver for Ralink SoC");
1421 MODULE_VERSION(FE_DRV_VERSION);